def create_new_spine_database(self, checked=False):
"""Create new (empty) Spine SQLite database file."""
answer = QFileDialog.getSaveFileName(
self._toolbox, "Create new Spine SQLite database", self.data_dir,
"SQlite database (*.sqlite *.db)")
file_path = answer[0]
if not file_path:
return
extension = os.path.splitext(file_path)[1]
if not extension:
file_path += ".sqlite"
# We need to remove the file first so `create_new_spine_database` doesn't complain
try:
os.remove(file_path)
except OSError:
pass
url = "sqlite:///" + file_path
create_new_spine_database(url)
database = os.path.basename(file_path)
username = getpass.getuser()
# Update UI
self._toolbox.ui.comboBox_dsn.clear()
self._toolbox.ui.comboBox_dialect.setCurrentText("sqlite")
self._toolbox.ui.lineEdit_SQLite_file.setText(
os.path.abspath(file_path))
self._toolbox.ui.lineEdit_host.clear()
self._toolbox.ui.lineEdit_port.clear()
self._toolbox.ui.lineEdit_database.setText(database)
self._toolbox.ui.lineEdit_username.setText(username)
self._toolbox.ui.lineEdit_password.clear()
def test_copy_db_url_to_clipboard(self):
"""Test that the database url from current selections is copied to clipboard.
"""
# First create a DS with an sqlite db reference
file_path = os.path.join(self.toolbox.project().project_dir, "mock_db.sqlite")
if not os.path.exists(file_path):
with open(file_path, 'w'): pass
url = "sqlite:///" + file_path
create_new_spine_database(url)
reference = dict(database="foo", username="******", url=url)
data_store = DataStore(self.toolbox, "DS", "", reference, 0, 0)
data_store.activate()
self.toolbox.ui.toolButton_copy_db_url.click()
clipboard_text = QApplication.clipboard().text()
self.assertEqual(clipboard_text, url)
def setUp(self):
"""Overridden method. Runs before each test. Makes instance of TreeViewForm class.
"""
# # Set logging level to Error to silence "Logging level: All messages" print
with mock.patch("data_store.DataStore") as mock_data_store:
logging.disable(level=logging.ERROR) # Disable logging
try:
os.remove('mock_db.sqlite')
except OSError:
pass
db_url = "sqlite:///mock_db.sqlite"
create_new_spine_database(db_url)
db_map = DiffDatabaseMapping(db_url, "UnitTest")
db_map.reset_mapping()
self.tree_view_form = TreeViewForm(mock_data_store, db_map, "mock_db")
logging.disable(level=logging.NOTSET) # Enable logging
def __init__(self, db_url, datapackage_descriptor, datapackage_base_path):
super().__init__()
self.db_url = db_url
create_new_spine_database(self.db_url)
self.db_map = DiffDatabaseMapping(db_url, getpass.getuser())
self.datapackage = Package(datapackage_descriptor,
datapackage_base_path)
self.signaler = Signaler()
self.resource_data = dict()
self.object_class_count = None
self.object_count = None
self.relationship_class_count = None
self.relationship_count = None
self.parameter_count = None
self.parameter_value_count = None
for resource in self.datapackage.resources:
self.resource_data[resource.name] = resource.read(cast=False)
def test_load_reference(self):
"""Test that reference is loaded into selections on Data Store creation,
and then shown in the ui when Data Store is activated.
"""
# FIXME: For now it only tests sqlite references
file_path = os.path.join(self.toolbox.project().project_dir, "mock_db.sqlite")
if not os.path.exists(file_path):
with open(file_path, 'w'): pass
url = "sqlite:///" + file_path
create_new_spine_database(url)
reference = dict(database="foo", username="******", url=url)
data_store = DataStore(self.toolbox, "DS", "", reference, 0, 0)
data_store.activate()
dialect = self.toolbox.ui.comboBox_dialect.currentText()
database = self.toolbox.ui.lineEdit_database.text()
username = self.toolbox.ui.lineEdit_username.text()
self.assertEqual(dialect, 'sqlite')
self.assertEqual(database, 'foo')
self.assertEqual(username, 'bar')
def setUp(self):
"""Overridden method. Runs before each test.
"""
# temp file for excel export
self.temp_excel_filename = str(uuid.uuid4()) + '.xlsx'
# create a in memory database with objects, relationship, parameters and values
input_db = create_new_spine_database('sqlite://')
db_map = DiffDatabaseMapping("",
username='******',
create_all=False)
db_map.engine = input_db
db_map.engine.connect()
db_map.session = Session(db_map.engine, autoflush=False)
db_map.create_mapping()
db_map.create_diff_tables_and_mapping()
db_map.init_next_id()
# create empty database for loading excel into
input_db_test = create_new_spine_database('sqlite://')
db_map_test = DiffDatabaseMapping("",
username='******',
create_all=False)
db_map_test.engine = input_db_test
db_map_test.engine.connect()
db_map_test.session = Session(db_map_test.engine, autoflush=False)
db_map_test.create_mapping()
db_map_test.create_diff_tables_and_mapping()
db_map_test.init_next_id()
# delete all object_classes to empty database
oc = set(oc.id for oc in db_map_test.object_class_list().all())
if oc:
db_map_test.remove_items(object_class_ids=oc)
db_map_test.commit_session('empty database')
oc = set(oc.id for oc in db_map.object_class_list().all())
if oc:
db_map.remove_items(object_class_ids=oc)
db_map.commit_session('empty database')
# create object classes
oc_1 = db_map.add_object_class(**{'name': 'object_class_1'})
oc_2 = db_map.add_object_class(**{'name': 'object_class_2'})
# create relationship classes
relc1 = db_map.add_wide_relationship_class(
**{
'name': 'relationship_class',
'object_class_id_list': [oc_1.id, oc_2.id]
})
# create objects
oc1_obj1 = db_map.add_object(**{
'name': 'oc1_obj1',
'class_id': oc_1.id
})
oc1_obj2 = db_map.add_object(**{
'name': 'oc1_obj2',
'class_id': oc_1.id
})
oc2_obj1 = db_map.add_object(**{
'name': 'oc2_obj1',
'class_id': oc_2.id
})
oc2_obj2 = db_map.add_object(**{
'name': 'oc2_obj2',
'class_id': oc_2.id
})
# add relationships
rel1 = db_map.add_wide_relationship(
**{
'name': 'rel1',
'class_id': relc1.id,
'object_id_list': [oc1_obj1.id, oc2_obj1.id]
})
rel2 = db_map.add_wide_relationship(
**{
'name': 'rel2',
'class_id': relc1.id,
'object_id_list': [oc1_obj2.id, oc2_obj2.id]
})
# create parameters
p1 = db_map.add_parameter(**{
'name': 'parameter1',
'object_class_id': oc_1.id
})
p2 = db_map.add_parameter(**{
'name': 'parameter2',
'object_class_id': oc_1.id
})
p3 = db_map.add_parameter(**{
'name': 'parameter3',
'object_class_id': oc_2.id
})
p4 = db_map.add_parameter(**{
'name': 'parameter4',
'object_class_id': oc_2.id
})
rel_p1 = db_map.add_parameter(**{
'name': 'rel_parameter1',
'relationship_class_id': relc1.id
})
rel_p2 = db_map.add_parameter(**{
'name': 'rel_parameter2',
'relationship_class_id': relc1.id
})
rel_p3 = db_map.add_parameter(**{
'name': 'rel_parameter3',
'relationship_class_id': relc1.id
})
rel_p4 = db_map.add_parameter(**{
'name': 'rel_parameter4',
'relationship_class_id': relc1.id
})
# add parameter values
db_map.add_parameter_value(**{
'parameter_id': p1.id,
'object_id': oc1_obj1.id,
'value': 0
})
db_map.add_parameter_value(**{
'parameter_id': p2.id,
'object_id': oc1_obj2.id,
'value': 3.5
})
db_map.add_parameter_value(
**{
'parameter_id': p3.id,
'object_id': oc2_obj1.id,
'json': '[1, 2, 3, 4]'
})
db_map.add_parameter_value(**{
'parameter_id': p4.id,
'object_id': oc2_obj2.id,
'json': '[5, 6, 7]'
})
db_map.add_parameter_value(**{
'parameter_id': rel_p1.id,
'relationship_id': rel1.id,
'value': 0
})
db_map.add_parameter_value(**{
'parameter_id': rel_p2.id,
'relationship_id': rel2.id,
'value': 4
})
db_map.add_parameter_value(
**{
'parameter_id': rel_p3.id,
'relationship_id': rel1.id,
'json': '[5, 6, 7]'
})
db_map.add_parameter_value(
**{
'parameter_id': rel_p4.id,
'relationship_id': rel2.id,
'json': '[1, 2, 3, 4]'
})
# commit
db_map.commit_session('test')
self.db_map = db_map
self.empty_db_map = db_map_test