public async Task TestSourceWithEAProj()
{
string testName = "TestSourceWithEAProj";
string entityName = "SalesSourceWithEA";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath);
foreach (List <string> resOpt in resOptsCombinations)
{
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt);
}
}
public async Task TestExtendsProj()
{
string testName = "TestExtendsProj";
string entityName = "Customer";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
foreach (List <string> resOpt in resOptsCombinations)
{
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt);
}
}
/// <summary>
/// Common test code for these test cases
/// </summary>
/// <param name="testName"></param>
/// <param name="entityName"></param>
private void TestRun(string testName, string entityName)
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
string inputFolder = TestHelper.GetInputFolderPath(testsSubpath, testName);
string expectedOutputFolder = TestHelper.GetExpectedOutputFolderPath(testsSubpath, testName);
string actualOutputFolder = TestHelper.GetActualOutputFolderPath(testsSubpath, testName);
if (!Directory.Exists(actualOutputFolder))
{
Directory.CreateDirectory(actualOutputFolder);
}
CdmManifestDefinition manifest = corpus.FetchObjectAsync <CdmManifestDefinition>($"local:/default.manifest.cdm.json").GetAwaiter().GetResult();
Assert.IsNotNull(manifest);
CdmEntityDefinition entity = corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}", manifest).GetAwaiter().GetResult();
Assert.IsNotNull(entity);
CdmEntityDefinition resolvedEntity = ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"referenceOnly"
}).GetAwaiter().GetResult();
AttributeContextUtil.ValidateAttributeContext(corpus, expectedOutputFolder, entityName, resolvedEntity);
corpus.CalculateEntityGraphAsync(manifest).GetAwaiter().GetResult();
manifest.PopulateManifestRelationshipsAsync().GetAwaiter().GetResult();
string actualRelationshipsString = ListRelationships(corpus, entity, actualOutputFolder, entityName);
string expectedRelationshipsStringFilePath = Path.GetFullPath(Path.Combine(expectedOutputFolder, $"REL_{entityName}.txt"));
string expectedRelationshipsString = File.ReadAllText(expectedRelationshipsStringFilePath);
Assert.AreEqual(expectedRelationshipsString, actualRelationshipsString);
CdmFolderDefinition outputFolder = corpus.Storage.FetchRootFolder("output");
outputFolder.Documents.Add(manifest);
string manifestFileName = $"saved.manifest.cdm.json";
manifest.SaveAsAsync(manifestFileName, saveReferenced: true).GetAwaiter().GetResult();
string actualManifestPath = Path.Combine(actualOutputFolder, manifestFileName);
if (!File.Exists(actualManifestPath))
{
Assert.Fail("Unable to save manifest with relationship");
}
else
{
CdmManifestDefinition savedManifest = corpus.FetchObjectAsync <CdmManifestDefinition>($"output:/{manifestFileName}").GetAwaiter().GetResult();
string actualSavedManifestRel = GetRelationshipStrings(savedManifest.Relationships);
string expectedSavedManifestRel = File.ReadAllText(Path.Combine(expectedOutputFolder, $"MANIFEST_REL_{entityName}.txt"));
Assert.AreEqual(expectedSavedManifestRel, actualSavedManifestRel);
}
}
public async Task TestPolymorphicFKProj()
{
string testName = "TestPolymorphicFKProj";
string entityName = "PersonPolymorphicSourceFK";
CdmCorpusDefinition corpus = ProjectionTestUtils.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.AreEqual("indicates.expansionInfo.count", nonStructuredResolvedEntity.Attributes[4].AppliedTraits[1].NamedReference);
Assert.AreEqual("FavoriteTerms", (nonStructuredResolvedEntity.Attributes[4].AppliedTraits[1] 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 TestAppliedTraitsInAttributes()
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestAppliedTraitsInAttributes");
string expectedOutputFolder = TestHelper.GetExpectedOutputFolderPath(testsSubpath, "TestAppliedTraitsInAttributes");
CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/Sales.cdm.json/Sales");
CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"referenceOnly"
});
await AttributeContextUtil.ValidateAttributeContext(expectedOutputFolder, "Sales", resolvedEntity);
}
public void TestBuildTree()
{
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, "TestBuildTree");
ProjectionContext pc = BuildFakeTree(corpus);
Assert.AreEqual("1 ==>> [ 12 14 17 .. 1 .. 1]", SearchTreeTraversal(pc, "1"));
Assert.AreEqual("8 ==>> [ 12 17 .. 8 .. 1]", SearchTreeTraversal(pc, "8"));
Assert.AreEqual("13 ==>> [ 13 .. 13 .. 4 5 6]", SearchTreeTraversal(pc, "13"));
Assert.AreEqual("9 ==>> [ 13 .. 9 .. 4 5]", SearchTreeTraversal(pc, "9"));
Assert.AreEqual("5 ==>> [ 13 .. 5 .. 5]", SearchTreeTraversal(pc, "5"));
Assert.AreEqual("7 ==>> [ 11 15 .. 7 .. 1]", SearchTreeTraversal(pc, "7"));
}
public async Task TestCircularEntityAttributes()
{
string testName = "TestCircularEntityAttributes";
string entityName = "A";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"{entityName}.cdm.json/{entityName}");
CdmEntityDefinition resEntity = await entity.CreateResolvedEntityAsync($"resolved-{entityName}");
Assert.IsNotNull(resEntity);
Assert.AreEqual(2, resEntity.Attributes.Count);
}
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"));
}
private async Task LoadEntityForResolutionOptionAndSave(string testName, string entityName, List <string> resOpts)
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
CdmManifestDefinition manifest = await corpus.FetchObjectAsync <CdmManifestDefinition>($"local:/default.manifest.cdm.json");
string expectedOutputPath = TestHelper.GetExpectedOutputFolderPath(testsSubpath, testName);
string fileNameSuffix = ProjectionTestUtils.GetResolutionOptionNameSuffix(resOpts);
CdmEntityDefinition entSalesForeignKeyProjection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}", manifest);
Assert.IsNotNull(entSalesForeignKeyProjection);
CdmEntityDefinition resolvedSalesForeignKeyProjection = await SaveResolved(corpus, manifest, testName, entSalesForeignKeyProjection, resOpts);
Assert.IsNotNull(resolvedSalesForeignKeyProjection);
await AttributeContextUtil.ValidateAttributeContext(corpus, expectedOutputPath, $"{entityName}{fileNameSuffix}", resolvedSalesForeignKeyProjection);
}
public async Task TestRenProj()
{
string testName = "TestRenProj";
string entityName = "Customer";
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
foreach (List <string> resOpt in resOptsCombinations)
{
if (resOpt.Contains("structured"))
{
// Rename attributes is not supported on an attribute group yet.
continue;
}
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt);
}
}
public async Task TestProjectionExtendsTrait()
{
string testName = "TestProjectionExtendsTrait";
string entityName = testName;
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, new List <string> {
});
// Attribute Name
Assert.AreEqual("TestProjectionAttribute", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]).Name);
// Trait Name
Assert.AreEqual("does.haveDefault", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]).AppliedTraits[3].NamedReference);
// Trait Name
Assert.AreEqual("testTrait", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]).AppliedTraits[4].NamedReference);
// Trait Param Name
Assert.AreEqual("testTraitParam1", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]).AppliedTraits[4]).Arguments[0].ResolvedParameter.Name);
// Trait Param Default Value
Assert.AreEqual("TestTrait Param 1 DefaultValue", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]).AppliedTraits[4]).Arguments[0].Value);
// Attribute Name
Assert.AreEqual("TestProjectionAttributeB", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).Name);
// Trait Name
Assert.AreEqual("does.haveDefault", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[3].NamedReference);
// Trait Name
Assert.AreEqual("testTrait", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[4].NamedReference);
// Trait Param Name
Assert.AreEqual("testTraitParam1", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[4]).Arguments[0].ResolvedParameter.Name);
// Trait Param Default Value
Assert.AreEqual("TestTrait Param 1 DefaultValue", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[4]).Arguments[0].Value);
// Trait Name
Assert.AreEqual("testExtendsTraitB", ((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[5].NamedReference);
// Trait Param Name
Assert.AreEqual("testTraitParam1", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[5]).Arguments[0].ResolvedParameter.Name);
// Trait Param Default Value
Assert.AreEqual("TestTrait Param 1 DefaultValue", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[5]).Arguments[0].Value);
// Trait Param Name
Assert.AreEqual("testExtendsTraitBParam1", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[5]).Arguments[1].ResolvedParameter.Name);
// Trait Param Default Value
Assert.AreEqual("TestExtendsTraitB Param 1 DefaultValue", ((CdmTraitReference)((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1]).AppliedTraits[5]).Arguments[1].Value);
}
public async Task TestEntityAttributeProjUsingObjectModel()
{
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, "TestEntityAttributeProjUsingObjectModel");
corpus.Storage.Mount("local", new LocalAdapter(TestHelper.GetActualOutputFolderPath(testsSubpath, "TestEntityAttributeProjUsingObjectModel")));
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 AddTypeAttribute operation
CdmOperationAddTypeAttribute addTypeAttrOp = corpus.MakeObject <CdmOperationAddTypeAttribute>(CdmObjectType.OperationAddTypeAttributeDef);
addTypeAttrOp.TypeAttribute = corpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, "testType");
addTypeAttrOp.TypeAttribute.DataType = corpus.MakeRef <CdmDataTypeReference>(CdmObjectType.DataTypeRef, "entityName", true);
projection.Operations.Add(addTypeAttrOp);
// 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 AddTypeAttribute operation
// Original set of attributes: ["id", "name", "value", "date"]
// Type attribute: "testType"
Assert.AreEqual(5, resolvedEntity.Attributes.Count);
Assert.AreEqual("id", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("value", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("date", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("testType", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("is.linkedEntity.name", resolvedEntity.Attributes[4].AppliedTraits[4].NamedReference);
}
public async Task TestRunSequentiallyAndSourceInput()
{
string testName = "TestRunSequentiallyAndSourceInput";
string entityName = "NewPerson";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
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"]
// Replace "age" with "ageFK" and "address" with "addressFK" as foreign keys, followed by a add count attribute.
Assert.AreEqual(3, resolvedEntity.Attributes.Count);
Assert.AreEqual("ageFK", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("addressFK", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("countAttribute", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
}
public async Task TestMaxDepthOnPolymorphicEntity()
{
string testName = "TestMaxDepthOnPolymorphicEntity";
string entityName = "A";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"{entityName}.cdm.json/{entityName}");
ResolveOptions resOpt = new ResolveOptions(entity)
{
MaxDepth = 1
};
CdmEntityDefinition resEntity = await entity.CreateResolvedEntityAsync($"resolved-{entityName}", resOpt);
Assert.IsNotNull(resEntity);
Assert.AreEqual(4, resEntity.Attributes.Count);
}
public async Task TestEntityAttributeProjUsingObjectModel()
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestEntityAttributeProjUsingObjectModel");
corpus.Storage.Mount("local", new LocalAdapter(TestHelper.GetActualOutputFolderPath(testsSubpath, "TestEntityAttributeProjUsingObjectModel")));
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 ExcludeAttributes operation
CdmOperationExcludeAttributes excludeAttrsOp = corpus.MakeObject <CdmOperationExcludeAttributes>(CdmObjectType.OperationExcludeAttributesDef);
excludeAttrsOp.ExcludeAttributes = new List <string>()
{
"id", "date"
};
projection.Operations.Add(excludeAttrsOp);
// 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 ExcludeAttributes operation
// Original set of attributes: ["id", "name", "value", "date"]
// Excluded attributes: ["id", "date"]
Assert.AreEqual(2, resolvedEntity.Attributes.Count);
Assert.AreEqual("name", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("value", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
}
public async Task TestEntityProjection()
{
string testName = "TestEntityProjection";
string entityName = testName;
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
CdmManifestDefinition manifest = await corpus.FetchObjectAsync <CdmManifestDefinition>($"local:/default.manifest.cdm.json");
string expectedOutputPath = TestHelper.GetExpectedOutputFolderPath(testsSubpath, testName);
CdmEntityDefinition entTestEntityProjection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}", manifest);
Assert.IsNotNull(entTestEntityProjection);
CdmEntityDefinition resolvedTestEntityProjection = await ProjectionTestUtils.GetResolvedEntity(corpus, entTestEntityProjection, new List <string> {
});
Assert.IsNotNull(resolvedTestEntityProjection);
AttributeContextUtil.ValidateAttributeContext(corpus, expectedOutputPath, entityName, resolvedTestEntityProjection);
}
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);
}
/// <summary>
/// Loads an entity, resolves it, and then validates the generated attribute contexts
/// </summary>
private async Task LoadEntityForResolutionOptionAndSave(string testName, string entityName, List <string> resOpts)
{
string expectedOutputPath = TestHelper.GetExpectedOutputFolderPath(testsSubpath, testName);
string fileNameSuffix = ProjectionTestUtils.GetResolutionOptionNameSuffix(resOpts);
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
corpus.Storage.Mount("expected", new LocalAdapter(expectedOutputPath));
CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}");
Assert.IsNotNull(entity);
CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, resOpts, true);
Assert.IsNotNull(resolvedEntity);
await ValidateResolvedAttributes(corpus, resolvedEntity, entityName, fileNameSuffix);
await AttributeContextUtil.ValidateAttributeContext(corpus, expectedOutputPath, $"{entityName}{fileNameSuffix}", resolvedEntity);
}
public async Task TestNonPolymorphicProj()
{
string testName = "TestNonPolymorphicProj";
string entityName = "NewPerson";
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
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"]
// Combined attributes ["phoneNumber", "email"] into "contactAt"
Assert.AreEqual(4, 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("contactAt", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
}
public async Task TestAddTypeAttrOnTypeAttrProj()
{
string testName = nameof(TestAddTypeAttrOnTypeAttrProj);
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> {
});
Assert.AreEqual(2, resolvedEntity.Attributes.Count);
Assert.AreEqual("newTerm", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("FavoriteTerm", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
}
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 TestConditionalProj()
{
string testName = nameof(TestConditionalProj);
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> {
"referenceOnly"
});
// Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
// Condition not met, no traits are added
Assert.AreEqual(5, resolvedEntity.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0], "name", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[1], "age", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[2], "address", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[3], "phoneNumber", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[4], "email", doesNotExist: true);
CdmEntityDefinition resolvedEntity2 = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"structured"
});
// Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
// Condition met, new traits are added
Assert.AreEqual(5, resolvedEntity2.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity2.Attributes[0], "name", true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity2.Attributes[1], "age");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity2.Attributes[2], "address");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity2.Attributes[3], "phoneNumber");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity2.Attributes[4], "email");
}
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, don't include supporting attribute
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> {
"referenceOnly", "virtual"
});
// Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
// Condition met, include the supporting attribute
Assert.AreEqual(6, resolvedEntity2.Attributes.Count);
Assert.AreEqual("name", (resolvedEntity2.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("age", (resolvedEntity2.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address", (resolvedEntity2.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("phoneNumber", (resolvedEntity2.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email", (resolvedEntity2.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("PersonInfo_display", (resolvedEntity2.Attributes[5] as CdmTypeAttributeDefinition).Name);
ValidateInSupportOfAttribute(resolvedEntity2.Attributes[5], "email");
}
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: ["Favorite Terms"]
// in non-structured form
// Expand 1...2;
// renameFormat = Term {o};
// alterTraits = { has.expansionInfo.list(expansionName: "{a}", ordinal: "{o}") , "argumentsContainWildcards" : true }
// addArtifactAttribute : "number of favorite terms"
// alterTraits = { indicates.expansionInfo.count(expansionName: "{a}") , apply to "number of favorite terms" , "argumentsContainWildcards" : true }
Assert.AreEqual(3, nonStructuredResolvedEntity.Attributes.Count);
Assert.AreEqual("Term 1", (nonStructuredResolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("Term 2", (nonStructuredResolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("number of favorite terms", (nonStructuredResolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("indicates.expansionInfo.count", nonStructuredResolvedEntity.Attributes[2].AppliedTraits[1].NamedReference);
Assert.AreEqual("Favorite Terms", (nonStructuredResolvedEntity.Attributes[2].AppliedTraits[1] as CdmTraitReference).Arguments[0].Value);
// Original set of attributes: ["Favorite Terms"]
// in structured form
// alterTraits = { is.dataFormat.list }
CdmEntityDefinition structuredResolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"structured"
});
Assert.AreEqual(1, structuredResolvedEntity.Attributes.Count);
Assert.AreEqual("Favorite Terms", (structuredResolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.IsNotNull(structuredResolvedEntity.Attributes[0].AppliedTraits.Item("is.dataFormat.list"));
}
public async Task TestAllOperations()
{
string testName = "TestAllOperations";
string entityName = testName;
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
corpus.SetEventCallback(new EventCallback
{
Invoke = (CdmStatusLevel statusLevel, string message) =>
{
if (!message.Contains("Projection operation not implemented yet."))
{
Assert.Fail($"'Some unexpected failure - {message}!");
}
}
}, CdmStatusLevel.Error);
await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, new List <string> {
"referenceOnly"
});
}
public async Task TestRunSequentially()
{
string testName = "TestRunSequentially";
string entityName = "NewPerson";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, testName);
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"]
// Rename attributes "age" to "yearsOld" then "phoneNumber" to "contactNumber" followed by a add count attribute.
Assert.AreEqual(6, resolvedEntity.Attributes.Count);
Assert.AreEqual("name", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("yearsOld", (resolvedEntity.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("address", (resolvedEntity.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("contactNumber", (resolvedEntity.Attributes[3] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("email", (resolvedEntity.Attributes[4] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("countAttribute", (resolvedEntity.Attributes[5] as CdmTypeAttributeDefinition).Name);
}
/// <summary>
/// Utility class constructor
/// </summary>
/// <param name="testName"></param>
public ProjectionOMTestUtil(string className, string testName)
{
ClassName = className;
TestName = testName;
testsSubpath = Path.Combine("Cdm", "Projection", ClassName);
InputPath = TestHelper.GetInputFolderPath(testsSubpath, TestName);
ExpectedOutputPath = TestHelper.GetExpectedOutputFolderPath(testsSubpath, TestName);
ActualOutputPath = TestHelper.GetActualOutputFolderPath(testsSubpath, TestName);
Corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, TestName);
Corpus.Storage.Mount(LocalOutputStorageNS, new LocalAdapter(ActualOutputPath));
Corpus.Storage.DefaultNamespace = LocalOutputStorageNS;
LocalStorageRoot = Corpus.Storage.FetchRootFolder(LocalOutputStorageNS);
DefaultManifest = CreateDefaultManifest();
AllImports = CreateAndInitializeAllImportsFile();
}
public async Task TestAlterTraitsOnTypeAttrProj()
{
string testName = nameof(TestAlterTraitsOnTypeAttrProj);
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(1, resolvedEntity.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntity.Attributes[0], "FavoriteTerm", true);
}
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"]
// Excluded attributes: ["address", "phoneNumber", "email"], ["age"]
Assert.AreEqual(1, resolvedEntity.Attributes.Count);
Assert.AreEqual("name", (resolvedEntity.Attributes[0] as CdmTypeAttributeDefinition).Name);
}
