public async Task TestPatternWithNonExistingFolder() { var corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestPatternWithNonExistingFolder"); var content = TestHelper.GetInputFileContent(testsSubpath, "TestPatternWithNonExistingFolder", "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(corpus, null), "entities", "local", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); int errorLogged = 0; corpus.SetEventCallback(new EventCallback { Invoke = (CdmStatusLevel statusLevel, string message) => { if (message.Contains("Failed to fetch all files in the folder location 'local:/testLocation' described by a partition pattern. Exception:")) { errorLogged++; } } }, CdmStatusLevel.Warning); await cdmManifest.FileStatusCheckAsync(); Assert.AreEqual(1, errorLogged); Assert.AreEqual(cdmManifest.Entities[0].DataPartitions.Count, 0); // make sure the last check time is still being set Assert.IsNotNull(cdmManifest.Entities[0].DataPartitionPatterns[0].LastFileStatusCheckTime); }
public async Task TestLoadingCdmFolderResultAndModelJsonToData() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestLoadingCdmFolderResultAndModelJsonToData)); var watch = Stopwatch.StartNew(); var cdmManifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>($"result.model{PersistenceLayer.ManifestExtension}", cdmCorpus.Storage.FetchRootFolder("local")); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Loading from data"); watch.Restart(); var obtainedModelJson = await ManifestPersistence.ToData(cdmManifest, null, null); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Parsing to data"); // remove empty description from entities as they interfere with test. obtainedModelJson.Entities.ForEach(RemoveDescriptionFromEntityIfEmpty); obtainedModelJson.Description = null; Assert.IsNull(cdmManifest.Imports.Item(Constants.FoundationsCorpusPath, checkMoniker: false)); Assert.AreEqual(1, obtainedModelJson.Imports.Count); Assert.AreEqual(Constants.FoundationsCorpusPath, obtainedModelJson.Imports[0].CorpusPath); this.HandleOutput(nameof(TestLoadingCdmFolderResultAndModelJsonToData), PersistenceLayer.ModelJsonExtension, obtainedModelJson); }
public async Task TestImportsRelativePath() { // the corpus path in the imports are relative to the document where it was defined. // when saving in model.json the documents are flattened to the manifest level // so it is necessary to recalculate the path to be relative to the manifest. var corpus = this.GetLocalCorpus("notImportantLocation"); var folder = corpus.Storage.FetchRootFolder("local"); var manifest = new CdmManifestDefinition(corpus.Ctx, "manifest"); var entityDeclaration = manifest.Entities.Add("EntityName", "EntityName/EntityName.cdm.json/EntityName"); folder.Documents.Add(manifest); var entityFolder = folder.ChildFolders.Add("EntityName"); var document = new CdmDocumentDefinition(corpus.Ctx, "EntityName.cdm.json"); document.Imports.Add("subfolder/EntityName.cdm.json"); document.Definitions.Add("EntityName"); entityFolder.Documents.Add(document); var subFolder = entityFolder.ChildFolders.Add("subfolder"); subFolder.Documents.Add("EntityName.cdm.json"); var data = await ManifestPersistence.ToData(manifest, null, null); Assert.AreEqual(1, data.Entities.Count); var imports = data.Entities[0]["cdm:imports"].ToObject <List <Import> >(); Assert.AreEqual(1, imports.Count); Assert.AreEqual("EntityName/subfolder/EntityName.cdm.json", imports[0].CorpusPath); }
public void TestToDataPartitionPatternWithIncrementalTrait() { var corpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestToDataPartitionPatternWithIncrementalTrait), noInputAndOutputFolder: true); bool errorMessageVerified = false; // not checking the CdmLogCode here as we want to check if this error message constructed correctly for the partition pattern (it shares the same CdmLogCode with partition) corpus.SetEventCallback(new EventCallback { Invoke = (CdmStatusLevel statusLevel, string message) => { if (message.Contains("Failed to persist object 'UpsertPartitionPattern'. " + "This object contains the trait 'is.partition.incremental', " + "so it should not be in the collection 'DataPartitionPatterns'. | ToData")) { errorMessageVerified = true; } else { Assert.Fail("Some unexpected failure - " + message); } } }, CdmStatusLevel.Warning); var manifest = new CdmManifestDefinition(corpus.Ctx, "manifest"); corpus.Storage.FetchRootFolder("local").Documents.Add(manifest); var entity = new CdmEntityDefinition(corpus.Ctx, "entityName", null); CdmCollectionHelperFunctions.CreateDocumentForEntity(corpus, entity); var localizedEntityDeclaration = manifest.Entities.Add(entity); var upsertIncrementalPartitionPattern = corpus.MakeObject <CdmDataPartitionPatternDefinition>(CdmObjectType.DataPartitionPatternDef, "UpsertPartitionPattern", false); upsertIncrementalPartitionPattern.RootLocation = "/IncrementalData"; upsertIncrementalPartitionPattern.SpecializedSchema = "csv"; upsertIncrementalPartitionPattern.ExhibitsTraits.Add(Constants.IncrementalTraitName, new List <Tuple <string, dynamic> >() { new Tuple <string, dynamic>("type", CdmIncrementalPartitionType.Upsert.ToString()) }); var testingPartitionPattern = corpus.MakeObject <CdmDataPartitionPatternDefinition>(CdmObjectType.DataPartitionPatternDef, "TestingPartitionPattern", false); testingPartitionPattern.RootLocation = "/testingData"; testingPartitionPattern.SpecializedSchema = "csv"; localizedEntityDeclaration.DataPartitionPatterns.Add(upsertIncrementalPartitionPattern); localizedEntityDeclaration.DataPartitionPatterns.Add(testingPartitionPattern); using (Logger.EnterScope(nameof(DataPartitionPatternTest), corpus.Ctx, nameof(TestToDataPartitionPatternWithIncrementalTrait))) { var manifestData = ManifestPersistence.ToData(manifest, null, null); Assert.AreEqual(1, manifestData.Entities.Count); var entityData = manifestData.Entities[0]; Assert.AreEqual(1, entityData.Value <JArray>("dataPartitionPatterns").Count); var patternData = entityData.Value <JArray>("dataPartitionPatterns").First; Assert.AreEqual("TestingPartitionPattern", patternData.Value <JToken>("name")); } Assert.IsTrue(errorMessageVerified); }
public void TestProgrammaticallyCreatePartitions() { var corpus = new CdmCorpusDefinition(); corpus.Storage.Mount("local", new LocalAdapter()); var manifest = corpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef, "manifest"); var entity = manifest.Entities.Add("entity"); var relativePartition = corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, "relative partition"); relativePartition.Location = "relative/path"; var absolutePartition = corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, "absolute partition"); absolutePartition.Location = "local:/absolute/path"; entity.DataPartitions.Add(relativePartition); entity.DataPartitions.Add(absolutePartition); var manifestData = ManifestPersistence.ToData(manifest, new ResolveOptions(), new CopyOptions()); Assert.AreEqual(manifestData.Entities.Count, 1); var entityData = manifestData.Entities[0]; var partitionsList = entityData.Value <JArray>("dataPartitions"); Assert.AreEqual(partitionsList.Count, 2); var relativePartitionData = partitionsList.First; var absolutePartitionData = partitionsList.Last; Assert.AreEqual(relativePartitionData.Value <string>("location"), relativePartition.Location); Assert.AreEqual(absolutePartitionData.Value <string>("location"), absolutePartition.Location); }
public async Task TestFromAndToData() { var expectedLogCodes = new HashSet <CdmLogCode> { CdmLogCode.ErrResolveReferenceFailure }; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestFromAndToData), expectedCodes: expectedLogCodes); var folder = corpus.Storage.FetchRootFolder("local"); var manifest = await corpus.FetchObjectAsync <CdmManifestDefinition>($"default{PersistenceLayer.ManifestExtension}", folder); var actualData = ManifestPersistence.ToData(manifest, null, null); foreach (var entity in manifest.Entities) { await corpus.FetchObjectAsync <CdmEntityDefinition>(entity.EntityPath, manifest); } corpus.Storage.FetchRootFolder("output").Documents.Add(manifest); await manifest.SaveAsAsync($"default{PersistenceLayer.ManifestExtension}", saveReferenced : true); TestHelper.AssertCdmLogCodeEquality(corpus, CdmLogCode.ErrResolveReferenceFailure, true); var expected_data = TestHelper.GetExpectedOutputFileContent(testsSubpath, nameof(TestFromAndToData), $"default{PersistenceLayer.ManifestExtension}"); TestHelper.AssertSameObjectWasSerialized(expected_data, JsonConvert.SerializeObject(actualData, Formatting.Indented, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore })); }
public void TestLoadLocalEntitiyWithDataPartition() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadLocalEntityWithDataPartition", "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromData(new ResolveContext(new CdmCorpusDefinition(), null), "entities", "testNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(cdmManifest.Entities.Count, 1); Assert.AreEqual(cdmManifest.Entities[0].ObjectType, CdmObjectType.LocalEntityDeclarationDef); var entity = cdmManifest.Entities[0]; Assert.AreEqual(entity.DataPartitions.Count, 1); var partition = entity.DataPartitions[0]; Assert.AreEqual(partition.Location, "test/location"); Assert.AreEqual(TimeUtils.GetFormattedDateString(partition.LastFileModifiedTime), "2008-09-15T23:53:23.000Z"); Assert.AreEqual(partition.ExhibitsTraits.Count, 1); Assert.AreEqual(partition.SpecializedSchema, "teststring"); var testList = partition.Arguments["test"]; Assert.AreEqual(testList.Count, 2); Assert.AreEqual(testList[0], "something"); Assert.AreEqual(testList[1], "somethingelse"); var keyList = partition.Arguments["KEY"]; Assert.AreEqual(keyList.Count, 1); Assert.AreEqual(keyList[0], "VALUE"); Assert.IsFalse(partition.Arguments.ContainsKey("wrong")); }
public async Task TestLoadingAndSavingDateAndTimeDataTypes() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestLoadingAndSavingDateAndTimeDataTypes)); // Load the manifest and resolve it var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("local:/default.manifest.cdm.json"); var resolvedManifest = await manifest.CreateResolvedManifestAsync("resolved", null); // Convert loaded manifest to model.json var modelJson = await ManifestPersistence.ToData(resolvedManifest, null, null); // Verify that the attributes' data types were correctly persisted as "date" and "time" Assert.AreEqual("date", modelJson.Entities[0]["attributes"][0]["dataType"].ToString()); Assert.AreEqual("time", modelJson.Entities[0]["attributes"][1]["dataType"].ToString()); // Now check that these attributes' data types are still "date" and "time" when loading the model.json back to manifest // We first need to create a second adapter to the input folder to fool the OM into thinking it's different // This is because there's a bug that currently prevents us from saving and then loading a model.json under the same namespace cdmCorpus.Storage.Mount("local2", new LocalAdapter(TestHelper.GetInputFolderPath(testsSubpath, nameof(TestLoadingAndSavingDateAndTimeDataTypes)))); var manifestFromModelJson = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("local2:/model.json"); var entity = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>(manifestFromModelJson.Entities[0].EntityPath, manifestFromModelJson); // Verify that the attributes' data types were correctly loaded as "date" and "time" Assert.AreEqual(CdmDataFormat.Date, (entity.Attributes[0] as CdmTypeAttributeDefinition).DataFormat); Assert.AreEqual(CdmDataFormat.Time, (entity.Attributes[1] as CdmTypeAttributeDefinition).DataFormat); }
public void TestProgrammaticallyCreatePartitions() { var corpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestProgrammaticallyCreatePartitions), noInputAndOutputFolder: true); var manifest = corpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef, "manifest"); var entity = manifest.Entities.Add("entity"); var relativePartition = corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, "relative partition"); relativePartition.Location = "relative/path"; relativePartition.Arguments.Add("test1", new List <string>() { "argument1" }); relativePartition.Arguments.Add("test2", new List <string>() { "argument2", "argument3" }); var absolutePartition = corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, "absolute partition"); absolutePartition.Location = "local:/absolute/path"; // add an empty arguments list to test empty list should not be displayed in ToData json. absolutePartition.Arguments.Add("test", new List <string>()); entity.DataPartitions.Add(relativePartition); entity.DataPartitions.Add(absolutePartition); var manifestData = ManifestPersistence.ToData(manifest, new ResolveOptions(), new CopyOptions()); Assert.AreEqual(1, manifestData.Entities.Count); var entityData = manifestData.Entities[0]; var partitionsList = entityData.Value <JArray>("dataPartitions"); Assert.AreEqual(2, partitionsList.Count); var relativePartitionData = partitionsList.First; var absolutePartitionData = partitionsList.Last; Assert.AreEqual(relativePartition.Location, relativePartitionData.Value <string>("location")); var argumentsList = relativePartitionData.Value <JArray>("arguments"); Assert.AreEqual(3, argumentsList.Count); Assert.AreEqual(2, argumentsList[0].Count()); Assert.AreEqual("test1", argumentsList[0].Value <string>("name")); Assert.AreEqual("argument1", argumentsList[0].Value <string>("value")); Assert.AreEqual(2, argumentsList[1].Count()); Assert.AreEqual("test2", argumentsList[1].Value <string>("name")); Assert.AreEqual("argument2", argumentsList[1].Value <string>("value")); Assert.AreEqual(2, argumentsList[2].Count()); Assert.AreEqual("test2", argumentsList[2].Value <string>("name")); Assert.AreEqual("argument3", argumentsList[2].Value <string>("value")); Assert.AreEqual(absolutePartition.Location, absolutePartitionData.Value <string>("location")); // test if empty argument list is set to null Assert.IsNull(absolutePartitionData.Value <List <object> >("arguments")); }
public async Task TestLoadLegacyEntityDeclaration() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadLegacyEntityDeclaration", "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromData(new ResolveContext(new CdmCorpusDefinition(), null), "", "", "", JsonConvert.DeserializeObject <ManifestContent>(content)); // Local entity declaration. Assert.AreEqual("testPath", cdmManifest.Entities[0].EntityPath); // Referenced entity declaration. Assert.AreEqual("Account.cdm.json/Account", cdmManifest.Entities[1].EntityPath); }
public async Task TestReferenceModels() { var corpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestReferenceModels)); var manifest = await corpus.FetchObjectAsync <CdmManifestDefinition>(PersistenceLayer.ModelJsonExtension, corpus.Storage.FetchRootFolder("local")); // entity with same modelId but different location var referenceEntity1 = new CdmReferencedEntityDeclarationDefinition(corpus.Ctx, "ReferenceEntity1") { EntityPath = "remote:/contoso/entity1.model.json/Entity1" }; var modelIdTrait1 = referenceEntity1.ExhibitsTraits.Add("is.propertyContent.multiTrait") as CdmTraitReference; modelIdTrait1.IsFromProperty = true; modelIdTrait1.Arguments.Add("modelId", "f19bbb97-c031-441a-8bd1-61b9181c0b83/1a7ef9c8-c7e8-45f8-9d8a-b80f8ffe4612"); manifest.Entities.Add(referenceEntity1); // entity without modelId but same location var referenceEntity2 = new CdmReferencedEntityDeclarationDefinition(corpus.Ctx, "ReferenceEntity2") { EntityPath = "remote:/contoso/entity.model.json/Entity2" }; manifest.Entities.Add(referenceEntity2); // entity with modelId and new location var referenceEntity3 = new CdmReferencedEntityDeclarationDefinition(corpus.Ctx, "ReferenceEntity3") { EntityPath = "remote:/contoso/entity3.model.json/Entity3" }; var modelIdTrait3 = referenceEntity3.ExhibitsTraits.Add("is.propertyContent.multiTrait") as CdmTraitReference; modelIdTrait3.IsFromProperty = true; modelIdTrait3.Arguments.Add("modelId", "3b2e040a-c8c5-4508-bb42-09952eb04a50"); manifest.Entities.Add(referenceEntity3); // entity with same modelId and same location var referenceEntity4 = new CdmReferencedEntityDeclarationDefinition(corpus.Ctx, "ReferenceEntity4") { EntityPath = "remote:/contoso/entity.model.json/Entity4" }; var modelIdTrait4 = referenceEntity4.ExhibitsTraits.Add("is.propertyContent.multiTrait") as CdmTraitReference; modelIdTrait4.IsFromProperty = true; modelIdTrait4.Arguments.Add("modelId", "f19bbb97-c031-441a-8bd1-61b9181c0b83/1a7ef9c8-c7e8-45f8-9d8a-b80f8ffe4612"); manifest.Entities.Add(referenceEntity4); var obtainedModelJson = await ManifestPersistence.ToData(manifest, null, null); this.HandleOutput(nameof(TestReferenceModels), PersistenceLayer.ModelJsonExtension, obtainedModelJson); }
public void TestLoadFolderWithSubFolders() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadFolderWithSubFolders", "subManifest.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(new CdmCorpusDefinition(), null), "testEntity", "testNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(cdmManifest.SubManifests.Count, 1); var subManifest = cdmManifest.SubManifests[0]; Assert.AreEqual(subManifest.GetName(), "sub folder declaration"); Assert.AreEqual(subManifest.Explanation, "test sub explanation"); Assert.AreEqual(subManifest.Definition, "test definition"); }
public void TestLoadReferencedEntity() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadReferencedEntity", "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(new CdmCorpusDefinition(), null), "testEntity", "testNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(cdmManifest.Entities.Count, 1); Assert.AreEqual(cdmManifest.Entities[0].ObjectType, CdmObjectType.ReferencedEntityDeclarationDef); var entity = cdmManifest.Entities[0]; Assert.AreEqual(entity.EntityName, "testEntity"); Assert.AreEqual(entity.Explanation, "test explanation"); Assert.AreEqual(entity.EntityPath, "testNamespace:/testPath"); Assert.AreEqual(entity.ExhibitsTraits.Count, 1); }
public async Task TestLoadingAndSavingCdmTraits() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestLoadingAndSavingCdmTraits)); var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("model.json"); var entity = await cdmCorpus.FetchObjectAsync <CdmEntityDefinition>("someEntity.cdm.json/someEntity"); Assert.NotNull(entity.ExhibitsTraits.Item("is.CDM.entityVersion")); var manifestData = await ManifestPersistence.ToData(manifest, new ResolveOptions(manifest.InDocument), new CopyOptions()); var versionAnnotation = (manifestData.Entities[0]["annotations"][0]).ToObject <Annotation>(); Assert.AreEqual("<version>", versionAnnotation.Value); }
public void TestManifestWithBlankFields() { var content = TestHelper.GetInputFileContent(testsSubpath, "testManifestWithBlankFields", "blank.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(new CdmCorpusDefinition(), null), "cdmTest", "someNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.IsNull(cdmManifest.Schema); Assert.IsNull(cdmManifest.DocumentVersion); Assert.AreEqual(TimeUtils.GetFormattedDateString((DateTimeOffset)cdmManifest.LastFileModifiedTime), "2008-09-15T23:53:23.000Z"); Assert.AreEqual(cdmManifest.Explanation, "test cdm folder for cdm version 1.0+"); Assert.AreEqual(cdmManifest.Imports.Count, 1); Assert.AreEqual(cdmManifest.Imports[0].CorpusPath, "/primitives.cdm.json"); Assert.AreEqual(cdmManifest.Entities.Count, 0); Assert.AreEqual(cdmManifest.ExhibitsTraits.Count, 1); Assert.AreEqual(cdmManifest.SubManifests.Count, 0); }
public void TestFolioWithEverything() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestFolioWithEverything", "complete.folio.cdm.json"); var cdmManifest = ManifestPersistence.FromData(new ResolveContext(new CdmCorpusDefinition(), null), "docName", "someNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(1, cdmManifest.SubManifests.Count); Assert.AreEqual(2, cdmManifest.Entities.Count); Assert.AreEqual("cdmTest", cdmManifest.ManifestName); content = TestHelper.GetInputFileContent(testsSubpath, "TestFolioWithEverything", "noname.folio.cdm.json"); cdmManifest = ManifestPersistence.FromData(new ResolveContext(new CdmCorpusDefinition(), null), "docName.folio.cdm.json", "someNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(1, cdmManifest.SubManifests.Count); Assert.AreEqual(2, cdmManifest.Entities.Count); Assert.AreEqual("docName", cdmManifest.ManifestName); }
public void TestLoadFolderWithNoEntityFolders() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadFolderWithNoEntityFolders", "empty.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromData(new ResolveContext(new CdmCorpusDefinition(), null), "cdmTest", "someNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(cdmManifest.Schema, "CdmManifestDefinition.cdm.json"); Assert.AreEqual(cdmManifest.ManifestName, "cdmTest"); Assert.AreEqual(cdmManifest.JsonSchemaSemanticVersion, "0.9.0"); Assert.AreEqual(TimeUtils.GetFormattedDateString((DateTimeOffset)cdmManifest.LastFileModifiedTime), "2008-09-15T23:53:23.000Z"); Assert.AreEqual(cdmManifest.Explanation, "test cdm folder for cdm version 0.9+"); Assert.AreEqual(cdmManifest.Imports.Count, 1); Assert.AreEqual(cdmManifest.Imports[0].CorpusPath, "/primitives.cdm.json"); Assert.AreEqual(cdmManifest.Entities.Count, 0); Assert.AreEqual(cdmManifest.ExhibitsTraits.Count, 1); Assert.AreEqual(cdmManifest.SubManifests.Count, 0); }
public void TestLoadNoPartition() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadNoPartition", "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(new CdmCorpusDefinition(), null), "", "", "", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(1, cdmManifest.Entities.Count); Assert.AreEqual(cdmManifest.Entities[0].ObjectType, CdmObjectType.LocalEntityDeclarationDef); var entity = cdmManifest.Entities[0]; Assert.AreEqual("Account", entity.EntityName); Assert.AreEqual("Account explanation", entity.Explanation); Assert.AreEqual("Account.cdm.json/Account", entity.EntityPath); Assert.AreEqual(1, entity.ExhibitsTraits.Count); Assert.AreEqual(0, entity.DataPartitions.Count); Assert.AreEqual(0, entity.DataPartitionPatterns.Count); }
public void TestDataPartitionArgumentsAreSerializedAppropriately() { var readFile = TestHelper.GetInputFileContent(testsSubpath, nameof(TestDataPartitionArgumentsAreSerializedAppropriately), "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject( new ResolveContext(new CdmCorpusDefinition(), null), "entities", "testNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(readFile)); var obtainedCdmFolder = ManifestPersistence.ToData(cdmManifest, null, null); if (doesWriteTestDebuggingFiles) { TestHelper.WriteActualOutputFileContent(testsSubpath, nameof(TestDataPartitionArgumentsAreSerializedAppropriately), "savedManifest.manifest.cdm.json", ModelJsonTestsBase.Serialize(obtainedCdmFolder)); } var expectedOutput = TestHelper.GetExpectedOutputFileContent(testsSubpath, nameof(TestDataPartitionArgumentsAreSerializedAppropriately), "savedManifest.manifest.cdm.json"); TestHelper.AssertSameObjectWasSerialized(expectedOutput, ModelJsonTestsBase.Serialize(obtainedCdmFolder)); }
public async Task TestLoadingCdmFolderAndModelJsonToData() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestLoadingCdmFolderAndModelJsonToData)); var watch = Stopwatch.StartNew(); var cdmManifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>($"default{PersistenceLayer.ManifestExtension}", cdmCorpus.Storage.FetchRootFolder("local")); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Loading from data"); watch.Restart(); var obtainedModelJson = await ManifestPersistence.ToData(cdmManifest, null, null); watch.Stop(); Assert.Performance(9800, watch.ElapsedMilliseconds, "Parsing to data"); this.HandleOutput(nameof(TestLoadingCdmFolderAndModelJsonToData), "model.json", obtainedModelJson, isLanguageSpecific: true); }
public async Task TestModelJsonFromAndToData() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestModelJsonFromAndToData)); var watch = Stopwatch.StartNew(); var cdmManifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>(PersistenceLayer.ModelJsonExtension, cdmCorpus.Storage.FetchRootFolder("local")); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Loading from data"); watch.Restart(); var obtainedModelJson = await ManifestPersistence.ToData(cdmManifest, null, null); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Parsing to data"); this.HandleOutput(nameof(TestModelJsonFromAndToData), PersistenceLayer.ModelJsonExtension, obtainedModelJson); }
public async Task TestLoadingCdmFolderAndSavingModelJson() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestLoadingCdmFolderAndSavingModelJson"); var watch = Stopwatch.StartNew(); var cdmManifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("default.manifest.cdm.json", cdmCorpus.Storage.FetchRootFolder("local")); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Loading from data"); watch.Restart(); var obtainedModelJson = await ManifestPersistence.ToData(cdmManifest, null, null); watch.Stop(); Assert.Performance(5000, watch.ElapsedMilliseconds, "Parsing to data"); this.HandleOutput("TestLoadingCdmFolderAndSavingModelJson", "model.json", obtainedModelJson); }
public async Task TestRefEntityWithSlashPath() { var slashCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestRefEntityWithSlashPath"); var slashLocalPath = ((LocalAdapter)slashCorpus.Storage.NamespaceAdapters["local"]).Root; var slashAdapter = new LocalAdapterWithSlashPath(slashLocalPath, "/"); slashCorpus.Storage.Mount("slash", slashAdapter); slashCorpus.Storage.DefaultNamespace = "slash"; // load model.json files with paths generated using both '/' and '\' var slashManifest = await slashCorpus.FetchObjectAsync <CdmManifestDefinition>("slash:/model.json"); // manually add the reference model location, path will vary on each machine var refModelTrait = slashManifest.ExhibitsTraits.Item("is.modelConversion.referenceModelMap") as CdmTraitReference; var entityPath = slashManifest.Entities[0].EntityPath; refModelTrait.Arguments[0].Value[0].location = slashAdapter.CreateAdapterPath(entityPath.Substring(0, entityPath.LastIndexOf("/"))); var slashModel = await ManifestPersistence.ToData(slashManifest, new ResolveOptions(), new CopyOptions()); Assert.IsNotNull(slashModel); Assert.AreEqual(1, slashModel.Entities.Count); var backSlashCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestRefEntityWithSlashPath"); var backSlashLocalPath = ((LocalAdapter)backSlashCorpus.Storage.NamespaceAdapters["local"]).Root; var backSlashAdapter = new LocalAdapterWithSlashPath(backSlashLocalPath, "\\"); backSlashCorpus.Storage.Mount("backslash", backSlashAdapter); backSlashCorpus.Storage.DefaultNamespace = "backslash"; var backSlashManifest = await backSlashCorpus.FetchObjectAsync <CdmManifestDefinition>("backslash:/model.json"); // manually add the reference model location, path will vary on each machine var backSlashRefModelTrait = backSlashManifest.ExhibitsTraits.Item("is.modelConversion.referenceModelMap") as CdmTraitReference; var backSlashEntityPath = backSlashManifest.Entities[0].EntityPath; backSlashRefModelTrait.Arguments[0].Value[0].location = backSlashAdapter.CreateAdapterPath(backSlashEntityPath.Substring(0, backSlashEntityPath.LastIndexOf("/"))) .Replace("/", "\\\\"); var backSlashModel = await ManifestPersistence.ToData(backSlashManifest, new ResolveOptions(), new CopyOptions()); Assert.IsNotNull(backSlashModel); Assert.AreEqual(1, backSlashModel.Entities.Count); }
public void TestManifestForCopyData() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestManifestForCopyData", "complete.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromData(new ResolveContext(new CdmCorpusDefinition(), null), "docName", "someNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); ManifestContent manifestObject = CdmObjectBase.CopyData(cdmManifest, null, null); Assert.AreEqual(manifestObject.Schema, "CdmManifestDefinition.cdm.json"); Assert.AreEqual(manifestObject.JsonSchemaSemanticVersion, "0.9.0"); Assert.AreEqual(manifestObject.ManifestName, "cdmTest"); Assert.AreEqual(manifestObject.Explanation, "test cdm folder for cdm version 0.9+"); Assert.AreEqual(manifestObject.Imports.Count, 1); Assert.AreEqual(manifestObject.Imports[0].CorpusPath, "/primitives.cdm.json"); Assert.AreEqual(manifestObject.ExhibitsTraits.Count, 1); Assert.AreEqual(manifestObject.Entities.Count, 2); Assert.AreEqual(manifestObject.Entities[0]["entityName"], "testEntity"); Assert.AreEqual(manifestObject.SubManifests.Count, 1); Assert.AreEqual(manifestObject.SubManifests[0].Definition, "test definition"); Assert.AreEqual(manifestObject.LastFileModifiedTime, null); }
public async Task TestModelJsonExtensibility() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestModelJsonExtensibility"); var cdmManifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("model.json", cdmCorpus.Storage.FetchRootFolder("local")); var obtainedModel = await ManifestPersistence.ToData(cdmManifest, null, null); // The imports were generated during processing and are not present in the original file. obtainedModel.Imports = null; if (doesWriteTestDebuggingFiles) { TestHelper.WriteActualOutputFileContent(testsSubpath, "TestModelJsonExtensibility", "SerializerTesting-model.json", Serialize(obtainedModel)); } var obtainedModelJson = Serialize(obtainedModel); var originalModelJson = TestHelper.GetExpectedOutputFileContent(testsSubpath, "TestModelJsonExtensibility", "SerializerTesting-model.json"); TestHelper.AssertSameObjectWasSerialized(originalModelJson, obtainedModelJson); }
public void TestLoadNoPartitionAbsoluteNamespaceSet() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadNoPartitionAbsoluteNamespaceSet", "entities.manifest.cdm.json"); ManifestContent manifestContent = JsonConvert.DeserializeObject <ManifestContent>(content); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(new CdmCorpusDefinition(), null), "testEntity", "testNamespace", "/", manifestContent); Assert.AreEqual(cdmManifest.Entities.Count, 1); Assert.AreEqual(cdmManifest.Entities[0].ObjectType, CdmObjectType.LocalEntityDeclarationDef); var entity = cdmManifest.Entities[0]; Assert.AreEqual("Account", entity.EntityName); Assert.AreEqual("Account explanation", entity.Explanation); Assert.AreEqual("testNamespace:/Account.cdm.json/Account", entity.EntityPath); Assert.AreEqual(1, entity.ExhibitsTraits.Count); Assert.AreEqual(0, entity.DataPartitions.Count); Assert.AreEqual(0, entity.DataPartitionPatterns.Count); var manifestToData = ManifestPersistence.ToData(cdmManifest, null, null); Assert.AreEqual("testNamespace:/Account.cdm.json/Account", manifestToData.Entities[0].Value <string>("entityPath")); }
public async Task TestSettingModelJsonEntityDescription() { var cdmCorpus = new CdmCorpusDefinition(); var cdmManifest = cdmCorpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef, "test"); var document = cdmCorpus.MakeObject <CdmDocumentDefinition>(CdmObjectType.DocumentDef, $"entity{PersistenceLayer.CdmExtension}"); var folder = cdmCorpus.Storage.FetchRootFolder("local"); folder.Documents.Add(document); var entity = document.Definitions.Add(CdmObjectType.EntityDef, "entity") as CdmEntityDefinition; entity.Description = "test description"; cdmManifest.Entities.Add(entity); folder.Documents.Add(cdmManifest); var obtainedModelJson = await ManifestPersistence.ToData(cdmManifest, null, null); Assert.AreEqual("test description", obtainedModelJson.Entities[0]["description"].ToString()); }
public async Task TestLoadingCdmFolderResultAndSavingModelJson() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, "TestLoadingCdmFolderResultAndSavingModelJson"); var watch = Stopwatch.StartNew(); var cdmManifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("result.model.manifest.cdm.json", cdmCorpus.Storage.FetchRootFolder("local")); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Loading from data"); watch.Restart(); var obtainedModelJson = await ManifestPersistence.ToData(cdmManifest, null, null); watch.Stop(); Assert.Performance(1000, watch.ElapsedMilliseconds, "Parsing to data"); // remove empty description from entities as they interfere with test. obtainedModelJson.Entities.ForEach(RemoveDescriptionFromEntityIfEmpty); obtainedModelJson.Description = null; this.HandleOutput("TestLoadingCdmFolderResultAndSavingModelJson", "model.json", obtainedModelJson); }
public void TestLoadLocalEntitiyWithDataPartitionPattern() { var content = TestHelper.GetInputFileContent(testsSubpath, "TestLoadLocalEntityWithDataPartitionPattern", "entities.manifest.cdm.json"); var cdmManifest = ManifestPersistence.FromObject(new ResolveContext(new CdmCorpusDefinition(), null), "entities", "testNamespace", "/", JsonConvert.DeserializeObject <ManifestContent>(content)); Assert.AreEqual(cdmManifest.Entities.Count, 1); Assert.AreEqual(cdmManifest.Entities[0].ObjectType, CdmObjectType.LocalEntityDeclarationDef); var entity = cdmManifest.Entities[0]; Assert.AreEqual(entity.DataPartitionPatterns.Count, 1); var pattern = entity.DataPartitionPatterns[0]; Assert.AreEqual(pattern.Name, "testPattern"); Assert.AreEqual(pattern.Explanation, "test explanation"); Assert.AreEqual(pattern.RootLocation, "test location"); Assert.AreEqual(pattern.RegularExpression.ToString(), "\\s*"); Assert.AreEqual(pattern.Parameters.Count, 2); Assert.AreEqual(pattern.Parameters[0], "testParam1"); Assert.AreEqual(pattern.Parameters[1], "testParam2"); Assert.AreEqual(pattern.SpecializedSchema, "test special schema"); Assert.AreEqual(pattern.ExhibitsTraits.Count, 1); }
public async Task TestLoadingAndSavingCsvPartitionTraits() { var cdmCorpus = TestHelper.GetLocalCorpus(testsSubpath, nameof(TestLoadingCsvPartitionTraitsFromFileFormatSettings)); var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("model.json"); // If the data partition trait is.partition.format.CSV being saved has arguments that are not supported by fileFormatSettings // the trait should also be persisted. var manifestData = await ManifestPersistence.ToData(manifest, new ResolveOptions(manifest.InDocument), new CopyOptions()); var localEntity = manifestData.Entities[0].ToObject <LocalEntity>(); Assert.AreEqual(1, localEntity.Partitions[0].Traits.Count); // Remove the argument that is not supported by fileFormatSettings and check if the trait is removed after that. var csvTrait = manifest.Entities[0].DataPartitions[0].ExhibitsTraits[0] as CdmTraitReference; csvTrait.Arguments.Remove(csvTrait.Arguments.Item("newline")); manifestData = await ManifestPersistence.ToData(manifest, new ResolveOptions(manifest.InDocument), new CopyOptions()); localEntity = manifestData.Entities[0].ToObject <LocalEntity>(); Assert.IsNull(localEntity.Partitions[0].Traits); }