public async Task TestLoadingInvalidModelJsonName()
{
var testName = "TestLoadingInvalidModelJsonName";
var testInputPath = TestHelper.GetInputFolderPath(testsSubpath, testName);
CdmCorpusDefinition corpus = new CdmCorpusDefinition();
corpus.SetEventCallback(new EventCallback {
Invoke = CommonDataModelLoader.ConsoleStatusReport
}, CdmStatusLevel.Warning);
corpus.Storage.Mount("local", new LocalAdapter(testInputPath));
corpus.Storage.DefaultNamespace = "local";
// We are trying to load a file with an invalid name, so FetchObjectAsync() should just return null.
var invalidModelJson = await corpus.FetchObjectAsync <CdmManifestDefinition>("test.model.json");
Assert.IsNull(invalidModelJson);
}
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 = 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 TestLoadingConfigAndTryingToFetchManifest()
{
var testInputPath = TestHelper.GetInputFolderPath(testsSubpath, "TestLoadingConfigAndTryingToFetchManifest");
// Create a corpus to load the config.
var cdmCorpus = this.GetLocalCorpus(testInputPath);
var config = await cdmCorpus.Storage.FetchAdapter("local").ReadAsync("/config.json");
var differentCorpus = new CdmCorpusDefinition();
var unrecognizedAdapters = differentCorpus.Storage.MountFromConfig(config, true);
var cdmManifest = await differentCorpus.FetchObjectAsync <CdmManifestDefinition>("model.json", cdmCorpus.Storage.FetchRootFolder("local"));
Assert.IsNotNull(cdmManifest);
Assert.AreEqual(1, unrecognizedAdapters.Count);
}
public void TestLoadingBlankName()
{
var corpus = new CdmCorpusDefinition();
var argumentData = new JObject()
{
["name"] = " ",
["value"] = 0
};
var argument = ArgumentPersistence.FromData(corpus.Ctx, argumentData);
Assert.AreEqual(0, argument.Value);
var argumentToData = ArgumentPersistence.ToData(argument, null, null);
Assert.AreEqual(0, argumentToData);
}
private CdmCorpusDefinition InitializeClientWithUserDatabase()
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestTelemetryKustoClient");
// TODO: need to investigate why only Java not failing if using event callback from GetLocalCorpus()
// set callback to receive error and warning logs.
corpus.SetEventCallback(new EventCallback
{
Invoke = (level, message) =>
{
// Do nothing
}
}, CdmStatusLevel.Progress);
string tenantId = Environment.GetEnvironmentVariable("KUSTO_TENANTID");
string clientId = Environment.GetEnvironmentVariable("KUSTO_CLIENTID");
string secret = Environment.GetEnvironmentVariable("KUSTO_SECRET");
string clusterName = Environment.GetEnvironmentVariable("KUSTO_CLUSTER");
string databaseName = Environment.GetEnvironmentVariable("KUSTO_DATABASE");
string infoTable = Environment.GetEnvironmentVariable("KUSTO_INFOTABLE");
string warningTable = Environment.GetEnvironmentVariable("KUSTO_WARNINGTABLE");
string errorTable = Environment.GetEnvironmentVariable("KUSTO_ERRORTABLE");
Assert.IsFalse(string.IsNullOrEmpty(tenantId), "KUSTO_TENANTID not set");
Assert.IsFalse(string.IsNullOrEmpty(clientId), "KUSTO_CLIENTID not set");
Assert.IsFalse(string.IsNullOrEmpty(secret), "KUSTO_SECRET not set");
Assert.IsFalse(string.IsNullOrEmpty(clusterName), "KUSTO_CLUSTER not set");
Assert.IsFalse(string.IsNullOrEmpty(databaseName), "KUSTO_DATABASE not set");
Assert.IsFalse(string.IsNullOrEmpty(infoTable), "KUSTO_INFOTABLE not set");
Assert.IsFalse(string.IsNullOrEmpty(warningTable), "KUSTO_WARNINGTABLE not set");
Assert.IsFalse(string.IsNullOrEmpty(errorTable), "KUSTO_ERRORTABLE not set");
TelemetryConfig kustoConfig = new TelemetryConfig(tenantId, clientId, secret,
clusterName, databaseName, infoTable, warningTable, errorTable, EnvironmentType.DEV, removeUserContent: false);
corpus.TelemetryClient = new TelemetryKustoClient(corpus.Ctx, kustoConfig);
corpus.AppId = "CDM Integration Test";
return(corpus);
}
private static async Task SaveCDMDocuments(string nameSpace, CdmCorpusDefinition cdmCorpus)
{
Console.WriteLine("Make placeholder manifest");
// Make the temp manifest and add it to the root of the local documents in the corpus
CdmManifestDefinition manifestAbstract = cdmCorpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef, "tempAbstract");
// Add the temp manifest to the root of the local documents in the corpus.
var localRoot = cdmCorpus.Storage.FetchRootFolder(nameSpace);
localRoot.Documents.Add(manifestAbstract);
// Create two entities from scratch, and add some attributes, traits, properties, and relationships in between
Console.WriteLine("Create net new entities");
DTDLParser parser = new DTDLParser(dtdlRoot, "json");
foreach (DTInterfaceInfo info in parser.DTDLInterfaces)
{
CreateCustomEntity(cdmCorpus, manifestAbstract, localRoot, info);
}
// Create the resolved version of everything in the root folder too
Console.WriteLine("Resolve the placeholder");
var manifestResolved = await manifestAbstract.CreateResolvedManifestAsync("default", null);
// Add an import to the foundations doc so the traits about partitons will resolve nicely
manifestResolved.Imports.Add("cdm:/foundations.cdm.json");
Console.WriteLine($"Save the folders and partition data documents to {nameSpace} storage.");
await SavePartitionDocuments(nameSpace, cdmCorpus, manifestResolved);
Console.WriteLine($"Save the manifest, entity and resolved documents to {nameSpace} storage.");
// Save all other files (resolved, manifest, entity etc.)
var manifestFileName = $"{manifestResolved.ManifestName}.manifest.cdm.json";
var manifestSaved = await manifestResolved.SaveAsAsync(manifestFileName, true);
LogSaveOutput(manifestSaved, manifestFileName);
var modelFileName = "model.json";
var modelSaved = await manifestResolved.SaveAsAsync(modelFileName, true);
LogSaveOutput(modelSaved, modelFileName);
}
public async Task ResolveEntities()
{
var cdmCorpus = new CdmCorpusDefinition();
var testInputPath = TestHelper.GetInputFolderPath(testsSubpath, "TestResolveEntities");
cdmCorpus.RootPath = testInputPath;
cdmCorpus.Storage.Mount("local", new LocalAdapter(testInputPath));
cdmCorpus.Storage.DefaultNamespace = "local";
var entities = await this.GetAllEntities(cdmCorpus);
var entityResolutionTimes = new List <Tuple <string, long> >();
foreach (var data in entities)
{
var entity = data.Item1;
var doc = data.Item2;
var directives = new AttributeResolutionDirectiveSet(new HashSet <string> {
"normalized", "referenceOnly"
});
var resOpt = new ResolveOptions {
WrtDoc = doc, Directives = directives
};
var watch = Stopwatch.StartNew();
await entity.CreateResolvedEntityAsync($"{entity.GetName()}_", resOpt); watch.Stop();
entityResolutionTimes.Add(Tuple.Create(entity.AtCorpusPath, watch.ElapsedMilliseconds));
}
entityResolutionTimes.Sort((lhs, rhs) =>
{
var diff = rhs.Item2 - lhs.Item2;
return(diff == 0 ? 0 : diff < 0 ? -1 : 1);
});
foreach (var data in entityResolutionTimes)
{
Trace.WriteLine($"{data.Item1}:{data.Item2}");
}
Assert.Performance(1000, entityResolutionTimes[0].Item2);
var total = entityResolutionTimes.Sum(data => data.Item2);
Assert.Performance(5000, total);
}
public void TestEntityAttributeSource()
{
CdmCorpusDefinition corpus = new CdmCorpusDefinition();
int errorCount = 0;
corpus.SetEventCallback(new EventCallback()
{
Invoke = (level, message) =>
{
errorCount++;
}
}, CdmStatusLevel.Error);
CdmProjection projection = new CdmProjection(corpus.Ctx);
CdmEntityAttributeDefinition _ = new CdmEntityAttributeDefinition(corpus.Ctx, "attribute")
{
Entity = new CdmEntityReference(corpus.Ctx, projection, false)
};
// First case, a projection without source.
projection.Validate();
Assert.AreEqual(1, errorCount);
errorCount = 0;
// Second case, a projection with a nested projection.
CdmProjection innerProjection = new CdmProjection(corpus.Ctx);
projection.Source = new CdmEntityReference(corpus.Ctx, innerProjection, false);
projection.Validate();
innerProjection.Validate();
Assert.AreEqual(1, errorCount);
errorCount = 0;
// Third case, a projection with an explicit entity definition.
innerProjection.Source = new CdmEntityReference(corpus.Ctx, new CdmEntityDefinition(corpus.Ctx, "Entity"), false);
projection.Validate();
innerProjection.Validate();
Assert.AreEqual(0, errorCount);
// Third case, a projection with a named reference.
innerProjection.Source = new CdmEntityReference(corpus.Ctx, "Entity", false);
projection.Validate();
innerProjection.Validate();
Assert.AreEqual(0, errorCount);
}
internal async Task <bool> IndexIfNeeded(ResolveOptions resOpt)
{
if (this.NeedsIndexing)
{
// make the corpus internal machinery pay attention to this document for this call
CdmCorpusDefinition corpus = (this.Folder as CdmFolderDefinition).Corpus;
ConcurrentDictionary <CdmDocumentDefinition, byte> docsJustAdded = new ConcurrentDictionary <CdmDocumentDefinition, byte>();
ConcurrentDictionary <string, byte> docsNotFound = new ConcurrentDictionary <string, byte>();
await corpus.ResolveImportsAsync(this, docsJustAdded, docsNotFound);
// maintain actual current doc
docsJustAdded[this] = 1;
return(corpus.IndexDocuments(resOpt, this, docsJustAdded));
}
return(true);
}
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 TestSystemAndResourceAdapters()
{
var path = TestHelper.GetExpectedOutputFolderPath(testsSubpath, "TestSystemAndResourceAdapters");
// Create a corpus to load the config.
var cdmCorpus = this.GetLocalCorpus(path);
var differentCorpus = new CdmCorpusDefinition();
differentCorpus.Storage.Unmount("cdm");
differentCorpus.Storage.DefaultNamespace = "local";
var resultConfig = differentCorpus.Storage.FetchConfig();
var outputConfig = await cdmCorpus.Storage.NamespaceAdapters["local"].ReadAsync("/config.json");
Assert.AreEqual(outputConfig, resultConfig);
}
/// <summary>
/// Resolve the entities in the given manifest.
/// </summary>
/// <param name="testName">The name of the test. It is used to decide the path of input / output files. </param>
/// <parameter name="manifestName">The name of the manifest to be used. </parameter>
/// <returns> The resolved entities. </returns>
private async Task <string> ResolveEnvironment(string testName, string manifestName)
{
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.SetEventCallback(new EventCallback {
Invoke = CommonDataModelLoader.ConsoleStatusReport
}, CdmStatusLevel.Warning);
var testLocalAdapter = this.CreateStorageAdapterConfigForTest(testName);
cdmCorpus.Storage.Mount("local", testLocalAdapter);
var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>($"local:/{manifestName}.manifest.cdm.json");
var directives = new AttributeResolutionDirectiveSet(new HashSet <string> {
"normalized", "referenceOnly"
});
return(await ListAllResolved(cdmCorpus, directives, manifest, new StringSpewCatcher()));
}
private async static Task <CdmManifestDefinition> LoadAndResolveManifest(CdmCorpusDefinition corpus, CdmManifestDefinition manifest, string renameSuffix)
{
Console.WriteLine("Resolving manifest " + manifest.ManifestName + " ...");
CdmManifestDefinition resolvedManifest = await manifest.CreateResolvedManifestAsync(manifest.ManifestName + renameSuffix, "{n}-resolved.cdm.json");
foreach (CdmManifestDeclarationDefinition subManifestDecl in manifest.SubManifests)
{
CdmManifestDefinition subManifest = await corpus.FetchObjectAsync <CdmManifestDefinition>(subManifestDecl.Definition, manifest);
CdmManifestDefinition resolvedSubManifest = await LoadAndResolveManifest(corpus, subManifest, renameSuffix);
CdmManifestDeclarationDefinition resolvedDecl = corpus.MakeObject <CdmManifestDeclarationDefinition>(CdmObjectType.ManifestDeclarationDef, resolvedSubManifest.ManifestName);
resolvedDecl.Definition = corpus.Storage.CreateRelativeCorpusPath(resolvedSubManifest.AtCorpusPath, resolvedManifest);
resolvedManifest.SubManifests.Add(resolvedDecl);
}
return(resolvedManifest);
}
/// <summary>
/// Test that a document is fetched using the syms persistence class.
/// </summary>
internal async Task TestSymsFetchDocument(CdmCorpusDefinition corpus, CdmManifestDefinition manifestExpected)
{
foreach (var ent in manifestExpected.Entities)
{
var doc = await corpus.FetchObjectAsync <CdmDocumentDefinition>($"syms:/{manifestExpected.ManifestName}/{ent.EntityName}.cdm.json");
Assert.IsNotNull(doc);
Assert.IsTrue(string.Equals($"{ent.EntityName}.cdm.json", doc.Name));
await doc.SaveAsAsync($"localActOutput:/{doc.Name}");
var docLocal = await corpus.FetchObjectAsync <CdmDocumentDefinition>(doc.Name);
await docLocal.SaveAsAsync($"localExpOutput:/{doc.Name}");
var actualContent = TestHelper.GetActualOutputFileContent(testsSubpath, nameof(TestSymsSavingAndFetchingDocument), doc.Name);
var expectedContent = TestHelper.GetExpectedOutputFileContent(testsSubpath, nameof(TestSymsSavingAndFetchingDocument), doc.Name);
TestHelper.AssertSameObjectWasSerialized(actualContent, expectedContent);
}
}
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 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);
}
static async Task Main(string[] args)
{
// ------------------------------------------------------------------------------------------------------------
// Instantiate a corpus. The corpus is the collection of all documents and folders created or discovered
// while navigating objects and paths.
var cdmCorpus = new CdmCorpusDefinition();
// ------------------------------------------------------------------------------------------------------------
// Configure storage adapters and mount them to the corpus.
// We want our storage adapters to point at the local manifest location and at the example public standards.
string pathFromExeToExampleRoot = "../../../../../../";
// Storage adapter pointing to the target local manifest location.
cdmCorpus.Storage.Mount("local", new LocalAdapter(pathFromExeToExampleRoot + "1-read-manifest/sample-data"));
// 'local' is our default namespace.
// Any paths that start navigating without a device tag (ex. 'cdm') will just default to the 'local' namepace.
cdmCorpus.Storage.DefaultNamespace = "local";
// Storage adapter pointing to the example public standards.
// This is a fake 'cdm'; normally the Github adapter would be used to point at the real public standards.
// Mount it as the 'cdm' device, not the default, so that we must use "cdm:<folder-path>" to get there.
cdmCorpus.Storage.Mount("cdm", new LocalAdapter(pathFromExeToExampleRoot + "example-public-standards"));
// Example how to mount to the ADLS:
// cdmCorpus.Storage.Mount("adls",
// new ADLSAdapter(
// "<ACCOUNT-NAME>.dfs.core.windows.net", // Hostname.
// "/<FILESYSTEM-NAME>", // Root.
// "72f988bf-86f1-41af-91ab-2d7cd011db47", // Tenant ID.
// "<CLIENT-ID>", // Client ID.
// "<CLIENT-SECRET>" // Client secret.
// )
// );
// ------------------------------------------------------------------------------------------------------------
// Open the default manifest file at the root.
await ExploreManifest(cdmCorpus, "default.manifest.cdm.json");
}
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>
/// 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);
}
/// <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 TestResolveTestCorpus()
{
Assert.IsTrue(Directory.Exists(Path.GetFullPath(SchemaDocsPath)), "SchemaDocsRoot not found!!!");
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.SetEventCallback(new EventCallback {
Invoke = CommonDataModelLoader.ConsoleStatusReport
}, CdmStatusLevel.Warning);
cdmCorpus.Storage.Mount("local", new LocalAdapter(SchemaDocsPath));
var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>(TestHelper.CdmStandardSchemaPath) as CdmManifestDefinition;
var directives = new AttributeResolutionDirectiveSet(new HashSet <string> {
"normalized", "referenceOnly"
});
var allResolved = await ListAllResolved(cdmCorpus, directives, manifest, new StringSpewCatcher());
Assert.IsTrue(!string.IsNullOrWhiteSpace(allResolved));
}
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 void TestResolutionGuidanceCopy()
{
var corpus = new CdmCorpusDefinition();
var resolutionGuidance = new CdmAttributeResolutionGuidance(corpus.Ctx)
{
expansion = new CdmAttributeResolutionGuidance.Expansion(),
entityByReference = new CdmAttributeResolutionGuidance.CdmAttributeResolutionGuidance_EntityByReference(),
selectsSubAttribute = new CdmAttributeResolutionGuidance.CdmAttributeResolutionGuidance_SelectsSubAttribute(),
imposedDirectives = new List <string>(),
removedDirectives = new List <string>()
};
var resolutionGuidanceCopy = resolutionGuidance.Copy() as CdmAttributeResolutionGuidance;
Assert.IsFalse(Object.ReferenceEquals(resolutionGuidance.expansion, resolutionGuidanceCopy.expansion));
Assert.IsFalse(Object.ReferenceEquals(resolutionGuidance.entityByReference, resolutionGuidanceCopy.entityByReference));
Assert.IsFalse(Object.ReferenceEquals(resolutionGuidance.selectsSubAttribute, resolutionGuidanceCopy.selectsSubAttribute));
Assert.IsFalse(Object.ReferenceEquals(resolutionGuidance.imposedDirectives, resolutionGuidanceCopy.imposedDirectives));
Assert.IsFalse(Object.ReferenceEquals(resolutionGuidance.removedDirectives, resolutionGuidanceCopy.removedDirectives));
}
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 = 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, 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);
}
