public async Task TestAlterTraitsOnAttrGrpProj() { string testName = nameof(TestAlterTraitsOnAttrGrpProj); string entityName = "NewPerson"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); corpus.Storage.Mount("traitGroup", new LocalAdapter(traitGroupFilePath)); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); CdmAttributeGroupReference attGroupReference = resolvedEntity.Attributes[0] as CdmAttributeGroupReference; CdmAttributeGroupDefinition attGroupDefinition = attGroupReference.ExplicitReference as CdmAttributeGroupDefinition; Assert.AreEqual(5, attGroupDefinition.Members.Count); Assert.AreEqual("PersonAttributeGroup", attGroupDefinition.AttributeGroupName); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG100")); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG200")); Assert.IsNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG300")); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG400")); CdmTraitReference traitG4 = (CdmTraitReference)attGroupDefinition.ExhibitsTraits.Item("means.TraitG4"); Assert.IsNotNull(traitG4); Assert.AreEqual("5", traitG4.Arguments.FetchValue("precision")); Assert.AreEqual("15", traitG4.Arguments.FetchValue("scale")); }
public async Task TestNestedProj() { string testName = "TestNestedProj"; string entityName = "NewPerson"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email"] CdmAttributeGroupDefinition outerAttGroup = ProjectionTestUtils.ValidateAttributeGroup(resolvedEntity.Attributes, "OuterAttributeGroup"); CdmAttributeGroupDefinition innerAttGroup = ProjectionTestUtils.ValidateAttributeGroup(outerAttGroup.Members, "InnerAttributeGroup"); Assert.AreEqual(5, innerAttGroup.Members.Count); Assert.AreEqual("name", (innerAttGroup.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (innerAttGroup.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("address", (innerAttGroup.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (innerAttGroup.Members[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (innerAttGroup.Members[4] as CdmTypeAttributeDefinition).Name); }
public async Task TestCombineOpsProj() { string testName = "TestCombineOpsProj"; string entityName = "NewPerson"; CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email"] // Included attributes: ["age", "phoneNumber"] CdmAttributeGroupDefinition attGroupDefinition = this.ValidateAttributeGroup(resolvedEntity.Attributes, "PersonAttributeGroup", 3); Assert.AreEqual(5, attGroupDefinition.Members.Count); Assert.AreEqual("name", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("address", (attGroupDefinition.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (attGroupDefinition.Members[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (attGroupDefinition.Members[4] as CdmTypeAttributeDefinition).Name); // Check the attributes coming from the IncludeAttribute operation Assert.AreEqual("age", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name); }
public async Task TestTypeAttributeProj() { string testName = "TestTypeAttributeProj"; string entityName = "Person"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "referenceOnly" }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email"] // Add attribute group applied to "address" Assert.AreEqual(5, resolvedEntity.Attributes.Count); Assert.AreEqual("name", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name); CdmAttributeGroupDefinition attGroupDefinition = ProjectionTestUtils.ValidateAttributeGroup(resolvedEntity.Attributes, "AddressAttributeGroup", 5, 2); Assert.AreEqual("address", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name); }
public async Task TestEANameProj() { string testName = "TestEANameProj"; string entityName = "NewPerson"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "structured" }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email", "title", "company", "tenure"] // Excluded attributes: ["OccupationInfo"] (name of entity attribute that contains "title", "company", "tenure") Assert.AreEqual(1, resolvedEntity.Attributes.Count); // attribute group created because of structured directive CdmAttributeGroupDefinition attGroup = (resolvedEntity.Attributes[0] as CdmAttributeGroupReference).ExplicitReference as CdmAttributeGroupDefinition; Assert.AreEqual(5, attGroup.Members.Count); Assert.AreEqual("name", (attGroup.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (attGroup.Members[1] as CdmTypeAttributeDefinition).Name, "age"); Assert.AreEqual("address", (attGroup.Members[2] as CdmTypeAttributeDefinition).Name, "address"); Assert.AreEqual("phoneNumber", (attGroup.Members[3] as CdmTypeAttributeDefinition).Name, "phoneNumber"); Assert.AreEqual("email", (attGroup.Members[4] as CdmTypeAttributeDefinition).Name, "email"); }
public async Task TestPersistAttributeGroupDefinition() { var corpus = new CdmCorpusDefinition(); var attGroup = new CdmAttributeGroupDefinition(corpus.Ctx, "attGroup"); var persistedGroup = AttributeGroupPersistence.ToData(attGroup, new ResolveOptions(attGroup.InDocument), new CopyOptions()); Assert.IsNotNull(persistedGroup.Members); }
public static dynamic ToData(CdmAttributeGroupDefinition instance, ResolveOptions resOpt, CopyOptions options) { return(new AttributeGroup { Explanation = instance.Explanation, AttributeGroupName = instance.AttributeGroupName, ExhibitsTraits = CopyDataUtils.ListCopyData(resOpt, instance.ExhibitsTraits, options), AttributeContext = instance.AttributeContext?.CopyData(resOpt, options) as string, Members = CopyDataUtils.ListCopyData(resOpt, instance.Members, options) }); }
public async Task TestTypeAttribute() { string testName = "TestTypeAttribute"; string entityName = "Person"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition nonStructuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Original set of attributes: [ "FavoriteTerms" ] // in non-structured form // addArtifactAttribute : { "Term key" , "insertAtTop": true } // Expand 1...2; // renameAttributes = { {m}_{o}_key, apply to "Term key" } // renameAttributes = { {m}_{o}_value, apply to "FavoriteTerms" } // alterTraits = { indicates.expansionInfo.mapKey(expansionName: "{a}", ordinal: "{o}") , apply to "Term key" , "argumentsContainWildcards" : true } // alterTraits = { has.expansionInfo.mapValue(expansionName: "{a}", ordinal: "{o}") , apply to "FavoriteTerms" , "argumentsContainWildcards" : true } // addArtifactAttribute : number of favorite terms" // alterTraits = { indicates.expansionInfo.count(expansionName: "{a}") , apply to "number of favorite terms" , "argumentsContainWildcards" : true } Assert.AreEqual(5, nonStructuredResolvedEntity.Attributes.Count); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[0] as CdmTypeAttributeDefinition, "Term key_1_key", 1, "FavoriteTerms", isKey: true); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[1] as CdmTypeAttributeDefinition, "FavoriteTerms_1_value", 1, "FavoriteTerms"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[2] as CdmTypeAttributeDefinition, "Term key_2_key", 2, "FavoriteTerms", isKey: true); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[3] as CdmTypeAttributeDefinition, "FavoriteTerms_2_value", 2, "FavoriteTerms"); Assert.AreEqual("number of favorite terms", (nonStructuredResolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name); Assert.IsNotNull(nonStructuredResolvedEntity.Attributes[4].AppliedTraits.Item("indicates.expansionInfo.count")); Assert.AreEqual("FavoriteTerms", (nonStructuredResolvedEntity.Attributes[4].AppliedTraits.Item("indicates.expansionInfo.count") as CdmTraitReference).Arguments[0].Value); // Original set of attributes: [ "FavoriteTerms" ] // in structured form // alterTraits = { is.dataFormat.mapValue } // addArtifactAttribute : { "Favorite Terms Key" (with trait "is.dataFormat.mapKey") , "insertAtTop": true } // addAttributeGroup: favorite Term Group // alterTraits = { is.dataFormat.map } CdmEntityDefinition structuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "structured" }); Assert.AreEqual(1, structuredResolvedEntity.Attributes.Count); CdmAttributeGroupDefinition attGroupDefinition = ProjectionTestUtils.ValidateAttributeGroup(structuredResolvedEntity.Attributes, "favorite Term Group"); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("is.dataFormat.map")); Assert.AreEqual("Favorite Terms Key", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.IsNotNull(attGroupDefinition.Members[0].AppliedTraits.Item("is.dataFormat.mapKey")); Assert.AreEqual("FavoriteTerms", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name); Assert.IsNotNull(attGroupDefinition.Members[1].AppliedTraits.Item("is.dataFormat.mapValue")); }
public async Task TestNonMaxDepthCached() { CdmCorpusDefinition cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestMaxDepth"); CdmEntityDefinition aEnt = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("A.cdm.json/A"); CdmEntityDefinition bEnt = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("B.cdm.json/B"); CdmEntityDefinition cEnt = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("C.cdm.json/C"); CdmEntityDefinition dEnt = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("D.cdm.json/D"); // when resolving A, B should be cached and it should exclude any attributes from D because // it is outside of the maxDepth CdmEntityDefinition resA = await aEnt.CreateResolvedEntityAsync("resA", new ResolveOptions( aEnt.InDocument, new AttributeResolutionDirectiveSet(new HashSet <string> { "normalized", "structured" }) )); // ensure that when resolving B on its own, attributes from D are included CdmEntityDefinition resB = await bEnt.CreateResolvedEntityAsync("resB", new ResolveOptions( bEnt.InDocument, new AttributeResolutionDirectiveSet(new HashSet <string> { "normalized", "structured" }) )); // check the attributes found in D from resolving A CdmAttributeGroupDefinition bAttInA = ((CdmAttributeGroupDefinition)((CdmAttributeGroupReference)resA.Attributes[1]).ExplicitReference); CdmAttributeGroupDefinition cAttInA = ((CdmAttributeGroupDefinition)((CdmAttributeGroupReference)(bAttInA.Members[1])).ExplicitReference); CdmAttributeGroupDefinition dAttInA = ((CdmAttributeGroupDefinition)((CdmAttributeGroupReference)(cAttInA.Members[1])).ExplicitReference); Assert.AreEqual(dAttInA.Members.Count, 1); // check that the attribute in D is a foreign key attribute CdmTypeAttributeDefinition dIdAttFromA = (CdmTypeAttributeDefinition)(dAttInA.Members[0]); Assert.AreEqual(dIdAttFromA.Name, "dId"); Assert.IsNotNull(dIdAttFromA.AppliedTraits.Item("is.linkedEntity.identifier")); // check the attributes found in D from resolving B CdmAttributeGroupDefinition cAttInB = ((CdmAttributeGroupDefinition)((CdmAttributeGroupReference)resB.Attributes[1]).ExplicitReference); CdmAttributeGroupDefinition dAttInB = ((CdmAttributeGroupDefinition)((CdmAttributeGroupReference)(cAttInB.Members[1])).ExplicitReference); Assert.AreEqual(dAttInB.Members.Count, 2); // check that the attribute in D is not a foreign key attribute CdmTypeAttributeDefinition dIdAttFromB = (CdmTypeAttributeDefinition)(dAttInB.Members[0]); Assert.AreEqual(dIdAttFromB.Name, "dId"); Assert.IsNull(dIdAttFromB.AppliedTraits.Item("is.linkedEntity.identifier")); }
/// <summary> /// Validates the creation of an attribute group and return its definition /// </summary> /// <param name="attributes">The collection of attributes.</param> /// <param name="attributeGroupName">The attribute group name.</param> /// <param name="attributesSize">The expected size of the attributes collection.</param> /// <returns></returns> private CdmAttributeGroupDefinition ValidateAttributeGroup(CdmCollection <CdmAttributeItem> attributes, string attributeGroupName, int attributesSize = 1, int index = 0) { Assert.AreEqual(attributesSize, attributes.Count); Assert.AreEqual(CdmObjectType.AttributeGroupRef, attributes[index].ObjectType); CdmAttributeGroupReference attGroupReference = attributes[index] as CdmAttributeGroupReference; Assert.IsNotNull(attGroupReference.ExplicitReference); CdmAttributeGroupDefinition attGroupDefinition = attGroupReference.ExplicitReference as CdmAttributeGroupDefinition; Assert.AreEqual(attributeGroupName, attGroupDefinition.AttributeGroupName); return(attGroupDefinition); }
public async Task TestEntityAttribute() { string testName = "TestEntityAttribute"; string entityName = "ThreeMusketeers"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition nonStructuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Original set of attributes: ["name", "age", "address"] // in non-structured form // Expand 1...3; // renameFormat = {m}{o}; // alterTraits = { has.expansionInfo.list(expansionName: "{a}", ordinal: "{o}", memberAttribute: "{mo}") , "argumentsContainWildcards" : true } // addArtifactAttribute : "personCount" // alterTraits = { indicates.expansionInfo.count(expansionName: "{a}") , apply to "personCount" , "argumentsContainWildcards" : true } Assert.AreEqual(10, nonStructuredResolvedEntity.Attributes.Count); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[0] as CdmTypeAttributeDefinition, "name1", 1, "ThreePeople", "name"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[1] as CdmTypeAttributeDefinition, "age1", 1, "ThreePeople", "age"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[2] as CdmTypeAttributeDefinition, "address1", 1, "ThreePeople", "address"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[3] as CdmTypeAttributeDefinition, "name2", 2, "ThreePeople", "name"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[4] as CdmTypeAttributeDefinition, "age2", 2, "ThreePeople", "age"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[5] as CdmTypeAttributeDefinition, "address2", 2, "ThreePeople", "address"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[6] as CdmTypeAttributeDefinition, "name3", 3, "ThreePeople", "name"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[7] as CdmTypeAttributeDefinition, "age3", 3, "ThreePeople", "age"); ProjectionTestUtils.ValidateExpansionInfoTrait(nonStructuredResolvedEntity.Attributes[8] as CdmTypeAttributeDefinition, "address3", 3, "ThreePeople", "address"); Assert.AreEqual("personCount", (nonStructuredResolvedEntity.Attributes[9] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("indicates.expansionInfo.count", nonStructuredResolvedEntity.Attributes[9].AppliedTraits[1].NamedReference); Assert.AreEqual("ThreePeople", (nonStructuredResolvedEntity.Attributes[9].AppliedTraits[1] as CdmTraitReference).Arguments[0].Value); // Original set of attributes: ["name", "age", "address"] // in structured form // alterTraits = { is.dataFormat.list } // addAttributeGroup: favoriteMusketeers CdmEntityDefinition structuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "structured" }); Assert.AreEqual(1, structuredResolvedEntity.Attributes.Count); CdmAttributeGroupDefinition attGroupDefinition = ProjectionTestUtils.ValidateAttributeGroup(structuredResolvedEntity.Attributes, "favoriteMusketeers"); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("is.dataFormat.list")); }
public async Task TestReadingIsPrimaryKey() { var testInputPath = TestHelper.GetInputFolderPath(testsSubpath, "TestReadingIsPrimaryKey"); CdmCorpusDefinition corpus = new CdmCorpusDefinition(); corpus.SetEventCallback(new EventCallback { Invoke = CommonDataModelLoader.ConsoleStatusReport }, CdmStatusLevel.Warning); corpus.Storage.Mount("local", new LocalAdapter(testInputPath)); corpus.Storage.DefaultNamespace = "local"; // Read from an unresolved entity schema. CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership.cdm.json/TeamMembership"); CdmAttributeGroupReference attributeGroupRef = (CdmAttributeGroupReference)entity.Attributes[0]; CdmAttributeGroupDefinition attributeGroup = (CdmAttributeGroupDefinition)attributeGroupRef.ExplicitReference; CdmTypeAttributeDefinition typeAttribute = (CdmTypeAttributeDefinition)attributeGroup.Members[0]; Assert.IsTrue((bool)typeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy1 = typeAttribute.AppliedTraits[1]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy1.NamedReference); Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", isIdentifiedBy1.Arguments[0].Value); // Read from a resolved entity schema. CdmEntityDefinition resolvedEntity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership_Resolved.cdm.json/TeamMembership"); CdmTypeAttributeDefinition resolvedTypeAttribute = (CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]; Assert.IsTrue((bool)resolvedTypeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy2 = resolvedTypeAttribute.AppliedTraits[6]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy2.NamedReference); CdmAttributeReference argumentValue = isIdentifiedBy2.Arguments[0].Value; Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", argumentValue.NamedReference); }
public async Task TestEntityAttributeProjUsingObjectModel() { string testName = "TestEntityAttributeProjUsingObjectModel"; CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath); CdmFolderDefinition localRoot = corpus.Storage.FetchRootFolder("local"); // Create an entity CdmEntityDefinition entity = ProjectionTestUtils.CreateEntity(corpus, localRoot); // Create a projection CdmProjection projection = ProjectionTestUtils.CreateProjection(corpus, localRoot); // Create an AddAttributeGroup operation CdmOperationAddAttributeGroup addAttGroupOp = corpus.MakeObject <CdmOperationAddAttributeGroup>(CdmObjectType.OperationAddAttributeGroupDef); addAttGroupOp.AttributeGroupName = "PersonAttributeGroup"; projection.Operations.Add(addAttGroupOp); // Create an entity reference to hold this projection CdmEntityReference projectionEntityRef = corpus.MakeObject <CdmEntityReference>(CdmObjectType.EntityRef, null); projectionEntityRef.ExplicitReference = projection; // Create an entity attribute that contains this projection and add this to the entity CdmEntityAttributeDefinition entityAttribute = corpus.MakeObject <CdmEntityAttributeDefinition>(CdmObjectType.EntityAttributeDef, "TestEntityAttribute"); entityAttribute.Entity = projectionEntityRef; entity.Attributes.Add(entityAttribute); // Resolve the entity. CdmEntityDefinition resolvedEntity = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", null, localRoot); // Verify correctness of the resolved attributes after running the AddAttributeGroup operation // Original set of attributes: ["id", "name", "value", "date"] CdmAttributeGroupDefinition attGroupDefinition = this.ValidateAttributeGroup(resolvedEntity.Attributes, "PersonAttributeGroup"); Assert.AreEqual(4, attGroupDefinition.Members.Count); Assert.AreEqual("id", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("name", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("value", (attGroupDefinition.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("date", (attGroupDefinition.Members[3] as CdmTypeAttributeDefinition).Name); }
public static void ValidateAttributeGroupRef(AttributeExpectedValue expected, CdmAttributeGroupReference actual) { if (expected.AttributeGroupName != null || expected.Members != null) { if (actual.ExplicitReference != null) { CdmAttributeGroupDefinition actualObj = ((CdmAttributeGroupDefinition)actual.ExplicitReference); if (expected.AttributeGroupName != null) { Assert.AreEqual(expected.AttributeGroupName, actualObj.AttributeGroupName); } if (expected.AttributeContext != null) { Assert.AreEqual(expected.AttributeContext, actualObj.AttributeContext.NamedReference); } if (expected.Members != null) { Assert.AreEqual(expected.Members.Count, actualObj.Members.Count); for (int i = 0; i < actualObj.Members.Count; i++) { if (actualObj.Members[i].GetType() == typeof(CdmTypeAttributeDefinition)) { AttributeExpectedValue exp = (AttributeExpectedValue)expected.Members[i]; CdmTypeAttributeDefinition act = (CdmTypeAttributeDefinition)actualObj.Members[i]; ValidateTypeAttributeDefinition(exp, act); } else if (actualObj.Members[i].GetType() == typeof(CdmAttributeGroupReference)) { AttributeExpectedValue exp = (AttributeExpectedValue)expected.Members[i]; CdmAttributeGroupReference act = (CdmAttributeGroupReference)actualObj.Members[i]; ValidateAttributeGroupRef(exp, act); } else { throw new NotImplementedException("Unknown type!"); } } } } } }
public async Task TestReadingIsPrimaryKeyConstructedFromPurpose() { var testInputPath = TestHelper.GetInputFolderPath(testsSubpath, "TestReadingIsPrimaryKeyConstructedFromPurpose"); CdmCorpusDefinition corpus = new CdmCorpusDefinition(); corpus.SetEventCallback(new EventCallback { Invoke = CommonDataModelLoader.ConsoleStatusReport }, CdmStatusLevel.Warning); corpus.Storage.Mount("local", new LocalAdapter(testInputPath)); corpus.Storage.DefaultNamespace = "local"; CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership.cdm.json/TeamMembership"); CdmAttributeGroupReference attributeGroupRef = (CdmAttributeGroupReference)entity.Attributes[0]; CdmAttributeGroupDefinition attributeGroup = (CdmAttributeGroupDefinition)attributeGroupRef.ExplicitReference; CdmTypeAttributeDefinition typeAttribute = (CdmTypeAttributeDefinition)attributeGroup.Members[0]; Assert.AreEqual("identifiedBy", typeAttribute.Purpose.NamedReference); Assert.IsTrue((bool)typeAttribute.IsPrimaryKey); }
/// <summary> /// Get the traits for all the attributes of a resolved entity /// </summary> /// <param name="resolvedEntity"></param> private void GetTraits(CdmCollection <CdmAttributeItem> attributes) { foreach (CdmAttributeItem attrib in attributes) { string attribCorpusPath = attrib.AtCorpusPath; bldr.AppendLine(attribCorpusPath); if (attrib is CdmAttributeGroupReference) { CdmAttributeGroupDefinition attGroupDef = (CdmAttributeGroupDefinition)(attrib as CdmAttributeGroupReference).ExplicitReference; bldr.AppendLine(attGroupDef.AtCorpusPath); GetTraitCollection(attGroupDef.ExhibitsTraits); GetTraits(attGroupDef.Members); } else { GetTraitCollection(attrib.AppliedTraits); } } }
public async Task TestConditionalProj() { string testName = "TestConditionalProj"; string entityName = "NewPerson"; CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "referenceOnly" }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email"] // Condition not met, keep attributes in flat list Assert.AreEqual(5, resolvedEntity.Attributes.Count); Assert.AreEqual("name", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("address", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name); CdmEntityDefinition resolvedEntity2 = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "structured" }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email"] // Condition met, put all attributes in an attribute group CdmAttributeGroupDefinition attGroupDefinition = this.ValidateAttributeGroup(resolvedEntity2.Attributes, "PersonAttributeGroup"); Assert.AreEqual(5, attGroupDefinition.Members.Count); Assert.AreEqual("name", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("address", (attGroupDefinition.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (attGroupDefinition.Members[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (attGroupDefinition.Members[4] as CdmTypeAttributeDefinition).Name); }
public async Task TestCircularReference() { CdmCorpusDefinition cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestCircularReference"); CdmEntityDefinition customer = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("local:/Customer.cdm.json/Customer"); CdmEntityDefinition resCustomerStructured = await customer.CreateResolvedEntityAsync("resCustomer", new ResolveOptions( customer.InDocument, new AttributeResolutionDirectiveSet(new HashSet <string> { "normalized", "structured", "noMaxDepth" }) )); // check that the circular reference attribute has a single id attribute CdmAttributeGroupDefinition storeGroupAtt = ((CdmAttributeGroupReference)resCustomerStructured.Attributes[1]).ExplicitReference as CdmAttributeGroupDefinition; CdmAttributeGroupDefinition customerGroupAtt = ((CdmAttributeGroupReference)storeGroupAtt.Members[1]).ExplicitReference as CdmAttributeGroupDefinition; Assert.AreEqual(1, customerGroupAtt.Members.Count); Assert.AreEqual("customerId", ((CdmTypeAttributeDefinition)customerGroupAtt.Members[0]).Name); }
public async Task TestReadingIsPrimaryKey() { CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestReadingIsPrimaryKey"); var resOpt = new ResolveOptions() { StrictValidation = true }; // Read from an unresolved entity schema. CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership.cdm.json/TeamMembership", null, resOpt); CdmAttributeGroupReference attributeGroupRef = (CdmAttributeGroupReference)entity.Attributes[0]; CdmAttributeGroupDefinition attributeGroup = (CdmAttributeGroupDefinition)attributeGroupRef.ExplicitReference; CdmTypeAttributeDefinition typeAttribute = (CdmTypeAttributeDefinition)attributeGroup.Members[0]; Assert.IsTrue((bool)typeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy1 = typeAttribute.AppliedTraits[1]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy1.NamedReference); Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", isIdentifiedBy1.Arguments[0].Value); // Read from a resolved entity schema. CdmEntityDefinition resolvedEntity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership_Resolved.cdm.json/TeamMembership", null, resOpt); CdmTypeAttributeDefinition resolvedTypeAttribute = (CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]; Assert.IsTrue((bool)resolvedTypeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy2 = resolvedTypeAttribute.AppliedTraits[6]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy2.NamedReference); CdmAttributeReference argumentValue = isIdentifiedBy2.Arguments[0].Value; Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", argumentValue.NamedReference); }
public async Task TestMultipleOpProj() { string testName = "TestMultipleOpProj"; string entityName = "NewPerson"; CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Original set of attributes: ["name", "age", "address", "phoneNumber", "email"] // This will result in two attribute groups with the same set of attributes being generated CdmAttributeGroupDefinition attGroup1 = this.ValidateAttributeGroup(resolvedEntity.Attributes, "PersonAttributeGroup", 2); Assert.AreEqual(5, attGroup1.Members.Count); Assert.AreEqual("name", (attGroup1.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (attGroup1.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("address", (attGroup1.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (attGroup1.Members[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (attGroup1.Members[4] as CdmTypeAttributeDefinition).Name); CdmAttributeGroupDefinition attGroup2 = this.ValidateAttributeGroup(resolvedEntity.Attributes, "SecondAttributeGroup", 2, 1); Assert.AreEqual(5, attGroup2.Members.Count); Assert.AreEqual("name", (attGroup2.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("age", (attGroup2.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("address", (attGroup2.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("phoneNumber", (attGroup2.Members[3] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("email", (attGroup2.Members[4] as CdmTypeAttributeDefinition).Name); }
public async Task TestSymbolResolution() { CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(TestsSubpath, "TestSymbolResolution"); // load the file CdmEntityDefinition ent = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/symbolEntity.cdm.json/symbolEnt"); ResolveOptions resOpt = new ResolveOptions(ent.InDocument); // resolve a reference to the trait object CdmObjectBase traitDef = corpus.ResolveSymbolReference( resOpt, ent.InDocument, "symbolEnt/exhibitsTraits/someTraitOnEnt", CdmObjectType.TraitDef, false ); Assert.IsTrue(traitDef is CdmTraitDefinition); // resolve a path to the reference object that contains the trait CdmObjectBase traitRef = corpus.ResolveSymbolReference( resOpt, ent.InDocument, "symbolEnt/exhibitsTraits/someTraitOnEnt/(ref)", CdmObjectType.TraitDef, false ); Assert.IsTrue(traitRef is CdmTraitReference); // FetchObjectDefinition on a path to a reference should fetch the actual object CdmTraitDefinition traitRefDefinition = traitRef.FetchObjectDefinition <CdmTraitDefinition>(resOpt); CdmTraitDefinition traitDefDefinition = traitDef.FetchObjectDefinition <CdmTraitDefinition>(resOpt); Assert.AreEqual(traitRefDefinition, traitDef); Assert.AreEqual(traitDefDefinition, traitDef); CdmObjectBase groupRef = corpus.ResolveSymbolReference( resOpt, ent.InDocument, "symbolEnt/hasAttributes/someGroupRef/(ref)", CdmObjectType.AttributeGroupDef, false ); Assert.IsTrue(groupRef is CdmAttributeGroupReference); CdmObjectBase groupDef = corpus.ResolveSymbolReference( resOpt, ent.InDocument, "symbolEnt/hasAttributes/someGroupRef", CdmObjectType.AttributeGroupDef, false ); Assert.IsTrue(groupDef is CdmAttributeGroupDefinition); // calling FetchObjectDefinition on a symbol to a ref or def should both give the definition CdmAttributeGroupDefinition groupRefDefinition = groupRef.FetchObjectDefinition <CdmAttributeGroupDefinition>(resOpt); CdmAttributeGroupDefinition groupDefDefinition = groupDef.FetchObjectDefinition <CdmAttributeGroupDefinition>(resOpt); Assert.AreEqual(groupRefDefinition, groupDef); Assert.AreEqual(groupDefDefinition, groupDef); CdmObjectBase typeAtt = corpus.ResolveSymbolReference( resOpt, ent.InDocument, "symbolEnt/hasAttributes/someGroupRef/members/someAttribute", CdmObjectType.AttributeGroupDef, false ); Assert.IsTrue(typeAtt is CdmTypeAttributeDefinition); }
public async Task TestEntityAttribute() { string testName = "TestEntityAttribute"; string entityName = "ThreeMusketeers"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition nonStructuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Original set of attributes: ["name", "age", "address"] // in non-structured form // addArtifactAttribute : { "key" , "insertAtTop": true } // Expand 1...3; // renameAttributes = { {a}_{o}_key, apply to "key" } // renameAttributes = { {a}_{m}_{o}_value, apply to "name", "age", "address" } // alterTraits = { indicates.expansionInfo.mapKey(expansionName: "{a}", ordinal: "{o}") , apply to "key" , "argumentsContainWildcards" : true } // alterTraits = { has.expansionInfo.mapValue(expansionName: "{a}", ordinal: "{o}", memberAttribute: "{mo}") , apply to "name", "age", "address" , "argumentsContainWildcards" : true } // addArtifactAttribute : "personCount" // alterTraits = { indicates.expansionInfo.count(expansionName: "{a}") , apply to "personCount" , "argumentsContainWildcards" : true } Assert.AreEqual(13, nonStructuredResolvedEntity.Attributes.Count); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[0] as CdmTypeAttributeDefinition, "key_1_key", 1, "ThreePeople", isKey: true); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[1] as CdmTypeAttributeDefinition, "ThreePeople_name_1_value", 1, "ThreePeople", "name"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[2] as CdmTypeAttributeDefinition, "ThreePeople_age_1_value", 1, "ThreePeople", "age"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[3] as CdmTypeAttributeDefinition, "ThreePeople_address_1_value", 1, "ThreePeople", "address"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[4] as CdmTypeAttributeDefinition, "key_2_key", 2, "ThreePeople", isKey: true); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[5] as CdmTypeAttributeDefinition, "ThreePeople_name_2_value", 2, "ThreePeople", "name"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[6] as CdmTypeAttributeDefinition, "ThreePeople_age_2_value", 2, "ThreePeople", "age"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[7] as CdmTypeAttributeDefinition, "ThreePeople_address_2_value", 2, "ThreePeople", "address"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[8] as CdmTypeAttributeDefinition, "key_3_key", 3, "ThreePeople", isKey: true); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[9] as CdmTypeAttributeDefinition, "ThreePeople_name_3_value", 3, "ThreePeople", "name"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[10] as CdmTypeAttributeDefinition, "ThreePeople_age_3_value", 3, "ThreePeople", "age"); ValidateAttributeTrait(nonStructuredResolvedEntity.Attributes[11] as CdmTypeAttributeDefinition, "ThreePeople_address_3_value", 3, "ThreePeople", "address"); Assert.AreEqual("personCount", (nonStructuredResolvedEntity.Attributes[12] as CdmTypeAttributeDefinition).Name); Assert.IsNotNull(nonStructuredResolvedEntity.Attributes[12].AppliedTraits.Item("indicates.expansionInfo.count")); Assert.AreEqual("ThreePeople", (nonStructuredResolvedEntity.Attributes[12].AppliedTraits.Item("indicates.expansionInfo.count") as CdmTraitReference).Arguments[0].Value); // Original set of attributes: ["name", "age", "address"] // in structured form // addAttributeGroup: favorite people // alterTraits = { is.dataFormat.mapValue } // addArtifactAttribute : { "favorite People Key" (with trait "is.dataFormat.mapKey") , "insertAtTop": true } // addAttributeGroup: favorite People Group // alterTraits = { is.dataFormat.map } CdmEntityDefinition structuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "structured" }); Assert.AreEqual(1, structuredResolvedEntity.Attributes.Count); CdmAttributeGroupDefinition attGroupDefinition = ProjectionTestUtils.ValidateAttributeGroup(structuredResolvedEntity.Attributes, "favorite People Group"); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("is.dataFormat.map")); Assert.AreEqual("favorite People Key", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.IsNotNull(attGroupDefinition.Members[0].AppliedTraits.Item("is.dataFormat.mapKey")); Assert.AreEqual(CdmObjectType.AttributeGroupRef, attGroupDefinition.Members[1].ObjectType); CdmAttributeGroupReference innerAttGroupRef = attGroupDefinition.Members[1] as CdmAttributeGroupReference; Assert.IsNotNull(innerAttGroupRef.ExplicitReference); CdmAttributeGroupDefinition innerAttGroupDefinition = innerAttGroupRef.ExplicitReference as CdmAttributeGroupDefinition; Assert.AreEqual("favorite people", innerAttGroupDefinition.AttributeGroupName); Assert.IsNotNull(innerAttGroupDefinition.ExhibitsTraits.Item("is.dataFormat.mapValue")); }
public async Task TestConditionalProjUsingObjectModel() { string testName = "TestConditionalProjUsingObjectModel"; CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath); CdmFolderDefinition localRoot = corpus.Storage.FetchRootFolder("local"); // Create an entity. CdmEntityDefinition entity = ProjectionTestUtils.CreateEntity(corpus, localRoot); // Create a projection with a condition that states the operation should only execute when the resolution directive is 'structured'. CdmProjection projection = ProjectionTestUtils.CreateProjection(corpus, localRoot); projection.Condition = "structured==true"; // Create an AddAttributeGroup operation CdmOperationAddAttributeGroup addAttGroupOp = corpus.MakeObject <CdmOperationAddAttributeGroup>(CdmObjectType.OperationAddAttributeGroupDef); addAttGroupOp.AttributeGroupName = "PersonAttributeGroup"; projection.Operations.Add(addAttGroupOp); // Create an entity reference to hold this projection. CdmEntityReference projectionEntityRef = corpus.MakeObject <CdmEntityReference>(CdmObjectType.EntityRef, null); projectionEntityRef.ExplicitReference = projection; // Create an entity attribute that contains this projection and add this to the entity. CdmEntityAttributeDefinition entityAttribute = corpus.MakeObject <CdmEntityAttributeDefinition>(CdmObjectType.EntityAttributeDef, "TestEntityAttribute"); entityAttribute.Entity = projectionEntityRef; entity.Attributes.Add(entityAttribute); // Create resolution options with the 'referenceOnly' directive. ResolveOptions resOpt = new ResolveOptions(entity.InDocument) { Directives = new AttributeResolutionDirectiveSet(new HashSet <string> { "referenceOnly" }) }; // Resolve the entity with 'referenceOnly' CdmEntityDefinition resolvedEntityWithReferenceOnly = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", resOpt, localRoot); // 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 Assert.AreEqual(4, resolvedEntityWithReferenceOnly.Attributes.Count); Assert.AreEqual("id", (resolvedEntityWithReferenceOnly.Attributes[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("name", (resolvedEntityWithReferenceOnly.Attributes[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("value", (resolvedEntityWithReferenceOnly.Attributes[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("date", (resolvedEntityWithReferenceOnly.Attributes[3] as CdmTypeAttributeDefinition).Name); // Now resolve the entity with the 'structured' directive resOpt.Directives = new AttributeResolutionDirectiveSet(new HashSet <string> { "structured" }); CdmEntityDefinition resolvedEntityWithStructured = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", resOpt, localRoot); // 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 CdmAttributeGroupDefinition attGroupDefinition = this.ValidateAttributeGroup(resolvedEntityWithStructured.Attributes, "PersonAttributeGroup"); Assert.AreEqual(4, attGroupDefinition.Members.Count); Assert.AreEqual("id", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("name", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("value", (attGroupDefinition.Members[2] as CdmTypeAttributeDefinition).Name); Assert.AreEqual("date", (attGroupDefinition.Members[3] as CdmTypeAttributeDefinition).Name); }