public async Task TestResolveWithExtended()
{
CdmCorpusDefinition cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestResolveWithExtended");
cdmCorpus.SetEventCallback(new EventCallback {
Invoke = (CdmStatusLevel statusLevel, string message) =>
{
if (message.Contains("unable to resolve the reference"))
{
Assert.Fail();
}
}
}, CdmStatusLevel.Warning);
CdmEntityDefinition ent = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("local:/sub/Account.cdm.json/Account");
await ent.CreateResolvedEntityAsync("Account_");
}
public async Task TestRunSequentiallyAndSourceInput()
{
string testName = "TestRunSequentiallyAndSourceInput";
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"]
// 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 = TestHelper.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);
}
/// <summary>
/// If a source is tagged as polymorphic source, get the list of original source
/// </summary>
/// <param name="projDir"></param>
/// <param name="ctx"></param>
/// <param name="source"></param>
/// <param name="attrCtxParam"></param>
/// <returns></returns>
internal static Dictionary <string, List <ProjectionAttributeState> > GetPolymorphicSourceSet(
ProjectionDirective projDir,
CdmCorpusContext ctx,
CdmEntityReference source,
AttributeContextParameters attrCtxParam)
{
Dictionary <string, List <ProjectionAttributeState> > polySources = new Dictionary <string, List <ProjectionAttributeState> >();
// TODO (sukanyas): when projection based polymorphic source is made available - the following line will have to be changed
// for now assuming non-projections based polymorphic source
CdmEntityDefinition sourceDef = source.FetchObjectDefinition <CdmEntityDefinition>(projDir.ResOpt);
foreach (CdmAttributeItem attr in sourceDef.Attributes)
{
if (attr.ObjectType == CdmObjectType.EntityAttributeDef)
{
ResolvedAttributeSet raSet = ((CdmEntityAttributeDefinition)attr).FetchResolvedAttributes(projDir.ResOpt, null);
foreach (ResolvedAttribute resAttr in raSet.Set)
{
ProjectionAttributeState projAttrState = new ProjectionAttributeState(ctx)
{
CurrentResolvedAttribute = resAttr,
PreviousStateList = null
};
// the key already exists, just add to the existing list
if (polySources.ContainsKey(resAttr.ResolvedName))
{
List <ProjectionAttributeState> exisitingSet = polySources[resAttr.ResolvedName];
exisitingSet.Add(projAttrState);
polySources[resAttr.ResolvedName] = exisitingSet;
}
else
{
List <ProjectionAttributeState> pasList = new List <ProjectionAttributeState>();
pasList.Add(projAttrState);
polySources.Add(resAttr.ResolvedName, pasList);
}
}
}
}
return(polySources);
}
/// <summary>
/// Get the traits for all the attributes of a resolved entity
/// </summary>
/// <param name="resolvedEntity"></param>
private void GetTraits(CdmEntityDefinition resolvedEntity)
{
foreach (CdmAttributeItem attrib in resolvedEntity.Attributes)
{
string attribCorpusPath = attrib.AtCorpusPath;
bldr.AppendLine(attribCorpusPath);
foreach (CdmTraitReference trait in attrib.AppliedTraits)
{
string attribTraits = trait.NamedReference;
bldr.AppendLine(attribTraits);
foreach (CdmArgumentDefinition args in trait.Arguments)
{
GetArgumentValuesAsString(args);
}
}
}
}
public ResolvedEntityReferenceSet FindEntity(CdmEntityDefinition entOther)
{
// make an array of just the refs that include the requested
List <ResolvedEntityReference> filter = new List <ResolvedEntityReference>();
foreach (ResolvedEntityReference rer in this.Set)
{
if (rer.Referenced.Where(rers => rers.Entity == entOther).Any())
{
filter.Add(rer);
}
}
if (filter.Count == 0)
{
return(null);
}
return(new ResolvedEntityReferenceSet(this.ResOpt, filter));
}
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 TestUtils.GetResolvedEntity(corpus, entTestEntityProjection, new List <string> {
});
Assert.IsNotNull(resolvedTestEntityProjection);
AttributeContextUtil.ValidateAttributeContext(corpus, expectedOutputPath, entityName, resolvedTestEntityProjection);
}
public void TestManifestCanAddEntityDeclaration()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var entity = new CdmEntityDefinition(manifest.Ctx, "entityName", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(manifest.Ctx.Corpus, entity);
var entityDeclaration = manifest.Ctx.Corpus.MakeObject <CdmEntityDeclarationDefinition>(Enums.CdmObjectType.LocalEntityDeclarationDef, entity.EntityName, false);
entityDeclaration.EntityPath = $"{entity.Owner.AtCorpusPath}/{entity.EntityName}";
manifest.Entities.Add(entityDeclaration);
Assert.AreEqual("local:/entityName.cdm.json/entityName", entityDeclaration.EntityPath);
Assert.AreEqual("entityName", entityDeclaration.EntityName);
Assert.AreEqual(1, manifest.Entities.Count);
Assert.AreEqual(entityDeclaration, manifest.Entities[0]);
}
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 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 async Task TestEntityProjUsingObjectModel()
{
CdmCorpusDefinition corpus = ProjectionTestUtils.GetLocalCorpus(testsSubpath, "TestEntityProjUsingObjectModel");
corpus.Storage.Mount("local", new LocalAdapter(TestHelper.GetActualOutputFolderPath(testsSubpath, "TestEntityProjUsingObjectModel")));
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;
// Set the entity's ExtendEntity to be the projection
entity.ExtendsEntity = projectionEntityRef;
// 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 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);
}
/// <summary>
/// List the incoming and outgoing relationships
/// </summary>
/// <param name="corpus"></param>
/// <param name="entity"></param>
/// <param name="actualOutputFolder"></param>
/// <param name="entityName"></param>
/// <returns></returns>
private static string ListRelationships(CdmCorpusDefinition corpus, CdmEntityDefinition entity, string actualOutputFolder, string entityName)
{
StringBuilder bldr = new StringBuilder();
bldr.AppendLine($"Incoming Relationships For: {entity.EntityName}:");
// Loop through all the relationships where other entities point to this entity.
foreach (CdmE2ERelationship relationship in corpus.FetchIncomingRelationships(entity))
{
bldr.AppendLine(PrintRelationship(relationship));
}
Console.WriteLine($"Outgoing Relationships For: {entity.EntityName}:");
// Now loop through all the relationships where this entity points to other entities.
foreach (CdmE2ERelationship relationship in corpus.FetchOutgoingRelationships(entity))
{
bldr.AppendLine(PrintRelationship(relationship));
}
return(bldr.ToString());
}
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);
}
/// <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 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);
}
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 static async Task <LocalEntity> ToData(CdmEntityDefinition instance, ResolveOptions resOpt, CopyOptions options, CdmCorpusContext ctx)
{
var result = new LocalEntity
{
Name = instance.EntityName,
Description = instance.GetProperty("description"),
Type = "LocalEntity"
};
Utils.ProcessTraitsAndAnnotationsToData(instance.Ctx, result, instance.ExhibitsTraits);
if (instance.Attributes != null)
{
result.Attributes = new List <Attribute>();
foreach (CdmAttributeItem element in instance.Attributes)
{
if (element.ObjectType != CdmObjectType.TypeAttributeDef)
{
Logger.Error(nameof(EntityPersistence), (ResolveContext)ctx, "Saving a manifest, with an entity containing an entity attribute, to model.json format is currently not supported.");
return(null);
}
// TODO: handle when attribute is something else other than CdmTypeAttributeDefinition.
var attribute = await TypeAttributePersistence.ToData(element as CdmTypeAttributeDefinition, resOpt, options);
if (attribute != null)
{
result.Attributes.Add(attribute);
}
else
{
Logger.Error(nameof(EntityPersistence), (ResolveContext)ctx, "There was an error while trying to convert model.json attribute to cdm attribute.");
return(null);
}
}
}
return(result);
}
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 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 = "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 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 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);
}
/// <summary>
/// Check if the entity shape is correct in entity reference.
/// </summary>
/// <param name="resolvedEntity"></param>
/// <param name="isEntitySet">Indicate if the entity shape is entitySet or entityGroupSet.</param>
internal void AssertEntityShapeInResolvedEntity(CdmEntityDefinition resolvedEntity, bool isEntitySet)
{
foreach (var att in resolvedEntity.Attributes)
{
var entRef = att?.AppliedTraits?.Where(x => x.NamedReference == "is.linkedEntity.identifier" && x.Arguments?.Count > 0).FirstOrDefault()?.Arguments[0].Value;
if (entRef != null)
{
var entityShape = (entRef.FetchObjectDefinition <CdmConstantEntityDefinition>() as CdmConstantEntityDefinition).EntityShape.NamedReference;
if (isEntitySet)
{
Assert.AreEqual("entitySet", entityShape);
}
else
{
Assert.AreEqual("entityGroupSet", entityShape);
}
return;
}
}
Assert.Fail("Unable to find entity shape from resolved model.");
}
static void ListAttributes(CdmEntityDefinition entity)
{
Console.WriteLine($"\nList of all attributes for the entity {entity.EntityName}:");
// This way of getting the attributes only works well for 'resolved' entities that have been flattened out.
// An abstract entity can be resolved by calling createResolvedEntity on it.
foreach (CdmTypeAttributeDefinition attribute in entity.Attributes)
{
// Attribute's name.
PrintProperty("Name", attribute.Name);
// Attribute's data format.
PrintProperty("DataFormat", attribute.DataFormat.ToString());
// And all the traits of this attribute.
Console.WriteLine("AppliedTraits:");
foreach (var trait in attribute.AppliedTraits)
{
PrintTrait(trait);
}
Console.WriteLine();
}
}
/// <summary>
/// Create an entity 'TestOperationCollection' that extends from a projection with a collection of operations
/// </summary>
/// <param name="corpus"></param>
/// <param name="manifestDefault"></param>
/// <param name="localRoot"></param>
/// <returns></returns>
private CdmEntityDefinition CreateEntityTestOperationCollection(CdmCorpusDefinition corpus, CdmManifestDefinition manifestDefault, CdmFolderDefinition localRoot)
{
string entityName = "TestOperationCollection";
CdmEntityReference inlineProjectionEntityRef = corpus.MakeObject <CdmEntityReference>(CdmObjectType.EntityRef, null);
CdmEntityDefinition entityTestOperationCollection = corpus.MakeObject <CdmEntityDefinition>(CdmObjectType.EntityDef, entityName);
inlineProjectionEntityRef.ExplicitReference = CreateProjectionWithOperationCollection(corpus, entityTestOperationCollection);
entityTestOperationCollection.ExtendsEntity = inlineProjectionEntityRef;
CdmDocumentDefinition entityTestOperationCollectionDoc = corpus.MakeObject <CdmDocumentDefinition>(CdmObjectType.DocumentDef, $"{entityName}.cdm.json", false);
entityTestOperationCollectionDoc.Imports.Add(FoundationJsonPath);
entityTestOperationCollectionDoc.Imports.Add("TestSource.cdm.json");
entityTestOperationCollectionDoc.Definitions.Add(entityTestOperationCollection);
localRoot.Documents.Add(entityTestOperationCollectionDoc, entityTestOperationCollectionDoc.Name);
manifestDefault.Entities.Add(entityTestOperationCollection);
return(entityTestOperationCollection);
}
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 TestEntRefNonexistent()
{
var expectedCodes = new HashSet <CdmLogCode> {
CdmLogCode.WarnResolveObjectFailed, CdmLogCode.ErrResolveReferenceFailure
};
var corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestEntRefNonexistent", expectedCodes: expectedCodes);
var folder = corpus.Storage.NamespaceFolders["local"];
var doc = new CdmDocumentDefinition(corpus.Ctx, "someDoc.cdm.json");
folder.Documents.Add(doc);
var entity = new CdmEntityDefinition(corpus.Ctx, "someEntity");
var entAtt = new CdmEntityAttributeDefinition(corpus.Ctx, "entityAtt");
entAtt.Entity = new CdmEntityReference(corpus.Ctx, "nonExistingEntity", true);
entity.Attributes.Add(entAtt);
doc.Definitions.Add(entity);
var resolvedEnt = await entity.CreateResolvedEntityAsync("resolvedSomeEntity");
Assert.IsNotNull(resolvedEnt);
}
public async Task TestProjectionTrait()
{
string testName = "TestProjectionTrait";
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);
}
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);
}
