async def test_loading_already_present_imports_async(self):
"""Testing docs that load the same import"""
test_name = 'TestLoadingAlreadyPresentImportsAsync'
corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)
res_opt = ResolveOptions()
res_opt.strict_validation = True
# load the first doc
main_doc = await corpus.fetch_object_async('mainEntity.cdm.json', res_opt=res_opt)
self.assertIsNotNone(main_doc)
self.assertEqual(1, len(main_doc.imports))
import_doc = main_doc.imports[0]._document
self.assertIsNotNone(import_doc)
# now load the second doc, which uses the same import
# the import should not be loaded again, it should be the same object
second_doc = await corpus.fetch_object_async('secondEntity.cdm.json', res_opt=res_opt)
self.assertIsNotNone(second_doc)
self.assertEqual(1, len(second_doc.imports))
second_import_doc = main_doc.imports[0]._document
self.assertIsNotNone(second_import_doc)
self.assertIs(import_doc, second_import_doc)
async def seek_entities(f: 'CdmManifestDefinition'):
if f.entities is not None:
spew.spew_line(f.folder_path)
for entity in f.entities:
ent = entity
current_file = f
while isinstance(ent,
CdmReferencedEntityDeclarationDefinition):
corpus_path = corpus.storage.create_absolute_corpus_path(
ent.entity_path, current_file)
ent = await corpus.fetch_object_async(corpus_path)
current_file = ent
corpus_path = corpus.storage.create_absolute_corpus_path(
ent.entity_path, current_file)
res_opt = ResolveOptions()
res_opt.strict_validation = True
new_ent = await corpus.fetch_object_async(corpus_path,
res_opt=res_opt)
res_opt.wrt_doc = new_ent.in_document
res_opt.directives = directives
res_ent = ResolvedEntity(res_opt, new_ent)
res_ent.spew(res_opt, spew, ' ', True)
if f.sub_manifests:
for sub_manifest in f.sub_manifests:
corpus_path = corpus.storage.create_absolute_corpus_path(
sub_manifest.definition, f)
await seek_entities(await
corpus.fetch_object_async(corpus_path))
async def test_entity_with_missing_import(self):
"""The path between TestDataPath and TestName."""
test_name = 'TestEntityWithMissingImport'
corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)
res_opt = ResolveOptions()
res_opt.strict_validation = True
doc = await corpus.fetch_object_async('local:/missingImport.cdm.json', res_opt=res_opt)
self.assertIsNotNone(doc)
self.assertEqual(1, len(doc.imports))
self.assertEqual('missing.cdm.json', doc.imports[0].corpus_path)
self.assertIsNone(doc.imports[0]._document)
async def test_strict_validation_on(self):
error_count = 0
corpus = TestHelper.get_local_corpus(self.tests_subpath,
'test_strict_validation')
def callback(status_level: CdmStatusLevel, message: str):
nonlocal error_count
if message.index('Unable to resolve the reference') != -1:
error_count += 1
else:
self.fail(message)
corpus.set_event_callback(callback, CdmStatusLevel.ERROR)
# load with strict validation.
res_opt = ResolveOptions()
res_opt.strict_validation = True
await corpus.fetch_object_async('local:/doc.cdm.json', res_opt=res_opt)
self.assertEqual(1, error_count)
error_count = 0
corpus = TestHelper.get_local_corpus(self.tests_subpath,
'test_strict_validation')
def callback1(status_level: CdmStatusLevel, message: str):
nonlocal error_count
if status_level == CdmStatusLevel.WARNING and message.index(
'Unable to resolve the reference') != -1:
error_count += 1
else:
self.fail(message)
corpus.set_event_callback(callback1, CdmStatusLevel.WARNING)
# load with strict validation and shallow validation.
res_opt = ResolveOptions()
res_opt.strict_validation = True
res_opt.shallow_validation = True
await corpus.fetch_object_async('local:/doc.cdm.json', res_opt=res_opt)
self.assertEqual(1, error_count)
async def test_entity_with_same_imports_async(self):
test_name = 'TestEntityWithSameImportsAsync'
corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)
res_opt = ResolveOptions()
res_opt.strict_validation = True
doc = await corpus.fetch_object_async('local:/multipleImports.cdm.json', res_opt=res_opt)
self.assertIsNotNone(doc)
self.assertEqual(2, len(doc.imports))
first_import = doc.imports[0]._document
self.assertEqual('missingImport.cdm.json', first_import.name)
self.assertEqual(1, len(first_import.imports))
second_import = doc.imports[1]._document
self.assertEqual('notMissing.cdm.json', second_import.name)
async def test_strict_validation_off(self):
corpus = TestHelper.get_local_corpus(
self.tests_subpath,
'test_strict_validation') # type: CdmCorpusDefinition
def callback(status_level: CdmStatusLevel, message: str):
# when the strict validation is disabled, there should be no reference validation.
# no error should be logged.
self.fail(message)
corpus.set_event_callback(callback, CdmStatusLevel.WARNING)
# load with strict validation disabled.
res_opt = ResolveOptions()
res_opt.strict_validation = False
await corpus.fetch_object_async('local:/doc.cdm.json', res_opt=res_opt)
async def test_reading_is_primary_key(self):
corpus = TestHelper.get_local_corpus(self.tests_subpath,
'test_reading_is_primary_key')
res_opt = ResolveOptions()
res_opt.strict_validation = True
# read from an unresolved entity schema
entity = await corpus.fetch_object_async(
'local:/TeamMembership.cdm.json/TeamMembership', res_opt=res_opt)
attribute_group_ref = entity.attributes[
0] # type: CdmAttributeGroupReference
attribute_group = attribute_group_ref.explicit_reference # type: CdmAttributeGroupDefinition
type_attribute = attribute_group.members[
0] # type: CdmTypeAttributeDefinition
self.assertTrue(type_attribute.is_primary_key)
# check that the trait "is.identifiedBy" is created with the correct argument.
is_identified_by1 = type_attribute.applied_traits[
1] # type: CdmTraitReference
self.assertEqual('is.identifiedBy', is_identified_by1.named_reference)
self.assertEqual(
'TeamMembership/(resolvedAttributes)/teamMembershipId',
is_identified_by1.arguments[0].value)
# read from a resolved entity schema
resolved_entity = await corpus.fetch_object_async(
'local:/TeamMembership_Resolved.cdm.json/TeamMembership',
res_opt=res_opt)
resolved_type_attribute = resolved_entity.attributes[
0] # type: CdmTypeAttributeDefinition
self.assertTrue(resolved_type_attribute.is_primary_key)
# check that the trait "is.identifiedBy" is created with the correct argument.
is_identified_by2 = resolved_type_attribute.applied_traits[
6] # type: CdmTraitReference
self.assertEqual('is.identifiedBy', is_identified_by2.named_reference)
argument_value = is_identified_by2.arguments[
0].value # type: CdmAttributeReference
self.assertEqual(
'TeamMembership/(resolvedAttributes)/teamMembershipId',
argument_value.named_reference)
async def test_loading_same_missing_imports_async(self):
"""Testing docs that load the same import"""
test_name = 'TestLoadingSameMissingImportsAsync'
corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)
res_opt = ResolveOptions()
res_opt.strict_validation = True
main_doc = await corpus.fetch_object_async('mainEntity.cdm.json', res_opt=res_opt)
self.assertIsNotNone(main_doc)
self.assertEqual(2, len(main_doc.imports))
# make sure imports loaded correctly, despite them missing imports
first_import = main_doc.imports[0]._document
second_import = main_doc.imports[1]._document
self.assertEqual(1, len(first_import.imports))
self.assertIsNone(first_import.imports[0]._document)
self.assertEqual(1, len(second_import.imports))
self.assertIsNone(first_import.imports[0]._document)
async def test_loading_same_imports_async(self):
"""Testing docs that load the same import"""
test_name = 'TestLoadingSameImportsAsync'
corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)
res_opt = ResolveOptions()
res_opt.strict_validation = True
main_doc = await corpus.fetch_object_async('mainEntity.cdm.json', res_opt=res_opt)
self.assertIsNotNone(main_doc)
self.assertEqual(2, len(main_doc.imports))
first_import = main_doc.imports[0]._document
second_import = main_doc.imports[1]._document
# since these two imports are loaded asynchronously, we need to make sure that
# the import that they share (targetImport) was loaded, and that the
# targetImport doc is attached to both of these import objects
self.assertEqual(1, len(first_import.imports))
self.assertIsNotNone(first_import.imports[0]._document)
self.assertEqual(1, len(second_import.imports))
self.assertIsNotNone(second_import.imports[0]._document)