def setUpClass(cls):
# Executed BEFORE test methods of the class
prepare_and_reset_database_for_tests(
prepare=True,
metadata_string=
"sqlite:////home/rnebot/GoogleDrive/AA_MAGIC/nis_metadata.db",
data_string=
"sqlite:////home/rnebot/GoogleDrive/AA_MAGIC/nis_cached_datasets.db"
)
nexinfosys.data_source_manager = register_external_datasources(
{"FAO_DATASETS_DIR": "/home/marco/temp/Data/FAOSTAT/"})
def test_003_new_case_study_with_no_command(self):
prepare_and_reset_database_for_tests(True)
uuid2, isess = new_case_study(with_metadata_command=0)
isess.quit()
self.assertIsNotNone(
uuid2,
"UUID should be defined after saving+closing the reproducible session"
)
# Check there is a case study, and a case study version and a session
session = DBSession()
self.assertEqual(len(session.query(CaseStudy).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersion).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 1)
session.close()
def test_004_new_case_study_with_only_metadata_command(self):
prepare_and_reset_database_for_tests(True)
uuid2, isess = new_case_study(
with_metadata_command=1) # 1 means "execute" (do not register)
# Check State
md = isess._state.get("_metadata")
isess.quit()
self.assertIsNotNone(md)
self.assertEqual(md["Title"], "Case study for test only")
# Check Session should not have CommandsContainer
session = DBSession()
tmp = len(session.query(CaseStudy).all())
self.assertEqual(tmp, 1)
self.assertEqual(len(session.query(CaseStudyVersion).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 1)
self.assertEqual(len(session.query(CommandsContainer).all()), 0)
session.close()
def execute_file_return_issues(file_name, generator_type):
"""
Execution of files in the context of TESTS
:param file_name:
:param generator_type:
:return:
"""
if generator_type == "spreadsheet":
content_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
read_type = "rb"
elif generator_type == "native":
content_type = "application/json"
read_type = "r"
prepare_and_reset_database_for_tests()
isess = InteractiveSession(DBSession)
isess.identify({"user": "******"}, testing=True) # Pass just user name.
isess.open_reproducible_session(case_study_version_uuid=None,
recover_previous_state=None,
cr_new=CreateNew.CASE_STUDY,
allow_saving=False)
# Add system-level entities from JSON definition in "default_cmds"
ret = isess.register_andor_execute_command_generator(
"json", "application/json", nexinfosys.default_cmds, False, True)
# Execute current file
with open(file_name, read_type) as f1:
buffer = f1.read()
issues, output = isess.register_andor_execute_command_generator(
generator_type, content_type, buffer, False, True)
for idx, issue in enumerate(issues):
print(f"Issue {idx+1}/{len(issues)} = {issue}")
print(f"Output = {output}")
isess.close_reproducible_session()
isess.close_db_session()
return isess, issues
def setUpClass(cls):
# Executed BEFORE test methods of the class
prepare_and_reset_database_for_tests(prepare=True)
nexinfosys.data_source_manager = register_external_datasources(
{"FAO_DATASETS_DIR": "/home/marco/temp/Data/FAOSTAT/"})
# if r_idx < 2:
# continue
# for c_idx, value in enumerate(row[1:], 1):
# wsd.cell(row=r_idx, column=c_idx).value = value
# xl.save("/home/rnebot/Downloads/dt_new.xlsx")
#
# a = 1 / 0
is_fao_test = False
fao_dir = "/home/marco/temp/Data/FAOSTAT/"
if is_fao_test:
i = TestFAOCommandFiles()
prepare_and_reset_database_for_tests(
prepare=True,
metadata_string=
"sqlite:////home/rnebot/GoogleDrive/AA_MAGIC/nis_metadata.db",
data_string=
"sqlite:////home/rnebot/GoogleDrive/AA_MAGIC/nis_cached_datasets.db"
)
nexinfosys.data_source_manager = register_external_datasources(
{"FAO_DATASETS_DIR": fao_dir})
i.test_001_fao()
else:
i = TestCommandFiles()
prepare_and_reset_database_for_tests(prepare=True)
nexinfosys.data_source_manager = register_external_datasources(
{"FAO_DATASETS_DIR": fao_dir})
#i.test_002_execute_file_two()
# i.test_006_execute_file_five() # TODO: This test from v1 has problems with the case sensitiveness!
#i.test_008_execute_file_v2_two()
def test_005_new_case_study_with_metadata_plus_dummy_command(self):
prepare_and_reset_database_for_tests(True)
# ----------------------------------------------------------------------
# Create case study, with one CommandsContainer
uuid_, isess = new_case_study(with_metadata_command=3)
session = DBSession()
self.assertEqual(len(session.query(CaseStudy).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersion).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 1)
self.assertEqual(len(session.query(CommandsContainer).all()), 1)
session.close()
# Reset State
isess.reset_state()
self.assertIsNone(isess._state.get(
"metadata")) # After reset, no variable should be there
# ----------------------------------------------------------------------
# SECOND work session, resume and add DummyCommand
isess.open_reproducible_session(case_study_version_uuid=uuid_,
recover_previous_state=True,
cr_new=CreateNew.NO,
allow_saving=True)
self.assertIsNotNone(isess._state.get("_metadata"))
d_cmd, _ = create_command("dummy", None, {
"name": "var_a",
"description": "Content"
})
self.assertIsNone(isess._state.get("var_a"))
issues, output = isess.execute_executable_command(d_cmd)
self.assertIsNotNone(isess._state.get("var_a"))
isess.register_executable_command(d_cmd)
uuid2, _, _ = isess.close_reproducible_session(issues,
output,
save=True)
# Check Database objects
session = DBSession()
self.assertEqual(len(session.query(CommandsContainer).all()), 2)
self.assertEqual(len(session.query(CaseStudy).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersion).all()), 1)
self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 1)
session.close()
isess.reset_state()
# ----------------------------------------------------------------------
# Just Check that State was saved. Two variables: metadata and "var_a"
isess.open_reproducible_session(case_study_version_uuid=uuid2,
recover_previous_state=True,
cr_new=CreateNew.NO,
allow_saving=True)
self.assertIsNotNone(isess._state.get("_metadata"))
self.assertIsNotNone(isess._state.get("var_a"))
isess.close_reproducible_session() # Dismiss ReproducibleSession
# ----------------------------------------------------------------------
# Now create a new version, COPYING the previous, add TWO commands
# One of them OVERWRITES the state of one variable
isess.open_reproducible_session(case_study_version_uuid=uuid2,
recover_previous_state=True,
cr_new=CreateNew.VERSION,
allow_saving=True)
d_cmd, _ = create_command(
"dummy", None, {
"name": "var_b",
"description": "To test var storage and retrieval"
})
issues, output = isess.execute_executable_command(d_cmd)
isess.register_executable_command(d_cmd)
d_cmd, _ = create_command("dummy", None, {
"name": "var_a",
"description": "Overwritten"
})
issues, output = isess.execute_executable_command(d_cmd)
isess.register_executable_command(d_cmd)
uuid2, _, _ = isess.close_reproducible_session(issues,
output,
save=True)
# Database objects
session = DBSession()
cs_lst = session.query(CaseStudy).all()
self.assertEqual(len(cs_lst), 1)
self.assertEqual(len(session.query(CaseStudyVersion).all()), 2)
self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 3)
self.assertEqual(len(session.query(CommandsContainer).all()), 6)
session.close()
# ----------------------------------------------------------------------
# Now create a NEW CASE STUDY, COPYING the second version of the first case study
# TODO fix it!
# isess.open_reproducible_session(case_study_version_uuid=uuid2,
# recover_previous_state=True,
# cr_new=CreateNew.CASE_STUDY,
# allow_saving=True)
# d_cmd, _ = create_command("dummy", None, {"name": "var_b", "description": "Another value"})
# issues, output = isess.execute_executable_command(d_cmd)
# isess.register_executable_command(d_cmd)
# uuid3, _, _ = isess.close_reproducible_session(issues, output, save=True)
# # Database objects
# session = DBSession()
# cs_lst = session.query(CaseStudy).all()
# self.assertEqual(len(cs_lst), 2)
# self.assertEqual(len(session.query(CaseStudyVersion).all()), 3)
# self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 3)
# self.assertEqual(len(session.query(CommandsContainer).all()), 11)
# session.close()
# ----------------------------------------------------------------------
# Create a NEW VERSION, with restart
# isess.open_reproducible_session(case_study_version_uuid=uuid3,
# recover_previous_state=False,
# cr_new=CreateNew.VERSION,
# allow_saving=True)
# d_cmd, _ = create_command("dummy", None, {"name": "var_b", "description": "Another value"})
# issues, output = isess.execute_executable_command(d_cmd)
# isess.register_executable_command(d_cmd)
# uuid4, _, _ = isess.close_reproducible_session(issues, output, save=True)
#
# isess.open_reproducible_session(case_study_version_uuid=uuid4,
# recover_previous_state=True,
# cr_new=CreateNew.NO,
# allow_saving=True)
# self.assertIsNone(isess._state.get("var_a"))
# self.assertIsNotNone(isess._state.get("var_b"))
# isess.close_reproducible_session(issues, output, save=False)
#
# # Database objects
# session = DBSession()
# self.assertEqual(len(session.query(CaseStudy).all()), 2)
# self.assertEqual(len(session.query(CaseStudyVersion).all()), 4)
# self.assertEqual(len(session.query(CaseStudyVersionSession).all()), 3)
# self.assertEqual(len(session.query(CommandsContainer).all()), 12)
# session.close()
# ----------------------------------------------------------------------
# CHECK that we have separate states. Open the first version. "var_b" is not there, "var_a" equals "Content"
# FIRST VERSION
# isess.open_reproducible_session(case_study_version_uuid=uuid_,
# recover_previous_state=True,
# cr_new=CreateNew.NO,
# allow_saving=True)
# self.assertEqual(isess._state.get("var_a"), "Content")
# self.assertIsNone(isess._state.get("var_b"))
# isess.close_reproducible_session() # Dismiss ReproducibleSession
#
# # SECOND VERSION same case study
# isess.open_reproducible_session(case_study_version_uuid=uuid2,
# recover_previous_state=True,
# cr_new=CreateNew.NO,
# allow_saving=True)
# self.assertEqual(isess._state.get("var_a"), "Overwritten")
# self.assertIsNotNone(isess._state.get("var_b"))
# isess.close_reproducible_session() # Dismiss ReproducibleSession
#
# # FIRST VERSION new CASE STUDY, from second VERSION first CASE STUDY
# isess.open_reproducible_session(case_study_version_uuid=uuid3,
# recover_previous_state=True,
# cr_new=CreateNew.NO,
# allow_saving=True)
# self.assertEqual(isess._state.get("var_b"), "Another value")
# self.assertIsNotNone(isess._state.get("var_a"))
# isess.close_reproducible_session() # Dismiss ReproducibleSession
# TODO Test clone BUT without RESTART --> ALL sessions should be dismissed, in this case it makes no sense cloning State, Sessions and Commands
# TODO What if another session is opened?? It should be a close without saving followed by an open
isess.quit()