public void TestDocumentCollectionInsert()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("c:\\Root\\Path");
var folder = new CdmFolderDefinition(manifest.Ctx, "Folder");
folder.InDocument = manifest;
folder.Corpus = manifest.Ctx.Corpus;
folder.FolderPath = "FolderPath/";
folder.Namespace = "Namespace";
var document = new CdmDocumentDefinition(manifest.Ctx, "DocumentName");
var doc1 = folder.Documents.Add("doc1");
var doc2 = folder.Documents.Add("doc2");
manifest.IsDirty = false;
folder.Documents.Insert(2, document);
Assert.AreEqual(true, manifest.IsDirty);
Assert.AreEqual(3, folder.Documents.Count);
Assert.AreEqual(doc1, folder.Documents[0]);
Assert.AreEqual(doc2, folder.Documents[1]);
Assert.AreEqual(document, folder.Documents[2]);
Assert.AreEqual("FolderPath/", document.FolderPath);
Assert.AreEqual(folder, document.Owner);
Assert.AreEqual("Namespace", document.Namespace);
Assert.IsTrue(document.NeedsIndexing);
Assert.AreEqual(folder, document.Owner);
Assert.IsTrue(folder.DocumentLookup.ContainsKey(document.Name));
Assert.IsTrue(manifest.Ctx.Corpus.AllDocuments.Contains(Tuple.Create(folder, document)));
}
public void TestDocumentCollectionAddRange()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("c:\\Root\\Path");
var folder = new CdmFolderDefinition(manifest.Ctx, "Folder");
folder.Corpus = manifest.Ctx.Corpus;
folder.FolderPath = "FolderPath/";
folder.Namespace = "Namespace";
Assert.AreEqual(0, folder.Documents.Count);
var document = new CdmDocumentDefinition(manifest.Ctx, "DocumentName");
var document2 = new CdmDocumentDefinition(manifest.Ctx, "DocumentName2");
var documentList = new List <CdmDocumentDefinition> {
document, document2
};
folder.Documents.AddRange(documentList);
Assert.AreEqual(2, folder.Documents.Count);
Assert.AreEqual(document, folder.Documents[0]);
Assert.AreEqual(document2, folder.Documents[1]);
Assert.AreEqual("DocumentName", document.Name);
Assert.AreEqual("FolderPath/", document.FolderPath);
Assert.AreEqual(folder, document.Owner);
Assert.AreEqual("Namespace", document.Namespace);
Assert.IsTrue(document.NeedsIndexing);
Assert.AreEqual("DocumentName2", document2.Name);
Assert.AreEqual("FolderPath/", document2.FolderPath);
Assert.AreEqual(folder, document2.Owner);
Assert.AreEqual("Namespace", document2.Namespace);
Assert.IsTrue(document2.NeedsIndexing);
}
public void TestFolderCollectionInsert()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var parentFolder = new CdmFolderDefinition(manifest.Ctx, "ParentFolder");
parentFolder.InDocument = manifest;
parentFolder.Namespace = "TheNamespace";
parentFolder.FolderPath = "ParentFolderPath/";
var childFolders = parentFolder.ChildFolders;
var childFolder = new CdmFolderDefinition(manifest.Ctx, "ChildFolder1");
var child1 = childFolders.Add("child1");
var child2 = childFolders.Add("child2");
manifest.IsDirty = false;
childFolders.Insert(1, childFolder);
Assert.AreEqual(3, childFolders.Count);
Assert.IsTrue(manifest.IsDirty);
Assert.AreEqual(child1, childFolders[0]);
Assert.AreEqual(childFolder, childFolders[1]);
Assert.AreEqual(child2, childFolders[2]);
Assert.AreEqual(manifest.Ctx, childFolder.Ctx);
Assert.AreEqual("ChildFolder1", childFolder.Name);
Assert.AreEqual(parentFolder, childFolder.Owner);
Assert.AreEqual("TheNamespace", childFolder.Namespace);
Assert.AreEqual(parentFolder.FolderPath + childFolder.Name + "/", childFolder.FolderPath);
}
public void TestFolderCollectionAddRange()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var parentFolder = new CdmFolderDefinition(manifest.Ctx, "ParentFolder");
parentFolder.Namespace = "TheNamespace";
parentFolder.FolderPath = "ParentFolderPath/";
CdmFolderCollection childFolders = parentFolder.ChildFolders;
var childFolder = new CdmFolderDefinition(manifest.Ctx, "ChildFolder1");
var childFolder2 = new CdmFolderDefinition(manifest.Ctx, "ChildFolder2");
var childList = new List <CdmFolderDefinition> {
childFolder, childFolder2
};
Assert.AreEqual(0, childFolders.Count);
childFolders.AddRange(childList);
Assert.AreEqual(2, childFolders.Count);
Assert.AreEqual(childFolder, childFolders[0]);
Assert.AreEqual(manifest.Ctx, childFolder.Ctx);
Assert.AreEqual("ChildFolder1", childFolder.Name);
Assert.AreEqual(parentFolder, childFolder.Owner);
Assert.AreEqual("TheNamespace", childFolder.Namespace);
Assert.AreEqual(parentFolder.FolderPath + childFolder.Name + "/", childFolder.FolderPath);
Assert.AreEqual(childFolder2, childFolders[1]);
Assert.AreEqual("ChildFolder2", childFolder2.Name);
Assert.AreEqual(parentFolder, childFolder2.Owner);
Assert.AreEqual("TheNamespace", childFolder2.Namespace);
Assert.AreEqual(parentFolder.FolderPath + childFolder2.Name + "/", childFolder2.FolderPath);
}
public void TestManifestAddEntityWithLocalizedPaths()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var cdmCorpus = manifest.Ctx.Corpus;
var entity = new CdmEntityDefinition(cdmCorpus.Ctx, "entityName", null);
entity.Explanation = "The explanation of the entity";
CdmCollectionHelperFunctions.CreateDocumentForEntity(cdmCorpus, entity);
var cdmEntity = new CdmEntityDefinition(cdmCorpus.Ctx, "cdmEntityName", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(cdmCorpus, cdmEntity, "cdm");
var localizedEntityDeclaration = manifest.Entities.Add(entity);
var cdmEntityDeclaration = manifest.Entities.Add(cdmEntity);
Assert.AreEqual("The explanation of the entity", localizedEntityDeclaration.Explanation);
Assert.AreEqual("entityName.cdm.json/entityName", localizedEntityDeclaration.EntityPath);
Assert.AreEqual("entityName", localizedEntityDeclaration.EntityName);
Assert.AreEqual("cdm:/cdmEntityName.cdm.json/cdmEntityName", cdmEntityDeclaration.EntityPath);
Assert.AreEqual("entityName", localizedEntityDeclaration.EntityName);
Assert.AreEqual(2, manifest.Entities.Count);
Assert.AreEqual(localizedEntityDeclaration, manifest.Entities[0]);
Assert.AreEqual(cdmEntityDeclaration, manifest.Entities[1]);
}
public void TestCdmDefinitionCollectionAdd()
{
var document = CdmCollectionHelperFunctions.GenerateManifest("C:\\Nothing");
document.IsDirty = false;
var attribute = new CdmAttributeContext(document.Ctx, "the attribute");
var folder = new CdmFolderDefinition(document.Ctx, "The folder");
var trait = new CdmTraitDefinition(document.Ctx, "The trait");
var addedAttribute = document.Definitions.Add(attribute);
var addedFolder = document.Definitions.Add(folder);
var addedTrait = document.Definitions.Add(trait);
Assert.IsTrue(document.IsDirty);
Assert.AreEqual(3, document.Definitions.Count);
Assert.AreEqual(attribute, addedAttribute);
Assert.AreEqual(folder, addedFolder);
Assert.AreEqual(trait, addedTrait);
Assert.AreEqual(attribute, document.Definitions[0]);
Assert.AreEqual(folder, document.Definitions[1]);
Assert.AreEqual(trait, document.Definitions[2]);
Assert.AreEqual(document, attribute.InDocument);
Assert.AreEqual(document, trait.InDocument);
Assert.AreEqual(document, attribute.Owner);
Assert.AreEqual(document, folder.Owner);
Assert.AreEqual(document, trait.Owner);
}
public void TestManifestAddListOfEntityDeclarations()
{
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.Storage.DefaultNamespace = "local";
cdmCorpus.Storage.Mount("local", new LocalAdapter("CdmCorpus/LocalPath"));
var ctx = cdmCorpus.Ctx;
var cdmDocument = new CdmDocumentDefinition(ctx, "NameOfDocument");
var collection = new CdmEntityCollection(ctx, cdmDocument);
var entityList = new List <CdmEntityDefinition>();
for (int i = 0; i < 2; i++)
{
var entity = new CdmEntityDefinition(cdmCorpus.Ctx, $"entityName_{i}", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(cdmCorpus, entity);
entityList.Add(entity);
}
Assert.AreEqual(0, collection.Count);
collection.AddRange(entityList);
Assert.AreEqual(2, collection.Count);
for (int i = 0; i < 2; i++)
{
Assert.AreEqual($"entityName_{i}", collection[i].EntityName);
}
}
public void TestCdmEntityCollectionRemoveEntityDeclarationDefinition()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var entity = new CdmEntityDefinition(manifest.Ctx, "entityName", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(manifest.Ctx.Corpus, entity);
var otherEntity = new CdmEntityDefinition(manifest.Ctx, "otherEntityName", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(manifest.Ctx.Corpus, otherEntity);
manifest.Entities.Add(entity);
manifest.Entities.Add(otherEntity);
Assert.AreEqual(2, manifest.Entities.Count);
bool removed = manifest.Entities.Remove(entity);
Assert.IsTrue(removed);
Assert.AreEqual(1, manifest.Entities.Count);
Assert.AreEqual(otherEntity.EntityName, manifest.Entities[0].EntityName);
removed = manifest.Entities.Remove(entity);
Assert.IsFalse(removed);
Assert.AreEqual(1, manifest.Entities.Count);
}
public void CdmTraitCollectionRemove()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitDefinition(manifest.Ctx, "TraitName", null);
var otherTrait = new CdmTraitDefinition(manifest.Ctx, "Name of other Trait", null);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
Assert.AreEqual(2, manifest.ExhibitsTraits.Count);
manifest.TraitCache = new Dictionary <string, ResolvedTraitSetBuilder>();
var removed = manifest.ExhibitsTraits.Remove(trait);
Assert.IsTrue(removed);
Assert.AreEqual(1, manifest.ExhibitsTraits.Count);
Assert.IsNull(manifest.TraitCache);
// try to remove a second time.
removed = manifest.ExhibitsTraits.Remove(trait);
Assert.IsFalse(removed);
Assert.AreEqual(1, manifest.ExhibitsTraits.Count);
Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[0].ExplicitReference);
removed = manifest.ExhibitsTraits.Remove("Name of other Trait");
Assert.IsTrue(removed);
Assert.AreEqual(0, manifest.ExhibitsTraits.Count);
manifest.ExhibitsTraits.Add(trait);
Assert.AreEqual(1, manifest.ExhibitsTraits.Count);
removed = manifest.ExhibitsTraits.Remove(manifest.ExhibitsTraits[0]);
Assert.IsTrue(removed);
Assert.AreEqual(0, manifest.ExhibitsTraits.Count);
}
public void CdmTraitCollectionIndexOfOnlyFromProperty()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitDefinition(manifest.Ctx, "TraitName", null);
var otherTrait = new CdmTraitDefinition(manifest.Ctx, "Name of other Trait", null);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
Assert.AreEqual(false, manifest.ExhibitsTraits[0].IsFromProperty);
Assert.AreEqual(false, manifest.ExhibitsTraits[1].IsFromProperty);
var index = manifest.ExhibitsTraits.IndexOf(trait.TraitName, true);
Assert.AreEqual(-1, index);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
Assert.AreEqual(6, manifest.ExhibitsTraits.Count);
manifest.ExhibitsTraits[2].IsFromProperty = true;
index = manifest.ExhibitsTraits.IndexOf(trait.TraitName, true);
Assert.AreEqual(index, 2);
index = manifest.ExhibitsTraits.IndexOf(trait.TraitName);
Assert.AreEqual(index, 2);
}
public void CdmTraitCollectionRemoveTraitDefinitionPrioritizeFromProperty()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitDefinition(manifest.Ctx, "TraitName", null);
var otherTrait = new CdmTraitDefinition(manifest.Ctx, "Name of other Trait", null);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits[2].IsFromProperty = true;
manifest.ExhibitsTraits.Add(otherTrait);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits[4].IsFromProperty = true;
manifest.ExhibitsTraits.Add(otherTrait);
Assert.AreEqual(6, manifest.ExhibitsTraits.Count);
Assert.AreEqual(true, manifest.ExhibitsTraits[2].IsFromProperty);
var removed = manifest.ExhibitsTraits.Remove(trait);
Assert.AreEqual("TraitName", (manifest.ExhibitsTraits[0].ExplicitReference as CdmTraitDefinition).TraitName);
Assert.AreEqual("Name of other Trait", (manifest.ExhibitsTraits[2].ExplicitReference as CdmTraitDefinition).TraitName);
Assert.AreEqual("TraitName", (manifest.ExhibitsTraits[3].ExplicitReference as CdmTraitDefinition).TraitName);
}
public void TestCdmArgumentCollectionAddRange()
{
var trait = GenerateTrait();
trait.ResolvedArguments = true;
var argList = new List <CdmArgumentDefinition>();
var argumentDefinition = new CdmArgumentDefinition(null, null)
{
Name = "Arg1",
Value = 123
};
argList.Add(argumentDefinition);
var valOfArg2 = CdmCollectionHelperFunctions.GenerateManifest("C://Nothing");
argumentDefinition = new CdmArgumentDefinition(null, null)
{
Name = "Arg2",
Value = valOfArg2
};
argList.Add(argumentDefinition);
trait.Arguments.AddRange(argList);
Assert.AreEqual(2, trait.Arguments.Count);
Assert.AreEqual(false, trait.ResolvedArguments);
Assert.AreEqual("Arg1", trait.Arguments[0].Name);
Assert.AreEqual(123, trait.Arguments[0].Value);
Assert.AreEqual(trait, trait.Arguments[0].Owner);
Assert.AreEqual("Arg2", trait.Arguments[1].Name);
Assert.AreEqual(valOfArg2, trait.Arguments[1].Value);
}
public void TestCdmImportCollectionAddRange()
{
var document = CdmCollectionHelperFunctions.GenerateManifest();
document.IsDirty = false;
var importList = new List <CdmImport>()
{
new CdmImport(document.Ctx, "CorpusPath1", "Moniker1"),
new CdmImport(document.Ctx, "CorpusPath2", "Moniker2"),
new CdmImport(document.Ctx, "CorpusPath3", null),
};
document.Imports.AddRange(importList);
Assert.IsTrue(document.IsDirty);
Assert.AreEqual(3, document.Imports.Count);
Assert.AreEqual(importList[0], document.Imports[0]);
Assert.AreEqual(importList[1], document.Imports[1]);
Assert.AreEqual("CorpusPath1", document.Imports[0].CorpusPath);
Assert.AreEqual("Moniker1", document.Imports.Item("CorpusPath1", "Moniker1").Moniker);
Assert.AreEqual(document.Ctx, document.Imports.Item("CorpusPath1", "Moniker1").Ctx);
Assert.AreEqual("CorpusPath2", document.Imports[1].CorpusPath);
Assert.IsNull(document.Imports.Item("CorpusPath2"));
Assert.IsNotNull(document.Imports.Item("CorpusPath2", checkMoniker: false));
Assert.IsNull(document.Imports.Item("CorpusPath2", checkMoniker: true));
Assert.IsNotNull(document.Imports.Item("CorpusPath2", "Moniker2", true));
Assert.IsNotNull(document.Imports.Item("CorpusPath2", "Moniker3", false));
Assert.AreEqual("Moniker2", document.Imports.Item("CorpusPath2", "Moniker2").Moniker);
Assert.AreEqual(document.Ctx, document.Imports.Item("CorpusPath2", "Moniker2").Ctx);
Assert.AreEqual(importList[2], document.Imports.Item("CorpusPath3"));
}
public void CdmTraitCollectionIndexOf()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitDefinition(manifest.Ctx, "TraitName", null);
var otherTrait = new CdmTraitDefinition(manifest.Ctx, "Name of other Trait", null);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
int index = manifest.ExhibitsTraits.IndexOf(trait);
Assert.AreEqual(0, index);
index = manifest.ExhibitsTraits.IndexOf(otherTrait);
Assert.AreEqual(1, index);
index = manifest.ExhibitsTraits.IndexOf(manifest.ExhibitsTraits[0]);
Assert.AreEqual(0, index);
index = manifest.ExhibitsTraits.IndexOf(manifest.ExhibitsTraits[1]);
Assert.AreEqual(1, index);
index = manifest.ExhibitsTraits.IndexOf("TraitName");
Assert.AreEqual(0, index);
index = manifest.ExhibitsTraits.IndexOf("Name of other Trait");
Assert.AreEqual(1, index);
}
public void CdmTraitCollectionRemovePrioritizeFromProperty()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitReference(manifest.Ctx, "TraitName", false, false);
var otherTrait = new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
var traitCopyFromProperty = new CdmTraitReference(manifest.Ctx, "TraitName", false, false);
traitCopyFromProperty.IsFromProperty = true;
manifest.ExhibitsTraits.Add(traitCopyFromProperty);
Assert.AreEqual(false, trait.IsFromProperty);
Assert.AreEqual(false, otherTrait.IsFromProperty);
Assert.AreEqual(true, traitCopyFromProperty.IsFromProperty);
Assert.AreEqual(3, manifest.ExhibitsTraits.Count);
var removed = manifest.ExhibitsTraits.Remove("TraitName");
Assert.IsTrue(removed);
Assert.AreEqual(2, manifest.ExhibitsTraits.Count);
Assert.AreEqual(trait, manifest.ExhibitsTraits[0]);
Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[1]);
}
public void TestManifestCanAddEntityDefinition()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var entity = new CdmEntityDefinition(manifest.Ctx, "entityName", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(manifest.Ctx.Corpus, entity);
manifest.Entities.Add(entity);
Assert.AreEqual(1, manifest.Entities.Count);
Assert.AreEqual("entityName", entity.EntityName);
}
public void TestCdmDefinitionCollectionAddEntityByProvidingName()
{
var document = CdmCollectionHelperFunctions.GenerateManifest("C:\\Nothing");
document.IsDirty = false;
var entity = document.Definitions.Add("theNameOfTheEntity");
Assert.AreEqual(true, document.IsDirty);
Assert.AreEqual(entity, document.Definitions[0]);
Assert.AreEqual(document, entity.DocCreatedIn);
Assert.AreEqual(document, entity.Owner);
Assert.AreEqual("theNameOfTheEntity", entity.EntityName);
}
public void TestCdmImportCollectionAddCorpusPathAndMoniker()
{
var document = CdmCollectionHelperFunctions.GenerateManifest("C:\\Nothing");
document.IsDirty = false;
var import = document.Imports.Add("corpusPath", "moniker");
Assert.IsTrue(document.IsDirty);
Assert.AreEqual(1, document.Imports.Count);
Assert.AreEqual(import, document.Imports[0]);
Assert.AreEqual("corpusPath", import.CorpusPath);
Assert.AreEqual("moniker", import.Moniker);
Assert.AreEqual(document.Ctx, import.Ctx);
}
public void CdmTraitCollectionClear()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
new CdmTraitReference(manifest.Ctx, "TraitName", false, false);
new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false);
manifest.ExhibitsTraits.Add("trait1");
manifest.ExhibitsTraits.Add("trait2");
manifest.TraitCache = new Dictionary <string, ResolvedTraitSetBuilder>();
manifest.ExhibitsTraits.Clear();
Assert.AreEqual(0, manifest.ExhibitsTraits.Count);
Assert.IsNull(manifest.TraitCache);
}
public void TestFolderCollectionRemove()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var parentFolder = new CdmFolderDefinition(manifest.Ctx, "ParentFolder");
parentFolder.Namespace = "TheNamespace";
parentFolder.FolderPath = "ParentFolderPath/";
CdmFolderCollection childFolders = parentFolder.ChildFolders;
var childFolder = new CdmFolderDefinition(manifest.Ctx, "ChildFolder1");
Assert.AreEqual(0, childFolders.Count);
childFolders.Add(childFolder);
Assert.AreEqual(1, childFolders.Count);
childFolders.Remove(childFolder);
Assert.AreEqual(0, childFolders.Count);
}
public void TestCdmDefinitionCollectionAddByProvidingTypeAndName()
{
var document = CdmCollectionHelperFunctions.GenerateManifest("C:\\Nothing");
document.IsDirty = false;
var attribute = document.Definitions.Add(CdmObjectType.AttributeContextDef, "Name of attribute");
var trait = document.Definitions.Add(CdmObjectType.TraitDef, "Name of trait");
Assert.AreEqual(true, document.IsDirty);
Assert.AreEqual(attribute, document.Definitions[0]);
Assert.AreEqual(trait, document.Definitions[1]);
Assert.AreEqual(document, ((CdmObjectBase)attribute).DocCreatedIn);
Assert.AreEqual(document, attribute.Owner);
Assert.AreEqual(document, ((CdmObjectBase)trait).DocCreatedIn);
Assert.AreEqual(document, trait.Owner);
}
public void TestCdmCollectionAddPopulatesInDocumentWithVisit()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Nothing");
var entityReference = new CdmLocalEntityDeclarationDefinition(manifest.Ctx, "entityName");
var trait = entityReference.ExhibitsTraits.Add("theTrait");
var argument = trait.Arguments.Add("GreatArgumentName", "GreatValue");
manifest.Entities.Add(entityReference);
Assert.AreEqual(manifest, manifest.InDocument);
Assert.AreEqual(manifest, entityReference.InDocument);
Assert.AreEqual(manifest, trait.InDocument);
Assert.AreEqual(manifest, argument.InDocument);
}
public void TestCdmImportCollectionAdd()
{
var document = CdmCollectionHelperFunctions.GenerateManifest();
document.IsDirty = false;
Assert.AreEqual(false, document.IsDirty);
var import = new CdmImport(document.Ctx, "corpusPath", "moniker");
var addedImport = document.Imports.Add(import);
Assert.IsTrue(document.IsDirty);
Assert.AreEqual(1, document.Imports.Count);
Assert.AreEqual(import, addedImport);
Assert.AreEqual(import, document.Imports[0]);
Assert.AreEqual("corpusPath", import.CorpusPath);
Assert.AreEqual("moniker", import.Moniker);
Assert.AreEqual(document.Ctx, import.Ctx);
}
public void TestDocumentCollectionRemove()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var folder = new CdmFolderDefinition(manifest.Ctx, "Folder");
folder.Corpus = manifest.Ctx.Corpus;
folder.FolderPath = "FolderPath/";
folder.Namespace = "Namespace";
Assert.AreEqual(0, folder.Documents.Count);
var document = new CdmDocumentDefinition(manifest.Ctx, "DocumentName");
var document2 = new CdmDocumentDefinition(manifest.Ctx, "DocumentName2");
var documentList = new List <CdmDocumentDefinition> {
document, document2
};
folder.Documents.AddRange(documentList);
Assert.AreEqual(2, folder.Documents.Count);
Assert.AreEqual(document, folder.Documents[0]);
Assert.AreEqual(document2, folder.Documents[1]);
Assert.AreEqual(folder, document.Owner);
var removed = folder.Documents.Remove(document);
Assert.IsTrue(removed);
Assert.AreEqual(1, folder.Documents.Count);
Assert.AreEqual(document2, folder.Documents[0]);
Assert.IsNull(document.Owner);
removed = folder.Documents.Remove(document);
Assert.IsFalse(removed);
Assert.AreEqual(1, folder.Documents.Count);
Assert.AreEqual(document2, folder.Documents[0]);
folder.Documents.Add(document);
Assert.AreEqual(2, folder.Documents.Count);
Assert.AreEqual(folder, document.Owner);
removed = folder.Documents.Remove(document.Name);
Assert.AreEqual(1, folder.Documents.Count);
Assert.AreEqual(document2, folder.Documents[0]);
Assert.IsNull(document.Owner);
}
public void CdmTraitCollectionAddRange()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitDefinition(manifest.Ctx, "TraitName", null);
var otherTrait = new CdmTraitDefinition(manifest.Ctx, "Name of other Trait", null);
var traitList = new List <CdmTraitDefinition> {
trait, otherTrait
};
manifest.ExhibitsTraits.AddRange(traitList);
Assert.AreEqual(2, manifest.ExhibitsTraits.Count);
Assert.AreEqual(trait, manifest.ExhibitsTraits[0].ExplicitReference);
Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[1].ExplicitReference);
Assert.AreEqual(manifest, manifest.ExhibitsTraits[0].Owner);
}
public void TestCdmTraitCollectionInsert()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitReference(manifest.Ctx, "TraitName", false, false);
var otherTrait = new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false);
manifest.TraitCache = new Dictionary <string, ResolvedTraitSetBuilder>();
manifest.ExhibitsTraits.Insert(0, trait);
manifest.ExhibitsTraits.Insert(0, otherTrait);
Assert.IsNull(manifest.TraitCache);
Assert.AreEqual(2, manifest.ExhibitsTraits.Count);
Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[0]);
Assert.AreEqual(trait, manifest.ExhibitsTraits[1]);
Assert.AreEqual(manifest, manifest.ExhibitsTraits[0].Owner);
}
public void CdmTraitCollectionRemoveAt()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var trait = new CdmTraitDefinition(manifest.Ctx, "TraitName", null);
var otherTrait = new CdmTraitDefinition(manifest.Ctx, "Name of other Trait", null);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.Add(otherTrait);
manifest.ExhibitsTraits.Remove(trait);
Assert.IsNull(manifest.TraitCache);
manifest.ExhibitsTraits.Add(trait);
manifest.ExhibitsTraits.RemoveAt(1);
Assert.IsNull(manifest.TraitCache);
Assert.AreEqual(1, manifest.ExhibitsTraits.Count);
Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[0].ExplicitReference);
}
public void TestDocumentCollectionClear()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var folder = new CdmFolderDefinition(manifest.Ctx, "Folder");
folder.Corpus = manifest.Ctx.Corpus;
folder.FolderPath = "FolderPath/";
folder.Namespace = "Namespace";
var document = folder.Documents.Add("DocumentName");
var document2 = folder.Documents.Add("DocumentName2");
var document3 = folder.Documents.Add("DocumentName3");
folder.Documents.Clear();
Assert.AreEqual(0, folder.DocumentLookup.Count);
Assert.AreEqual(0, manifest.Ctx.Corpus.documentLibrary.ListAllDocuments().Count);
Assert.AreEqual(0, folder.Documents.Count);
}
public void TestManifestCanAddEntityDeclaration()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var entity = new CdmEntityDefinition(manifest.Ctx, "entityName", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(manifest.Ctx.Corpus, entity);
var entityDeclaration = manifest.Ctx.Corpus.MakeObject <CdmEntityDeclarationDefinition>(Enums.CdmObjectType.LocalEntityDeclarationDef, entity.EntityName, false);
entityDeclaration.EntityPath = $"{entity.Owner.AtCorpusPath}/{entity.EntityName}";
manifest.Entities.Add(entityDeclaration);
Assert.AreEqual("local:/entityName.cdm.json/entityName", entityDeclaration.EntityPath);
Assert.AreEqual("entityName", entityDeclaration.EntityName);
Assert.AreEqual(1, manifest.Entities.Count);
Assert.AreEqual(entityDeclaration, manifest.Entities[0]);
}
public void TestFolderCollectionAddWithNameParameter()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path");
var parentFolder = new CdmFolderDefinition(manifest.Ctx, "ParentFolder");
parentFolder.Namespace = "TheNamespace";
parentFolder.FolderPath = "ParentFolderPath/";
CdmFolderCollection childFolders = parentFolder.ChildFolders;
Assert.AreEqual(0, childFolders.Count);
var childFolder = childFolders.Add("ChildFolder1");
Assert.AreEqual(1, childFolders.Count);
Assert.AreEqual(childFolder, childFolders[0]);
Assert.AreEqual(manifest.Ctx, childFolder.Ctx);
Assert.AreEqual("ChildFolder1", childFolder.Name);
Assert.AreEqual(parentFolder, childFolder.Owner);
Assert.AreEqual("TheNamespace", childFolder.Namespace);
Assert.AreEqual(parentFolder.FolderPath + childFolder.Name + "/", childFolder.FolderPath);
}
