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); }