async def test_referenced_entity_declaration_resolution(self): corpus = CdmCorpusDefinition() corpus.ctx.report_at_level = CdmStatusLevel.WARNING corpus.storage.mount('cdm', LocalAdapter(root='../../schemaDocuments')) corpus.storage.default_namespace = 'cdm' manifest = CdmManifestDefinition(corpus.ctx, 'manifest') manifest.entities.append( 'Account', 'cdm:/core/applicationCommon/foundationCommon/crmCommon/accelerators/healthCare/electronicMedicalRecords/Account.cdm.json/Account') referenced_entity_path = \ 'cdm:/core/applicationCommon/foundationCommon/crmCommon/accelerators/healthCare/electronicMedicalRecords/electronicMedicalRecords.manifest.cdm.json/Address' referenced_entity = CdmReferencedEntityDeclarationDefinition(corpus.ctx, 'Address') referenced_entity.entity_path = referenced_entity_path manifest.entities.append(referenced_entity) corpus.storage.fetch_root_folder('cdm').documents.append(manifest) resolved_manifest = await manifest.create_resolved_manifest_async('resolved_manifest', None) self.assertEqual(2, len(resolved_manifest.entities)) self.assertEqual('core/applicationCommon/foundationCommon/crmCommon/accelerators/healthCare/electronicMedicalRecords/resolved/Account.cdm.json/Account', resolved_manifest.entities[0].entity_path) self.assertEqual(referenced_entity_path, resolved_manifest.entities[1].entity_path)
async def test_resolved_manifest_import(self): """Tests if the imports on the resolved manifest are relative to the resolved manifest location.""" corpus = TestHelper.get_local_corpus(self.tests_subpath, 'test_resolved_manifest_import') # Make sure that we are not picking up the default namespace while testing. corpus.storage.default_namespace = 'remote' document_name = 'localImport.cdm.json' local_folder = corpus.storage.fetch_root_folder('local') # Create a manifest that imports a document on the same folder. manifest = CdmManifestDefinition(corpus.ctx, 'default') manifest.imports.append(document_name) local_folder.documents.append(manifest) document = CdmDocumentDefinition(corpus.ctx, document_name) local_folder.documents.append(document) # Resolve the manifest into a different folder. resolved_manifest = await manifest.create_resolved_manifest_async( 'output:/default.manifest.cdm.json', None) # Checks if the import path on the resolved manifest points to the original location. self.assertEqual(1, len(resolved_manifest.imports)) self.assertEqual(f'local:/{document_name}', resolved_manifest.imports[0].corpus_path)
async def test_imports_relative_path(self): # the corpus path in the imports are relative to the document where it was defined. # when saving in model.json the documents are flattened to the manifest level # so it is necessary to recalculate the path to be relative to the manifest. corpus = TestHelper.get_local_corpus('notImportant', 'notImportantLocation') folder = corpus.storage.fetch_root_folder('local') manifest = CdmManifestDefinition(corpus.ctx, 'manifest') manifest.entities.append('EntityName', 'EntityName/EntityName.cdm.json/EntityName') folder.documents.append(manifest) entity_folder = folder.child_folders.append('EntityName') document = CdmDocumentDefinition(corpus.ctx, 'EntityName.cdm.json') document.imports.append('subfolder/EntityName.cdm.json') document.definitions.append('EntityName') entity_folder.documents.append(document) sub_folder = entity_folder.child_folders.append('subfolder') sub_folder.documents.append('EntityName.cdm.json') data = await ManifestPersistence.to_data(manifest, None, None) self.assertEqual(1, len(data.entities)) imports = data.entities[0].get('imports', []) self.assertEqual(1, len(imports)) self.assertEqual('EntityName/subfolder/EntityName.cdm.json', imports[0].corpusPath)
def generate_manifest(local_root_path: str) -> 'CdmManifestDefinition': """ Creates a manifest used for the tests. """ cdmCorpus = CdmCorpusDefinition() cdmCorpus.storage.default_namespace = 'local' adapter = LocalAdapter(root=local_root_path) cdmCorpus.storage.mount('local', adapter) # add cdm namespace cdmCorpus.storage.mount('cdm', adapter) manifest = CdmManifestDefinition(cdmCorpus.ctx, 'manifest') manifest.folder_path = '/' manifest.namespace = 'local' return manifest
async def test_to_incremental_partition_without_trait(self): """ Testing saving manifest with local entity declaration having an incremental partition without incremental trait. """ test_name = 'test_to_incremental_partition_without_trait' corpus = TestHelper.get_local_corpus(self.test_subpath, test_name) error_message_verified = False # not checking the CdmLogCode here as we want to check if this error message constructed correctly for the partition (it shares the same CdmLogCode with partition pattern) def callback(level, message): if 'Failed to persist object \'DeletePartition\'. This object does not contain the trait \'is.partition.incremental\', so it should not be in the collection \'incremental_partitions\'. | to_data' in message: nonlocal error_message_verified error_message_verified = True else: self.fail('Some unexpected failure - {}!'.format(message)) corpus.set_event_callback(callback, CdmStatusLevel.WARNING) manifest = CdmManifestDefinition(corpus.ctx, 'manifest') corpus.storage.fetch_root_folder('local').documents.append(manifest) entity = CdmEntityDefinition(corpus.ctx, 'entityName', None) create_document_for_entity(corpus, entity) localized_entity_declaration = manifest.entities.append(entity) upsert_incremental_partition = corpus.make_object( CdmObjectType.DATA_PARTITION_DEF, 'UpsertPartition', False) upsert_incremental_partition.location = '/IncrementalData' upsert_incremental_partition.specialized_schema = 'csv' upsert_incremental_partition.exhibits_traits.append( Constants._INCREMENTAL_TRAIT_NAME, [['type', CdmIncrementalPartitionType.UPSERT.value]]) delete_partition = corpus.make_object(CdmObjectType.DATA_PARTITION_DEF, 'DeletePartition', False) delete_partition.location = '/IncrementalData' delete_partition.specialized_schema = 'csv' localized_entity_declaration.incremental_partitions.append( upsert_incremental_partition) localized_entity_declaration.incremental_partitions.append( delete_partition) with logger._enter_scope(DataPartitionTest.__name__, corpus.ctx, test_name): manifest_data = ManifestPersistence.to_data(manifest, None, None) self.assertEqual(1, len(manifest_data.entities)) entity_data = manifest_data.entities[0] self.assertEqual(1, len(entity_data.incrementalPartitions)) partition_data = entity_data.incrementalPartitions[0] self.assertEqual('UpsertPartition', partition_data.name) self.assertEqual(1, len(partition_data.exhibitsTraits)) self.assertEqual(Constants._INCREMENTAL_TRAIT_NAME, partition_data.exhibitsTraits[0].traitReference) self.assertTrue(error_message_verified)
def test_path_that_does_not_end_in_slash(self): """FolderPath should always end with a / This checks the behavior if FolderPath does not end with a / ('/' should be appended and a warning be sent through callback function)""" expected_log_codes = {CdmLogCode.WARN_STORAGE_EXPECTED_PATH_PREFIX} corpus = TestHelper.get_local_corpus( self.tests_subpath, 'test_path_that_does_not_end_in_slash', expected_codes=expected_log_codes, no_input_and_output_folder=True) manifest = CdmManifestDefinition(None, None) manifest._namespace = 'cdm' manifest._folder_path = 'Mnp' absolute_path = corpus.storage.create_absolute_corpus_path( 'Abc', manifest) self.assertEqual('cdm:Mnp/Abc', absolute_path) TestHelper.assert_cdm_log_code_equality( corpus, CdmLogCode.WARN_STORAGE_EXPECTED_PATH_PREFIX, True, self)
async def test_saving_invalid_model_json_name(self): corpus = CdmCorpusDefinition() corpus.ctx.report_at_level = CdmStatusLevel.WARNING corpus.storage.unmount('cdm') corpus.storage.default_namespace = 'local' manifest = CdmManifestDefinition(corpus.ctx, 'manifest') corpus.storage.fetch_root_folder('local').documents.append(manifest) all_docs = {} # type: Dict[str, str] test_adapter = MockStorageAdapter(all_docs) corpus.storage._set_adapter('local', test_adapter) new_manifest_from_model_json_name = 'my.model.json' await manifest.save_as_async(new_manifest_from_model_json_name, True) # TODO: because we can load documents properly now, save_as_async returns false. Will check the value returned from save_as_async() when the problem is solved self.assertFalse('/' + new_manifest_from_model_json_name in all_docs)
def test_path_root_invalid_folder_path(self): """"Tests absolute paths cannot be created with wrong parameters. Checks behavior if FolderPath is invalid.""" corpus = CdmCorpusDefinition() function_was_called = False function_parameter1 = CdmStatusLevel.INFO function_parameter2 = None def callback(status_level: CdmStatusLevel, message1: str): nonlocal function_was_called, function_parameter1, function_parameter2 function_was_called = True function_parameter1 = status_level function_parameter2 = message1 corpus.set_event_callback(callback) manifest = CdmManifestDefinition(None, None) manifest.namespace = 'cdm' manifest.folder_path = './Mnp' corpus.storage.create_absolute_corpus_path('Abc', manifest) self.assertTrue(function_was_called) self.assertEqual(CdmStatusLevel.ERROR, function_parameter1) self.assertTrue(function_parameter2.find('The path should not start with ./') != -1) function_was_called = False manifest.namespace = 'cdm' manifest.folder_path = '/./Mnp' corpus.storage.create_absolute_corpus_path('Abc', manifest) self.assertTrue(function_was_called) self.assertEqual(CdmStatusLevel.ERROR, function_parameter1) self.assertTrue(function_parameter2.find('The path should not contain /./') != -1) function_was_called = False manifest.namespace = 'cdm' manifest.folder_path = '../Mnp' corpus.storage.create_absolute_corpus_path('Abc', manifest) function_parameter2 = function_parameter2.split('|')[1].strip() self.assertTrue(function_was_called) self.assertEqual(CdmStatusLevel.ERROR, function_parameter1) self.assertTrue(function_parameter2.find('The path should not contain ../') != -1) function_was_called = False manifest.namespace = 'cdm' manifest.folder_path = 'Mnp/./Qrs' corpus.storage.create_absolute_corpus_path('Abc', manifest) function_parameter2 = function_parameter2.split('|')[1].strip() self.assertTrue(function_was_called) self.assertEqual(CdmStatusLevel.ERROR, function_parameter1) self.assertTrue(function_parameter2.find('The path should not contain /./') != -1) function_was_called = False manifest.namespace = 'cdm' manifest.folder_path = 'Mnp/../Qrs' corpus.storage.create_absolute_corpus_path('Abc', manifest) function_parameter2 = function_parameter2.split('|')[1].strip() self.assertTrue(function_was_called) self.assertEqual(CdmStatusLevel.ERROR, function_parameter1) self.assertTrue(function_parameter2.find('The path should not contain ../') != -1)
def test_path_root_invalid_folder_path(self): """"Tests absolute paths cannot be created with wrong parameters. Checks behavior if FolderPath is invalid.""" expected_log_codes = {CdmLogCode.ERR_STORAGE_INVALID_PATH_FORMAT} corpus = TestHelper.get_local_corpus( self.tests_subpath, 'test_path_root_invalid_folder_path', expected_codes=expected_log_codes, no_input_and_output_folder=True) manifest = CdmManifestDefinition(None, None) manifest._namespace = 'cdm' manifest._folder_path = './Mnp' corpus.storage.create_absolute_corpus_path('Abc', manifest) TestHelper.assert_cdm_log_code_equality( corpus, CdmLogCode.ERR_STORAGE_INVALID_PATH_FORMAT, True, self) manifest = CdmManifestDefinition(None, None) manifest._namespace = 'cdm' manifest._folder_path = '/./Mnp' corpus.storage.create_absolute_corpus_path('Abc', manifest) TestHelper.assert_cdm_log_code_equality( corpus, CdmLogCode.ERR_STORAGE_INVALID_PATH_FORMAT, True, self) manifest = CdmManifestDefinition(None, None) manifest._namespace = 'cdm' manifest._folder_path = '../Mnp' corpus.storage.create_absolute_corpus_path('Abc', manifest) TestHelper.assert_cdm_log_code_equality( corpus, CdmLogCode.ERR_STORAGE_INVALID_PATH_FORMAT, True, self) manifest = CdmManifestDefinition(None, None) manifest._namespace = 'cdm' manifest._folder_path = 'Mnp/./Qrs' corpus.storage.create_absolute_corpus_path('Abc', manifest) TestHelper.assert_cdm_log_code_equality( corpus, CdmLogCode.ERR_STORAGE_INVALID_PATH_FORMAT, True, self) manifest = CdmManifestDefinition(None, None) manifest._namespace = 'cdm' manifest._folder_path = 'Mnp/../Qrs' corpus.storage.create_absolute_corpus_path('Abc', manifest) TestHelper.assert_cdm_log_code_equality( corpus, CdmLogCode.ERR_STORAGE_INVALID_PATH_FORMAT, True, self)