def test_cdm_collection_append_method(self):
cdm_corpus = CdmCorpusDefinition()
cdm_corpus.storage.default_namespace = 'local'
cdm_corpus.storage.mount('local', LocalAdapter('CdmCorpus/LocalPath'))
ctx = cdm_corpus.ctx
cdm_document = CdmDocumentDefinition(ctx, 'NameOfDocument')
collection = CdmCollection(ctx, cdm_document,
CdmObjectType.ATTRIBUTE_CONTEXT_DEF)
appended_attribute_context = collection.append('nameOfNewAttribute')
self.assertEqual(1, len(collection))
self.assertEqual('nameOfNewAttribute', collection[0].name)
self.assertEqual(cdm_document, collection[0].owner)
self.assertEqual(ctx, collection[0].ctx)
self.assertEqual(collection[0], appended_attribute_context)
attribute_context = CdmAttributeContext(ctx, 'NameOfAttributeContext')
appended_attribute = collection.append(attribute_context)
self.assertEqual(2, len(collection))
self.assertEqual(attribute_context, appended_attribute)
self.assertEqual(attribute_context, collection[1])
self.assertEqual(cdm_document, attribute_context.owner)
def test_cdm_collection_appending_list(self):
cdm_corpus = CdmCorpusDefinition()
cdm_corpus.storage.default_namespace = 'local'
cdm_corpus.storage.mount('local', LocalAdapter('CdmCorpus/LocalPath'))
ctx = cdm_corpus.ctx
cdm_document = CdmDocumentDefinition(ctx, 'NameOfDocument')
collection = CdmCollection(ctx, cdm_document,
CdmObjectType.LOCAL_ENTITY_DECLARATION_DEF)
entity_list = []
for i in range(0, 2):
entity = CdmEntityDefinition(cdm_corpus.ctx,
'entityName_{}'.format(i), None)
create_document_for_entity(cdm_corpus, entity)
entity_declaration = cdm_corpus.make_object(
CdmObjectType.LOCAL_ENTITY_DECLARATION_DEF, entity.entity_name,
False) # type: CdmLocalEntityDeclarationDefinition
entity_declaration.entity_path = '{}/{}'.format(
entity.owner.at_corpus_path, entity.entity_name)
entity_declaration.owner = entity.owner
entity_list.append(entity_declaration)
self.assertEqual(0, len(collection))
collection.extend(entity_list)
self.assertEqual(2, len(collection))
for i in range(0, 2):
self.assertEqual('entityName_{}'.format(i),
collection[i].entity_name)
def from_data(ctx: 'CdmCorpusContext', data: 'OperationAlterTraits') -> 'CdmOperationAlterTraits':
if not data:
return None
alter_traits_op = OperationBasePersistence.from_data(ctx,
CdmObjectType.OPERATION_ALTER_TRAITS_DEF, data) # type: CdmOperationAlterTraits
if 'traitsToAdd' in data:
alter_traits_op.traits_to_add = CdmCollection(ctx, alter_traits_op, CdmObjectType.TRAIT_REF)
utils.add_list_to_cdm_collection(alter_traits_op.traits_to_add, utils.create_trait_reference_array(ctx, data.traitsToAdd))
if 'traitsToRemove' in data:
alter_traits_op.traits_to_remove = CdmCollection(ctx, alter_traits_op, CdmObjectType.TRAIT_REF)
utils.add_list_to_cdm_collection(alter_traits_op.traits_to_remove, utils.create_trait_reference_array(ctx, data.traitsToRemove))
alter_traits_op.arguments_contain_wildcards = data.argumentsContainWildcards
if isinstance(data.applyTo, str):
alter_traits_op.apply_to = [data.applyTo]
elif isinstance(data.applyTo, list):
alter_traits_op.apply_to = data.applyTo
elif data.applyTo is not None:
logger.error(ctx, _TAG, OperationAlterTraitsPersistence.from_data.__name__, None, CdmLogCode.ERR_PERSIST_PROJ_UNSUPPORTED_PROP, 'applyTo', 'string or list of strings')
return alter_traits_op
def test_cdm_collection_remove_method(self):
cdm_corpus = CdmCorpusDefinition()
cdm_corpus.storage.default_namespace = 'local'
cdm_corpus.storage.mount('local', LocalAdapter('CdmCorpus/LocalPath'))
ctx = cdm_corpus.ctx
cdm_document = CdmDocumentDefinition(ctx, 'NameOfDocument')
collection = CdmCollection(ctx, cdm_document, CdmObjectType.ATTRIBUTE_CONTEXT_DEF)
appended_document = collection.append('nameOfNewDocument')
collection.append('otherDocument')
self.assertEqual(2, len(collection))
collection.remove(appended_document)
self.assertTrue(appended_document not in collection)
# try to remove a second time.
collection.remove(appended_document)
self.assertTrue(appended_document not in collection)
self.assertEqual(1, len(collection))
def test_cdm_collection_remove_at(self):
cdm_corpus = CdmCorpusDefinition()
cdm_corpus.storage.default_namespace = 'local'
cdm_corpus.storage.mount('local', LocalAdapter('CdmCorpus/LocalPath'))
ctx = cdm_corpus.ctx
cdm_document = CdmDocumentDefinition(ctx, 'NameOfDocument')
collection = CdmCollection(ctx, cdm_document,
CdmObjectType.ATTRIBUTE_CONTEXT_DEF)
collection.append('nameOfNewDocument')
appended_document2 = collection.append('otherDocument')
self.assertEqual(2, len(collection))
collection.pop(0)
self.assertEqual(1, len(collection))
self.assertEqual(appended_document2, collection[0])
collection.pop(1)
self.assertEqual(1, len(collection))
self.assertEqual(appended_document2, collection[0])
collection.pop(0)
self.assertEqual(0, len(collection))
def test_cdm_collection_change_makes_document_dirty(self):
manifest = generate_manifest('C:\\Nothing')
collection = CdmCollection(manifest.ctx, manifest,
CdmObjectType.ENTITY_REF)
manifest._is_dirty = False
collection.append(CdmEntityReference(manifest.ctx, 'name', False))
self.assertTrue(manifest._is_dirty)
manifest._is_dirty = False
collection.append('theName')
self.assertTrue(manifest._is_dirty)
entity = CdmEntityReference(manifest.ctx, 'otherEntity', False)
entity_list = [entity]
manifest._is_dirty = False
collection.extend(entity_list)
self.assertTrue(manifest._is_dirty)
manifest._is_dirty = False
entity2 = CdmEntityReference(manifest.ctx, 'otherEntity2', False)
collection.insert(0, entity2)
self.assertTrue(manifest._is_dirty)
manifest._is_dirty = False
collection.remove(entity)
self.assertTrue(manifest._is_dirty)
manifest._is_dirty = False
collection.pop(0)
self.assertTrue(manifest._is_dirty)
manifest._is_dirty = False
collection.clear()
self.assertTrue(manifest._is_dirty)
async def test_conditional_proj_using_object_model(self):
"""Test for creating a projection with an AddArtifactAttribute operation and a condition using the object model"""
test_name = 'test_conditional_proj_using_object_model'
corpus = ProjectionTestUtils.get_local_corpus(self.tests_subpath,
test_name)
local_root = corpus.storage.fetch_root_folder('local')
corpus.storage.mount('traitGroup',
LocalAdapter(self.trait_group_file_path))
# Create an entity.
entity = ProjectionTestUtils.create_entity(corpus, local_root)
entity.in_document.imports.append('traitGroup:/TraitGroup.cdm.json')
# 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) # type: CdmProjection
projection.condition = 'structured==true'
projection.run_sequentially = True
# Create an AlterTraits operation
alter_traits_op_1 = corpus.make_object(
CdmObjectType.OPERATION_ALTER_TRAITS_DEF
) # type: CdmOperationAlterTraits
alter_traits_op_1.traits_to_add = CdmCollection(
corpus.ctx, alter_traits_op_1, CdmObjectType.TRAIT_REF)
alter_traits_op_1.traits_to_add.append(
corpus.make_ref(CdmObjectType.TRAIT_REF, "means.TraitG100", True))
alter_traits_op_1.traits_to_add.append(
corpus.make_ref(CdmObjectType.TRAIT_GROUP_REF, "JobTitleBase",
True))
alter_traits_op_1.traits_to_remove = CdmCollection(
corpus.ctx, alter_traits_op_1, CdmObjectType.TRAIT_REF)
alter_traits_op_1.traits_to_remove.append(
corpus.make_ref(CdmObjectType.TRAIT_REF, "means.TraitG300", True))
projection.operations.append(alter_traits_op_1)
alter_traits_op_2 = corpus.make_object(
CdmObjectType.OPERATION_ALTER_TRAITS_DEF
) # type: CdmOperationAlterTraits
trait_g4 = corpus.make_ref(CdmObjectType.TRAIT_REF, "means.TraitG4",
True) # type: CdmTraitReference
trait_g4.arguments.append('precision', '5')
trait_g4.arguments.append('scale', '15')
alter_traits_op_2.traits_to_add = CdmCollection(
corpus.ctx, alter_traits_op_2, CdmObjectType.TRAIT_REF)
alter_traits_op_2.traits_to_add.append(trait_g4)
alter_traits_op_2.apply_to = []
alter_traits_op_2.apply_to.append('name')
projection.operations.append(alter_traits_op_2)
# 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)
# Original set of attributes: ['id', 'name', 'value', 'date']
# Condition not met, no traits are added
self.assertEqual(4,
len(resolved_entity_with_reference_only.attributes))
self.validate_trait(resolved_entity_with_reference_only.attributes[0],
'id', False, True)
self.validate_trait(resolved_entity_with_reference_only.attributes[1],
'name', False, True)
self.validate_trait(resolved_entity_with_reference_only.attributes[2],
'value', False, True)
self.validate_trait(resolved_entity_with_reference_only.attributes[3],
'date', False, True)
# 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)
# Original set of attributes: ['id', 'name', 'value', 'date']
# Condition met, new traits are added
self.assertEqual(4, len(resolved_entity_with_structured.attributes))
self.validate_trait(resolved_entity_with_structured.attributes[0],
'id')
self.validate_trait(resolved_entity_with_structured.attributes[1],
'name', True)
self.validate_trait(resolved_entity_with_structured.attributes[2],
'value')
self.validate_trait(resolved_entity_with_structured.attributes[3],
'date')