async def test_extends_entity_proj(self):
"""AddTypeAttribute on an entity definition"""
test_name = 'test_extends_entity_proj'
entity_name = 'Customer'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["emailId", "address", "isPrimary", "phoneId", "number", "socialId", "account"]
# Type attribute: "someType"
self.assertEqual(8, len(resolved_entity.attributes))
self.assertEqual('emailId', resolved_entity.attributes[0].name)
self.assertEqual('address', resolved_entity.attributes[1].name)
self.assertEqual('isPrimary', resolved_entity.attributes[2].name)
self.assertEqual('phoneId', resolved_entity.attributes[3].name)
self.assertEqual('number', resolved_entity.attributes[4].name)
self.assertEqual('socialId', resolved_entity.attributes[5].name)
self.assertEqual('account', resolved_entity.attributes[6].name)
self.assertEqual('someType', resolved_entity.attributes[7].name)
self.assertIsNotNone(resolved_entity.attributes[7].applied_traits.item(
'is.linkedEntity.name'))
async def test_group(self):
"""CountAttribute on an entity with an attribute group"""
test_name = 'test_group'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "someCount"
# For resolution guidance, CountAttribute has to be used with Expansion so we do an Expansion of 1...1 here
self.assertEqual(6, len(resolved_entity.attributes))
self.assertEqual('someCount', resolved_entity.attributes[0].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[0].applied_traits[1].named_reference)
self.assertEqual('name1', resolved_entity.attributes[1].name)
self.assertEqual('age1', resolved_entity.attributes[2].name)
self.assertEqual('address1', resolved_entity.attributes[3].name)
self.assertEqual('phoneNumber1', resolved_entity.attributes[4].name)
self.assertEqual('email1', resolved_entity.attributes[5].name)
async def test_duplicate(self):
"""Two AddCountAttribute operations in a single projection using the same Count attribute"""
test_name = 'test_duplicate'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "someCount", count attribute: "someCount"
# "someCount" should get merged into one
self.assertEqual(6, len(resolved_entity.attributes))
self.assertEqual('name', resolved_entity.attributes[0].name)
self.assertEqual('age', resolved_entity.attributes[1].name)
self.assertEqual('address', resolved_entity.attributes[2].name)
self.assertEqual('phoneNumber', resolved_entity.attributes[3].name)
self.assertEqual('email', resolved_entity.attributes[4].name)
self.assertEqual('someCount', resolved_entity.attributes[5].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[5].applied_traits[1].named_reference)
async def test_conditional_proj(self):
"""AddCountAttribute with a conditionn"""
test_name = 'test_conditional_proj'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "someCount"
# Condition is false, so no Count attribute added
self.assertEqual(5, len(resolved_entity.attributes))
self.assertEqual('name', resolved_entity.attributes[0].name)
self.assertEqual('age', resolved_entity.attributes[1].name)
self.assertEqual('address', resolved_entity.attributes[2].name)
self.assertEqual('phoneNumber', resolved_entity.attributes[3].name)
self.assertEqual('email', resolved_entity.attributes[4].name)
async def test_combine_ops_nested_proj(self):
"""Nested projections with AddCountAttribute and other operations"""
test_name = 'test_combine_ops_nested_proj'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "someCount", renameFormat = new_{m}, include ["new_name", "age", "new_someCount"]
self.assertEqual(3, len(resolved_entity.attributes))
self.assertEqual('new_name', resolved_entity.attributes[0].name)
self.assertEqual('new_age', resolved_entity.attributes[1].name)
self.assertEqual('new_someCount', resolved_entity.attributes[2].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[2].applied_traits[1].named_reference)
async def test_combine_ops(self):
"""AddCountAttribute with other operations in the same projection"""
test_name = 'test_combine_ops'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "someCount", count attribute: "anotherCount", rename "name" to "firstName"
self.assertEqual(8, len(resolved_entity.attributes))
self.assertEqual('name', resolved_entity.attributes[0].name)
self.assertEqual('age', resolved_entity.attributes[1].name)
self.assertEqual('address', resolved_entity.attributes[2].name)
self.assertEqual('phoneNumber', resolved_entity.attributes[3].name)
self.assertEqual('email', resolved_entity.attributes[4].name)
self.assertEqual('someCount', resolved_entity.attributes[5].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[5].applied_traits[1].named_reference)
self.assertEqual('anotherCount', resolved_entity.attributes[6].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[6].applied_traits[1].named_reference)
self.assertEqual('firstName', resolved_entity.attributes[7].name)
async def test_with_nested_array_expansion(self):
"""Nested projections with ArrayExpansion, then AddCountAttribute, and then RenameAttributes"""
test_name = 'test_with_nested_array_expansion'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "personCount", expand 1...2, renameFormat = {m}{o}
self.assertEqual(11, len(resolved_entity.attributes))
self.assertEqual('name1', resolved_entity.attributes[0].name)
self.assertEqual('age1', resolved_entity.attributes[1].name)
self.assertEqual('address1', resolved_entity.attributes[2].name)
self.assertEqual('phoneNumber1', resolved_entity.attributes[3].name)
self.assertEqual('email1', resolved_entity.attributes[4].name)
self.assertEqual('name2', resolved_entity.attributes[5].name)
self.assertEqual('age2', resolved_entity.attributes[6].name)
self.assertEqual('address2', resolved_entity.attributes[7].name)
self.assertEqual('phoneNumber2', resolved_entity.attributes[8].name)
self.assertEqual('email2', resolved_entity.attributes[9].name)
self.assertEqual('personCount', resolved_entity.attributes[10].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[10].applied_traits[1].named_reference)
async def test_extends_entity(self):
"""CountAttribute on an entity definition"""
test_name = 'test_extends_entity'
entity_name = 'NewPerson'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
# Count attribute: "someCount"
# For resolution guidance, CountAttribute has to be used with Expansion so we do an Expansion of 1...1 here
# ExtendsEntityResolutionGuidance doesn't support doing expansions, so we only get the Count attribute
self.assertEqual(1, len(resolved_entity.attributes))
self.assertEqual('someCount', resolved_entity.attributes[0].name)
self.assertEqual(
'is.linkedEntity.array.count',
resolved_entity.attributes[0].applied_traits[1].named_reference)
async def test_source_with_EA(self):
test_name = 'test_source_with_EA'
entity_name = 'SalesSourceWithEA'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_subpath, entity_name, res_opt)
async def test_nested_FK_proj(self):
test_name = 'test_nested_FK_proj'
entity_name = 'SalesNestedFK'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_subpath, entity_name, res_opt)
async def test_entity_attribute(self):
test_name = 'test_entity_attribute'
entity_name = 'SalesEntityAttribute'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_subpath, entity_name, res_opt)
async def test_polymorphic(self):
test_name = 'test_polymorphic'
entity_name = 'PersonPolymorphicSource'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_subpath, entity_name, res_opt)
async def test_foreign_key_always(self):
test_name = 'test_foreign_key_always'
entity_name = 'SalesForeignKeyAlways'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_subpath, entity_name, res_opt)
async def test_group_name_proj(self) -> None:
"""Test for include attributes operation by Group Name"""
test_name = 'test_group_name_proj'
entity_name = 'Product'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_ea_proj(self) -> None:
"""Test for entity attribute with projection with an includeAttributes operation"""
test_name = 'test_ea_proj'
entity_name = 'Color'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_nested_3_of_3_proj(self) -> None:
"""Test for top level projection"""
test_name = 'test_nested_3_of_3_proj'
entity_name = 'Color'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_include_exclude_proj(self) -> None:
"""Test for Projections with include and exclude"""
test_name = 'test_include_exclude_proj'
entity_name = 'Color'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_polymorphic_proj(self) -> None:
"""Test for Include Attributes from a Polymorphic Source"""
test_name = 'test_polymorphic_proj'
entity_name = 'Person'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_array_proj(self) -> None:
"""Test for Include Attributes from an Array"""
test_name = 'test_array_proj'
entity_name = 'Sales'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_group_name(self) -> None:
"""Test for SelectsSomeTakeNames by Group Name"""
test_name = 'test_group_name'
entity_name = 'Product'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_composite_key_proj(self):
self.maxDiff = None
test_name = 'test_composite_key_proj'
entity_name = 'SalesCompositeKey'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_subpath, entity_name, res_opt)
async def test_array_rename(self) -> None:
"""Test for SelectsSomeTakeNames from a renamed Array"""
test_name = 'test_array_rename'
entity_name = 'Sales'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_ea(self) -> None:
"""Test for entity attribute with resolution guidance with a SelectsSomeTakeNames"""
test_name = 'test_ea'
entity_name = 'Color'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_conditional_proj_using_object_model(self):
"""Test for creating a projection with an AddAttributeGroup operation and a condition using the object model"""
test_name = 'test_conditional_proj_using_object_model'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
local_root = corpus.storage.fetch_root_folder('local')
# Create an entity.
entity = ProjectionTestUtils.create_entity(corpus, local_root)
# Create a projection with a condition that states the operation should only execute when the resolution directive is 'structured'.
projection = ProjectionTestUtils.create_projection(corpus, local_root)
projection.condition = 'structured==true'
# Create an AddAttributeGroup operation
add_att_group_op = corpus.make_object(CdmObjectType.OPERATION_ADD_ATTRIBUTE_GROUP_DEF)
add_att_group_op.attribute_group_name = 'PersonAttributeGroup'
projection.operations.append(add_att_group_op)
# Create an entity reference to hold this projection.
projection_entity_ref = corpus.make_object(CdmObjectType.ENTITY_REF, None) # type: CdmEntityReference
projection_entity_ref.explicit_reference = projection
# Create an entity attribute that contains this projection and add this to the entity.
entity_attribute = corpus.make_object(CdmObjectType.ENTITY_ATTRIBUTE_DEF, 'TestEntityAttribute') # type: CdmEntityAttributeDefinition
entity_attribute.entity = projection_entity_ref
entity.attributes.append(entity_attribute)
# Create resolution options with the 'referenceOnly' directive.
res_opt = ResolveOptions(entity.in_document)
res_opt.directives = AttributeResolutionDirectiveSet({'referenceOnly'})
# Resolve the entity with 'referenceOnly'
resolved_entity_with_reference_only = await entity.create_resolved_entity_async('Resolved_{}.cdm.json'.format(entity.entity_name), res_opt, local_root)
# Verify correctness of the resolved attributes after running the AddAttributeGroup operation
# Original set of attributes: ['id', 'name', 'value', 'date']
# Condition not met, keep attributes in flat list
self.assertEqual(4, len(resolved_entity_with_reference_only.attributes))
self.assertEqual('id', resolved_entity_with_reference_only.attributes[0].name)
self.assertEqual('name', resolved_entity_with_reference_only.attributes[1].name)
self.assertEqual('value', resolved_entity_with_reference_only.attributes[2].name)
self.assertEqual('date', resolved_entity_with_reference_only.attributes[3].name)
# Now resolve the entity with the 'structured' directive
res_opt.directives = AttributeResolutionDirectiveSet({'structured'})
resolved_entity_with_structured = await entity.create_resolved_entity_async('Resolved_{}.cdm.json'.format(entity.entity_name), res_opt, local_root)
# Verify correctness of the resolved attributes after running the AddAttributeGroup operation
# Original set of attributes: ['id', 'name', 'value', 'date']
# Condition met, put all attributes in an attribute group
att_group_definition = self.validate_attribute_group(resolved_entity_with_structured.attributes, 'PersonAttributeGroup')
self.assertEqual(4, len(att_group_definition.members))
self.assertEqual('id', att_group_definition.members[0].name)
self.assertEqual('name', att_group_definition.members[1].name)
self.assertEqual('value', att_group_definition.members[2].name)
self.assertEqual('date', att_group_definition.members[3].name)
async def test_multi_proj(self) -> None:
"""Test Multiple Nested Operations with Combine including ArrayExpansion and Rename"""
self.maxDiff = None
test_name = 'test_multi_proj'
entity_name = 'Customer'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_extends(self) -> None:
"""Test Entity Extends with a Resolution Guidance that selects 'one'"""
self.maxDiff = None
test_name = 'test_extends'
entity_name = 'Customer'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_ea_proj(self) -> None:
"""Test Entity Attribute with a Combine Attributes operation"""
self.maxDiff = None
test_name = 'test_ea_proj'
entity_name = 'Customer'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_sub_path)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, \
self.tests_sub_path, entity_name, res_opt)
async def test_array_source(self):
"""SelectsSomeAvoidNames on an array source"""
test_name = 'test_array_source'
entity_name = 'FriendGroup'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(
self, corpus, test_name, self.tests_subpath, entity_name,
res_opt)
entity = await corpus.fetch_object_async(
'local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(
corpus, entity, [])
# Original set of attributes: ['GroupOfPeoplePersonCount', 'GroupOfPeopleName1', 'GroupOfPeopleAge1', 'GroupOfPeopleAddress1',
# 'GroupOfPeoplePhoneNumber1', 'GroupOfPeopleEmail1', ..., 'GroupOfPeopleEmail3'] (16 total)
# Excluded attributes: ['GroupOfPeopleAge1', 'GroupOfPeopleAge2', 'GroupOfPeopleAge3']
self.assertEqual(13, len(resolved_entity.attributes))
self.assertEqual('GroupOfPeoplePersonCount',
resolved_entity.attributes[0].name)
self.assertEqual('GroupOfPeopleName1',
resolved_entity.attributes[1].name)
self.assertEqual('GroupOfPeopleAddress1',
resolved_entity.attributes[2].name)
self.assertEqual('GroupOfPeoplePhoneNumber1',
resolved_entity.attributes[3].name)
self.assertEqual('GroupOfPeopleEmail1',
resolved_entity.attributes[4].name)
self.assertEqual('GroupOfPeopleName2',
resolved_entity.attributes[5].name)
self.assertEqual('GroupOfPeopleAddress2',
resolved_entity.attributes[6].name)
self.assertEqual('GroupOfPeoplePhoneNumber2',
resolved_entity.attributes[7].name)
self.assertEqual('GroupOfPeopleEmail2',
resolved_entity.attributes[8].name)
self.assertEqual('GroupOfPeopleName3',
resolved_entity.attributes[9].name)
self.assertEqual('GroupOfPeopleAddress3',
resolved_entity.attributes[10].name)
self.assertEqual('GroupOfPeoplePhoneNumber3',
resolved_entity.attributes[11].name)
self.assertEqual('GroupOfPeopleEmail3',
resolved_entity.attributes[12].name)
async def test_same_start_end_ordinals(self):
"""Same start and end ordinals"""
test_name = 'test_same_start_end_ordinals'
entity_name = 'ThreeMusketeers'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, self.tests_subpath, entity_name, res_opt)
entity = await corpus.fetch_object_async('local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(corpus, entity, [])
# Original set of attributes: ["name", "age", "address"]
# Expand 1...1, renameFormat = {m}{o}
self.assertEqual(3, len(resolved_entity.attributes))
self.assertEqual('name1', resolved_entity.attributes[0].name)
self.assertEqual('age1', resolved_entity.attributes[1].name)
self.assertEqual('address1', resolved_entity.attributes[2].name)
async def test_conditional_proj(self):
"""ArrayExpansion with a condition"""
test_name = 'test_conditional_proj'
entity_name = 'ThreeMusketeers'
corpus = ProjectionTestUtils.get_corpus(test_name, self.tests_subpath)
for res_opt in self.res_opts_combinations:
await ProjectionTestUtils.load_entity_for_resolution_option_and_save(self, corpus, test_name, self.tests_subpath, entity_name, res_opt)
entity = await corpus.fetch_object_async('local:/{}.cdm.json/{}'.format(entity_name, entity_name))
resolved_entity = await ProjectionTestUtils.get_resolved_entity(corpus, entity, [])
# Original set of attributes: ["name", "age", "address"]
# Expand 1...3, renameFormat = {m}{o}
# No array expansion, condition was false
self.assertEqual(3, len(resolved_entity.attributes))
self.assertEqual('name', resolved_entity.attributes[0].name)
self.assertEqual('age', resolved_entity.attributes[1].name)
self.assertEqual('address', resolved_entity.attributes[2].name)