Skip to content

Commit

Permalink
Add active_by_default to import_functions and export_functions
Browse files Browse the repository at this point in the history 
Re #316
  • Loading branch information
@soininen
soininen committed Jan 15, 2024
1 parent 7441bfb commit 8775ef0
Show file tree
Hide file tree
Showing 4 changed files with 145 additions and 92 deletions.
7 changes: 2 additions & 5 deletions spinedb_api/export_functions.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,10 +8,7 @@
# Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
######################################################################################################################

"""
Functions for exporting data from a Spine database in a standard format.
"""
""" Functions for exporting data from a Spine database in a standard format. """
from operator import itemgetter

from sqlalchemy.util import KeyedTuple
Expand Down Expand Up @@ -122,7 +119,7 @@ def export_parameter_value_lists(db_map, ids=Asterisk, parse_value=from_database
def export_entity_classes(db_map, ids=Asterisk):
return sorted(
(
(x.name, x.dimension_name_list, x.description, x.display_icon)
(x.name, x.dimension_name_list, x.description, x.display_icon, x.active_by_default)
for x in _get_items(db_map, "entity_class", ids)
),
key=lambda x: (len(x[1]), x[0]),
Expand Down
6 changes: 3 additions & 3 deletions spinedb_api/import_functions.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -262,8 +262,8 @@ def import_entity_classes(db_map, data):
Args:
db_map (spinedb_api.DiffDatabaseMapping): database mapping
data (list(tuple(str,tuple,str,int)): tuples of
(name, dimension name tuple, description, display icon integer)
data (list(tuple(str,tuple,str,int,bool)): tuples of
(name, dimension name tuple, description, display icon integer, active by default flag)
Returns:
int: number of items imported
Expand Down Expand Up @@ -471,7 +471,7 @@ def import_relationship_parameter_value_metadata(db_map, data):
def _get_entity_classes_for_import(db_map, data):
dim_name_list_by_name = {}
items = []
key = ("name", "dimension_name_list", "description", "display_icon")
key = ("name", "dimension_name_list", "description", "display_icon", "active_by_default")
for x in data:
if isinstance(x, str):
x = x, ()
Expand Down
181 changes: 102 additions & 79 deletions tests/test_export_functions.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,17 +8,14 @@
# Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
######################################################################################################################

"""
Unit tests for export_functions.
"""
""" Unit tests for export_functions. """

import unittest
from spinedb_api import (
DatabaseMapping,
export_alternatives,
export_data,
export_entity_classes,
export_scenarios,
export_scenario_alternatives,
import_alternatives,
Expand All @@ -37,91 +34,117 @@


class TestExportFunctions(unittest.TestCase):
def setUp(self):
db_url = "sqlite://"
self._db_map = DatabaseMapping(db_url, username="UnitTest", create=True)
def _assert_import_success(self, result):
errors = result[1]
self.assertEqual(errors, [])

def tearDown(self):
self._db_map.close()
def _assert_addition_success(self, result):
error = result[1]
self.assertIsNone(error)

def test_export_alternatives(self):
import_alternatives(self._db_map, [("alternative", "Description")])
exported = export_alternatives(self._db_map)
self.assertEqual(exported, [("Base", "Base alternative"), ("alternative", "Description")])
with DatabaseMapping("sqlite://", username="UnitTest", create=True) as db_map:
self._assert_import_success(import_alternatives(db_map, [("alternative", "Description")]))
exported = export_alternatives(db_map)
self.assertEqual(exported, [("Base", "Base alternative"), ("alternative", "Description")])

def test_export_scenarios(self):
import_scenarios(self._db_map, [("scenario", False, "Description")])
exported = export_scenarios(self._db_map)
self.assertEqual(exported, [("scenario", False, "Description")])
with DatabaseMapping("sqlite://", username="UnitTest", create=True) as db_map:
self._assert_import_success(import_scenarios(db_map, [("scenario", False, "Description")]))
exported = export_scenarios(db_map)
self.assertEqual(exported, [("scenario", False, "Description")])

def test_export_scenario_alternatives(self):
import_alternatives(self._db_map, ["alternative"])
import_scenarios(self._db_map, ["scenario"])
import_scenario_alternatives(self._db_map, (("scenario", "alternative"),))
exported = export_scenario_alternatives(self._db_map)
self.assertEqual(exported, [("scenario", "alternative", None)])
with DatabaseMapping("sqlite://", username="UnitTest", create=True) as db_map:
self._assert_import_success(import_alternatives(db_map, ["alternative"]))
self._assert_import_success(import_scenarios(db_map, ["scenario"]))
self._assert_import_success(import_scenario_alternatives(db_map, (("scenario", "alternative"),)))
exported = export_scenario_alternatives(db_map)
self.assertEqual(exported, [("scenario", "alternative", None)])

def test_export_multiple_scenario_alternatives(self):
import_alternatives(self._db_map, ["alternative1"])
import_alternatives(self._db_map, ["alternative2"])
import_scenarios(self._db_map, ["scenario"])
import_scenario_alternatives(self._db_map, (("scenario", "alternative1"),))
import_scenario_alternatives(self._db_map, (("scenario", "alternative2", "alternative1"),))
exported = export_scenario_alternatives(self._db_map)
self.assertEqual(
set(exported), {("scenario", "alternative2", "alternative1"), ("scenario", "alternative1", None)}
)
with DatabaseMapping("sqlite://", username="UnitTest", create=True) as db_map:
self._assert_import_success(import_alternatives(db_map, ["alternative1"]))
self._assert_import_success(import_alternatives(db_map, ["alternative2"]))
self._assert_import_success(import_scenarios(db_map, ["scenario"]))
self._assert_import_success(import_scenario_alternatives(db_map, (("scenario", "alternative1"),)))
self._assert_import_success(
import_scenario_alternatives(db_map, (("scenario", "alternative2", "alternative1"),))
)
exported = export_scenario_alternatives(db_map)
self.assertEqual(
set(exported), {("scenario", "alternative2", "alternative1"), ("scenario", "alternative1", None)}
)

def test_export_entity_classes(self):
with DatabaseMapping("sqlite://", username="UnitTest", create=True) as db_map:
self._assert_addition_success(db_map.add_entity_class_item(name="Object"))
self._assert_addition_success(
db_map.add_entity_class_item(name="Relation", dimension_name_list=("Object",))
)
exported = export_entity_classes(db_map)
expected = (("Object", (), None, None, False), ("Relation", ("Object",), None, None, True))
self.assertCountEqual(exported, expected)

def test_export_data(self):
import_object_classes(self._db_map, ["object_class"])
import_object_parameters(self._db_map, [("object_class", "object_parameter")])
import_objects(self._db_map, [("object_class", "object")])
import_object_parameter_values(self._db_map, [("object_class", "object", "object_parameter", 2.3)])
import_relationship_classes(self._db_map, [("relationship_class", ["object_class"])])
import_relationship_parameters(self._db_map, [("relationship_class", "relationship_parameter")])
import_relationships(self._db_map, [("relationship_class", ["object"])])
import_relationship_parameter_values(
self._db_map, [("relationship_class", ["object"], "relationship_parameter", 3.14)]
)
import_parameter_value_lists(self._db_map, [("value_list", "5.5"), ("value_list", "6.4")])
import_alternatives(self._db_map, ["alternative"])
import_scenarios(self._db_map, ["scenario"])
import_scenario_alternatives(self._db_map, [("scenario", "alternative")])
exported = export_data(self._db_map)
self.assertEqual(len(exported), 8)
self.assertIn("entity_classes", exported)
self.assertEqual(
exported["entity_classes"],
[("object_class", (), None, None), ("relationship_class", ("object_class",), None, None)],
)
self.assertIn("parameter_definitions", exported)
self.assertEqual(
exported["parameter_definitions"],
[
("object_class", "object_parameter", None, None, None),
("relationship_class", "relationship_parameter", None, None, None),
],
)
self.assertIn("entities", exported)
self.assertEqual(
exported["entities"], [("object_class", "object", None), ("relationship_class", ("object",), None)]
)
self.assertIn("parameter_values", exported)
self.assertEqual(
exported["parameter_values"],
[
("object_class", "object", "object_parameter", 2.3, "Base"),
("relationship_class", ("object",), "relationship_parameter", 3.14, "Base"),
],
)
self.assertIn("parameter_value_lists", exported)
self.assertEqual(exported["parameter_value_lists"], [("value_list", "5.5"), ("value_list", "6.4")])
self.assertIn("alternatives", exported)
self.assertEqual(exported["alternatives"], [("Base", "Base alternative"), ("alternative", None)])
self.assertIn("scenarios", exported)
self.assertEqual(exported["scenarios"], [("scenario", False, None)])
self.assertIn("scenario_alternatives", exported)
self.assertEqual(exported["scenario_alternatives"], [("scenario", "alternative", None)])
with DatabaseMapping("sqlite://", username="UnitTest", create=True) as db_map:
self._assert_import_success(import_object_classes(db_map, ["object_class"]))
self._assert_import_success(import_object_parameters(db_map, [("object_class", "object_parameter")]))
self._assert_import_success(import_objects(db_map, [("object_class", "object")]))
self._assert_import_success(
import_object_parameter_values(db_map, [("object_class", "object", "object_parameter", 2.3)])
)
self._assert_import_success(import_relationship_classes(db_map, [("relationship_class", ["object_class"])]))
self._assert_import_success(
import_relationship_parameters(db_map, [("relationship_class", "relationship_parameter")])
)
self._assert_import_success(import_relationships(db_map, [("relationship_class", ["object"])]))
self._assert_import_success(
import_relationship_parameter_values(
db_map, [("relationship_class", ["object"], "relationship_parameter", 3.14)]
)
)
self._assert_import_success(
import_parameter_value_lists(db_map, [("value_list", "5.5"), ("value_list", "6.4")])
)
self._assert_import_success(import_alternatives(db_map, ["alternative"]))
self._assert_import_success(import_scenarios(db_map, ["scenario"]))
self._assert_import_success(import_scenario_alternatives(db_map, [("scenario", "alternative")]))
exported = export_data(db_map)
self.assertEqual(len(exported), 8)
self.assertIn("entity_classes", exported)
self.assertEqual(
exported["entity_classes"],
[("object_class", (), None, None, False), ("relationship_class", ("object_class",), None, None, True)],
)
self.assertIn("parameter_definitions", exported)
self.assertEqual(
exported["parameter_definitions"],
[
("object_class", "object_parameter", None, None, None),
("relationship_class", "relationship_parameter", None, None, None),
],
)
self.assertIn("entities", exported)
self.assertEqual(
exported["entities"], [("object_class", "object", None), ("relationship_class", ("object",), None)]
)
self.assertIn("parameter_values", exported)
self.assertEqual(
exported["parameter_values"],
[
("object_class", "object", "object_parameter", 2.3, "Base"),
("relationship_class", ("object",), "relationship_parameter", 3.14, "Base"),
],
)
self.assertIn("parameter_value_lists", exported)
self.assertEqual(exported["parameter_value_lists"], [("value_list", "5.5"), ("value_list", "6.4")])
self.assertIn("alternatives", exported)
self.assertEqual(exported["alternatives"], [("Base", "Base alternative"), ("alternative", None)])
self.assertIn("scenarios", exported)
self.assertEqual(exported["scenarios"], [("scenario", False, None)])
self.assertIn("scenario_alternatives", exported)
self.assertEqual(exported["scenario_alternatives"], [("scenario", "alternative", None)])


if __name__ == '__main__':
Expand Down
43 changes: 38 additions & 5 deletions tests/test_import_functions.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,18 +8,15 @@
# Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
######################################################################################################################

"""
Unit tests for import_functions.py.
"""
""" Unit tests for import_functions.py. """

import unittest

from spinedb_api.spine_db_server import _unparse_value
from spinedb_api.db_mapping import DatabaseMapping
from spinedb_api.import_functions import (
import_alternatives,
import_entity_classes,
import_object_classes,
import_object_parameter_values,
import_object_parameters,
Expand Down Expand Up @@ -340,6 +337,42 @@ def test_import_existing_relationship_class_parameter(self):
db_map.close()


class TestImportEntityClasses(unittest.TestCase):
def _assert_success(self, result):
items, errors = result
self.assertEqual(errors, [])
return items

def test_import_object_class_with_all_optional_data(self):
with DatabaseMapping("sqlite://", create=True) as db_map:
self._assert_success(
import_entity_classes(
db_map,
(
("Object", (), "The test class.", 23, True),
("Relation", ("Object",), "The test relationship.", 5, False),
),
)
)
entity_classes = db_map.get_entity_class_items()
self.assertEqual(len(entity_classes), 2)
data = (
(
row["name"],
row["dimension_name_list"],
row["description"],
row["display_icon"],
row["active_by_default"],
)
for row in entity_classes
)
expected = (
("Object", (), "The test class.", 23, True),
("Relation", ("Object",), "The test relationship.", 5, False),
)
self.assertCountEqual(data, expected)


class TestImportEntity(unittest.TestCase):
def test_import_multi_d_entity_twice(self):
db_map = DatabaseMapping("sqlite://", create=True)
Expand Down

0 comments on commit 8775ef0

Please sign in to comment.