public async Task TestTypeAttributeProj()
{
string testName = "TestTypeAttributeProj";
string entityName = "Person";
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"]
// Replace as foreign key applied to "address", replace with "addressId"
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("addressId", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
}
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 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 TestArraySourceRename()
{
string testName = "TestArraySourceRename";
string entityName = "FriendGroup";
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: ["personCount", "name1", "age1", "address1", "phoneNumber1", "email1", ..., "email3"] (16 total)
// Excluded attributes: ["age1", "age2", "age3"]
Assert.AreEqual(13, resolvedEntity.Attributes.Count);
Assert.AreEqual("personCount", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name1", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address1", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber1", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email1", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name2", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address2", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber2", (resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email2", (resolvedEntity.Attributes[8] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name3", (resolvedEntity.Attributes[9] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address3", (resolvedEntity.Attributes[10] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber3", (resolvedEntity.Attributes[11] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email3", (resolvedEntity.Attributes[12] as CdmTypeAttributeDefinition).Name);
}
public async Task TestPolymorphicProj()
{
string testName = "TestPolymorphicProj";
string entityName = "BusinessPerson";
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: ["emailId", "address", "isPrimary", "phoneId", "number", "socialId", "account"]
// Excluded attributes: ["socialId", "account"]
Assert.AreEqual(5, resolvedEntity.Attributes.Count);
Assert.AreEqual("emailId", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("isPrimary", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneId", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("number", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
}
public async Task TestGroup()
{
string testName = "TestGroup";
string entityName = "NewPerson";
CdmCorpusDefinition corpus = ProjectionTestUtils.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"]
// Count attribute: "someCount"
// For resolution guidance, CountAttribute has to be used with Expansion so we do an Expansion of 1...1 here
Assert.AreEqual(6, resolvedEntity.Attributes.Count);
Assert.AreEqual("someCount", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("is.linkedEntity.array.count", resolvedEntity.Attributes[0].AppliedTraits[1].NamedReference);
Assert.AreEqual("name1", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age1", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address1", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber1", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email1", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
}
public async Task TestAlterArguments()
{
string testName = nameof(TestAlterArguments);
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> {
});
// Create resolution options with the 'referenceOnly' directive.
CdmEntityDefinition resolvedEntityWithReferenceOnly = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"referenceOnly"
});
// Original set of attributes: ["name", "age", "address[means.TraitG4(scale:15)]" , "phoneNumber", "email"]
// Condition not met, no trait is changed
Assert.AreEqual("address", ((CdmTypeAttributeDefinition)resolvedEntityWithReferenceOnly.Attributes[2]).Name);
CdmTraitReference traitG4 = (CdmTraitReference)resolvedEntityWithReferenceOnly.Attributes[2].AppliedTraits.Item("means.TraitG4");
Assert.IsNotNull(traitG4);
Assert.IsNull(traitG4.Arguments.FetchValue("precision"));
Assert.AreEqual("15", traitG4.Arguments.FetchValue("scale"));
// Create resolution options with the 'structured' directive.
CdmEntityDefinition resolvedEntityWithStructured = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"structured"
});
// Original set of attributes: ["name", "age", "address[means.TraitG4(scale:15)]" , "phoneNumber", "email"]
// Condition met, alter traits on ["address", + { "means.TraitG4, "arguments": ["6", {"name": "scale","value": "20"}"] }]
Assert.AreEqual("address", ((CdmTypeAttributeDefinition)resolvedEntityWithStructured.Attributes[2]).Name);
CdmTraitReference traitG4_1 = (CdmTraitReference)resolvedEntityWithStructured.Attributes[2].AppliedTraits.Item("means.TraitG4");
Assert.IsNotNull(traitG4_1);
Assert.AreEqual("6", traitG4_1.Arguments.FetchValue("precision"));
Assert.AreEqual("20", traitG4_1.Arguments.FetchValue("scale"));
// Create resolution options with the 'normalized' directive.
CdmEntityDefinition resolvedEntityWithNormalized = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"normalized"
});
// Original set of attributes: ["name", "age", "address[means.TraitG4(scale:15)]" , "phoneNumber", "email"]
// Condition met, alter traits on ["address", + { "means.TraitG4, "arguments": ["8", null] }]
Assert.AreEqual("address", ((CdmTypeAttributeDefinition)resolvedEntityWithNormalized.Attributes[2]).Name);
CdmTraitReference traitG4_2 = (CdmTraitReference)resolvedEntityWithNormalized.Attributes[2].AppliedTraits.Item("means.TraitG4");
Assert.IsNotNull(traitG4_2);
Assert.AreEqual("8", traitG4_2.Arguments.FetchValue("precision"));
Assert.AreEqual("", traitG4_2.Arguments.FetchValue("scale"));
}
public async Task TestConditionalProj()
{
string testName = "TestConditionalProj";
string entityName = "Customer";
CdmCorpusDefinition corpus = ProjectionTestUtils.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: ["emailId", "address", "isPrimary", "phoneId", "number", "socialId", "account"]
// Merge ["emailId, "phoneId, "socialId"] into "contactId", type attribute: "contactType"
// Condition for projection containing AddTypeAttribute is false, so no Type attribute is created
Assert.AreEqual(5, resolvedEntity.Attributes.Count);
Assert.AreEqual("address", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("isPrimary", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("number", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("account", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("contactId", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
}
public async Task TestCombineOpsNestedProj()
{
string testName = nameof(TestCombineOpsNestedProj);
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> {
});
// Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
// Include attributes: ["age", "phoneNumber", "name"]
// Add attribute: ["newName"]
// alter traits on ["newName", "name", + { "means.TraitG100" , "JobTitleBase" } - { "means.TraitG300" } ]
// Rename attribute ["newName" -> "renaming-{m}" ]
// alter traits on ["renaming-newName", + { "means.TraitG4(precision:5, scale:15)" } ]
Assert.AreEqual(4, resolvedEntity.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0], "age", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1], "phoneNumber", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[2], "name");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[3], "renaming-newName", true);
}
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 TestWildcardArgs()
{
string testName = nameof(TestWildcardArgs);
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 resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
});
// Original set of attributes: ["name", "age", "address"]
// Expand 1...3, renameFormat = {m}{o}
// Add traits with wildcard characters
Assert.AreEqual(9, resolvedEntity.Attributes.Count);
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition, "name1", 1, "ThreePeople", "name");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition, "age1", 1, "ThreePeople", "age");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition, "address1", 1, "ThreePeople", "address");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition, "name2", 2, "ThreePeople", "name");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition, "age2", 2, "ThreePeople", "age");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition, "address2", 2, "ThreePeople", "address");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition, "name3", 3, "ThreePeople", "name");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition, "age3", 3, "ThreePeople", "age");
ProjectionTestUtils.ValidateExpansionInfoTrait(resolvedEntity.Attributes[8] as CdmTypeAttributeDefinition, "address3", 3, "ThreePeople", "address");
}
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"]
// Supporting attribute: "PersonInfo_display", rename "address" to "homeAddress"
Assert.AreEqual(7, resolvedEntity.Attributes.Count);
Assert.AreEqual("name", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("homeAddress", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("PersonInfo_display", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
ValidateInSupportOfAttribute(resolvedEntity.Attributes[6], "email");
}
public async Task TestDuplicate()
{
string testName = "TestDuplicate";
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"]
// Count attribute: "someCount", count attribute: "someCount"
// "someCount" should get merged into one
Assert.AreEqual(6, 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);
Assert.AreEqual("someCount", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("is.linkedEntity.array.count", resolvedEntity.Attributes[5].AppliedTraits[1].NamedReference);
}
public async Task TestInsertAtTop()
{
string testName = nameof(TestInsertAtTop);
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"]
// Add attribute: ["newName" (InsertAtTop:false), "newName_1" (InsertAtTop:true)]
Assert.AreEqual(7, resolvedEntity.Attributes.Count);
Assert.AreEqual("newName_1", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("newName", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
}
public async Task TestCombineOpsNestedProj()
{
string testName = "TestCombineOpsNestedProj";
string entityName = "Customer";
CdmCorpusDefinition corpus = ProjectionTestUtils.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: ["emailId", "address", "isPrimary", "phoneId", "number", "socialId", "account"]
// Merge ["emailId, "phoneId, "socialId"] into "contactId", type attribute: "contactType",
// rename ["contactId", "isPrimary"] as "new_{m}", include ["contactId", "new_isPrimary", "contactType"]
Assert.AreEqual(3, resolvedEntity.Attributes.Count);
Assert.AreEqual("new_isPrimary", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("new_contactId", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("contactType", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("is.linkedEntity.name", resolvedEntity.Attributes[2].AppliedTraits[4].NamedReference);
}
public async Task TestArraySource()
{
string testName = "TestArraySource";
string entityName = "FriendGroup";
CdmCorpusDefinition corpus = ProjectionTestUtils.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: ["personCount", "name1", "age1", "address1", "name2", "age2", "address2"]
// Expand 1...2, renameFormat = {m}_{o}
// Since resolution guidance doesn't support doing an expansion on an array source, we end up with the
// following result where it skips expanding attributes with the same ordinal (ex. name1_1, name2_2)
Assert.AreEqual(9, resolvedEntity.Attributes.Count);
Assert.AreEqual("count_", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("personCount_1", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name2_1", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age2_1", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address2_1", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("personCount_2", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name1_2", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age1_2", (resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address1_2", (resolvedEntity.Attributes[8] as CdmTypeAttributeDefinition).Name);
}
public async Task TestExtendsEntity()
{
string testName = "TestExtendsEntity";
string entityName = "Customer";
CdmCorpusDefinition corpus = ProjectionTestUtils.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: ["emailId", "address", "isPrimary", "phoneId", "number", "socialId", "account"]
// Type attribute: "someType" (using extendsEntityResolutionGuidance)
Assert.AreEqual(8, resolvedEntity.Attributes.Count);
Assert.AreEqual("emailId", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("isPrimary", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneId", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("number", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("socialId", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("account", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("someType", (resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("is.linkedEntity.name", resolvedEntity.Attributes[7].AppliedTraits[4].NamedReference);
}
public async Task TestGroupProj()
{
string testName = "TestGroupProj";
string entityName = "ThreeMusketeers";
CdmCorpusDefinition corpus = ProjectionTestUtils.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"]
// Expand 1...3, renameFormat = {m}{o}
Assert.AreEqual(9, resolvedEntity.Attributes.Count);
Assert.AreEqual("name1", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age1", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address1", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name2", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age2", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address2", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name3", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age3", (resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address3", (resolvedEntity.Attributes[8] 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 TestPolymorphic()
{
string testName = "TestPolymorphic";
string entityName = "BusinessPerson";
CdmCorpusDefinition corpus = ProjectionTestUtils.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: ["emailId", "address", "isPrimary", "phoneId", "number"]
// Expand 1...2, renameFormat = {m}{o}
Assert.AreEqual(11, resolvedEntity.Attributes.Count);
Assert.AreEqual("count", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("emailId1", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address1", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("isPrimary1", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneId1", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("number1", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("emailId2", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address2", (resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("isPrimary2", (resolvedEntity.Attributes[8] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneId2", (resolvedEntity.Attributes[9] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("number2", (resolvedEntity.Attributes[10] as CdmTypeAttributeDefinition).Name);
}
public async Task TestTypeAttributeProj()
{
string testName = "TestTypeAttributeProj";
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: ["PersonInfo"]
Assert.AreEqual(2, resolvedEntity.Attributes.Count);
Assert.AreEqual("PersonInfo", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
CdmTypeAttributeDefinition supportingAttribute = resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition;
Assert.AreEqual("PersonInfo_display", supportingAttribute.Name);
ValidateInSupportOfAttribute(supportingAttribute, "PersonInfo");
}
public async Task TestConditionalProj()
{
string testName = "TestConditionalProj";
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"]
// Count attribute: "someCount"
// Condition is false, so no Count attribute added
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);
}
public async Task TestWithNestedArrayExpansion()
{
string testName = "TestWithNestedArrayExpansion";
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"]
// Count attribute: "personCount", expand 1...2, renameFormat = {m}{o}
Assert.AreEqual(11, resolvedEntity.Attributes.Count);
Assert.AreEqual("name1", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age1", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address1", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber1", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email1", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name2", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age2", (resolvedEntity.Attributes[6] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address2", (resolvedEntity.Attributes[7] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber2", (resolvedEntity.Attributes[8] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email2", (resolvedEntity.Attributes[9] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("personCount", (resolvedEntity.Attributes[10] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("is.linkedEntity.array.count", resolvedEntity.Attributes[10].AppliedTraits[1].NamedReference);
Assert.AreEqual("indicates.expansionInfo.count", resolvedEntity.Attributes[10].AppliedTraits[2].NamedReference);
}
public async Task TestAlterTraitsOnEntiAttrProj()
{
string testName = nameof(TestAlterTraitsOnEntiAttrProj);
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> {
});
Assert.AreEqual(5, resolvedEntity.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0], "name", true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1], "age");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[2], "address");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[3], "phoneNumber");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[4], "email");
}
public async Task TestEntityAttributeStringReference()
{
string testName = "TestEntityAttributeStringReference";
string entityName = "TestEntAttrStrRef";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, new List <string> {
});
}
public async Task TestEntityNestedProjection()
{
string testName = "TestEntityNestedProjection";
string entityName = testName;
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, new List <string> {
});
}
public async Task TestPolymorphicProj()
{
string testName = "TestPolymorphicProj";
string entityName = "Person";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
foreach (List <string> resOpt in resOptsCombinations)
{
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt);
}
}
public async Task TestEA()
{
string testName = "TestEA";
string entityName = "Color";
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
foreach (List <string> resOpt in resOptsCombinations)
{
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt);
}
}
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"));
}
