public static T FromData <T>(CdmCorpusContext ctx, CdmObjectType objectType, JToken obj)
where T : CdmOperationBase
{
if (obj == null)
{
return(default(T));
}
CdmOperationBase operation = ctx.Corpus.MakeObject <CdmOperationBase>(objectType);
CdmOperationType operationType = OperationTypeConvertor.FromObjectType(objectType);
if (obj["$type"] != null && !StringUtils.EqualsWithIgnoreCase(obj["$type"].ToString(), OperationTypeConvertor.OperationTypeToString(operationType)))
{
Logger.Error(ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistProjInvalidOpsType, obj["$type"].ToString());
}
else
{
operation.Type = operationType;
}
operation.Condition = obj["condition"]?.ToString();
operation.Explanation = obj["explanation"]?.ToString();
operation.SourceInput = (bool?)obj["sourceInput"];
return(operation as T);
}
/// <summary>
/// Constructs a CdmCollection.
/// </summary>
/// <param name="ctx">The context.</param>
/// <param name="owner">The owner of the collection.</param>
/// <param name="defaultType">The default type of the collection.</param>
public CdmCollection(CdmCorpusContext ctx, CdmObject owner, CdmObjectType defaultType)
{
this.Ctx = ctx;
this.AllItems = new List <T>();
this.DefaultType = defaultType;
this.Owner = owner;
}
/// <summary>
/// Instantiates a data object based on the object type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objectType"></param>
/// <returns></returns>
private static T MakeDataObject <T>(CdmObjectType objectType)
where T : OperationBase
{
switch (objectType)
{
case CdmObjectType.OperationAddAttributeGroupDef:
return(new OperationAddAttributeGroup() as T);
case CdmObjectType.OperationAddCountAttributeDef:
return(new OperationAddCountAttribute() as T);
case CdmObjectType.OperationAddSupportingAttributeDef:
return(new OperationAddSupportingAttribute() as T);
case CdmObjectType.OperationAddTypeAttributeDef:
return(new OperationAddTypeAttribute() as T);
case CdmObjectType.OperationArrayExpansionDef:
return(new OperationArrayExpansion() as T);
case CdmObjectType.OperationCombineAttributesDef:
return(new OperationCombineAttributes() as T);
case CdmObjectType.OperationExcludeAttributesDef:
return(new OperationExcludeAttributes() as T);
case CdmObjectType.OperationIncludeAttributesDef:
return(new OperationIncludeAttributes() as T);
case CdmObjectType.OperationRenameAttributesDef:
return(new OperationRenameAttributes() as T);
case CdmObjectType.OperationReplaceAsForeignKeyDef:
return(new OperationReplaceAsForeignKey() as T);
case CdmObjectType.OperationAlterTraitsDef:
return(new OperationAlterTraits() as T);
case CdmObjectType.OperationAddArtifactAttributeDef:
return(new OperationAddArtifactAttribute() as T);
}
return(null);
}
/// <summary>
/// Gets the operation type from the object type.
/// </summary>
/// <param name="objectType"></param>
/// <returns></returns>
internal static CdmOperationType FromObjectType(CdmObjectType objectType)
{
switch (objectType)
{
case CdmObjectType.OperationAddAttributeGroupDef:
return(CdmOperationType.AddAttributeGroup);
case CdmObjectType.OperationAddCountAttributeDef:
return(CdmOperationType.AddCountAttribute);
case CdmObjectType.OperationAddSupportingAttributeDef:
return(CdmOperationType.AddSupportingAttribute);
case CdmObjectType.OperationAddTypeAttributeDef:
return(CdmOperationType.AddTypeAttribute);
case CdmObjectType.OperationArrayExpansionDef:
return(CdmOperationType.ArrayExpansion);
case CdmObjectType.OperationCombineAttributesDef:
return(CdmOperationType.CombineAttributes);
case CdmObjectType.OperationAlterTraitsDef:
return(CdmOperationType.AlterTraits);
case CdmObjectType.OperationExcludeAttributesDef:
return(CdmOperationType.ExcludeAttributes);
case CdmObjectType.OperationIncludeAttributesDef:
return(CdmOperationType.IncludeAttributes);
case CdmObjectType.OperationRenameAttributesDef:
return(CdmOperationType.RenameAttributes);
case CdmObjectType.OperationReplaceAsForeignKeyDef:
return(CdmOperationType.ReplaceAsForeignKey);
case CdmObjectType.OperationAddArtifactAttributeDef:
return(CdmOperationType.AddArtifactAttribute);
default:
return(CdmOperationType.Error);
}
}
/// <summary>
/// Creates a <see cref="CdmObject"/> of the provided type, with the provided name and adds it to the collection.
/// </summary>
/// <param name="ofType">The type of the object to be created and added to the list.</param>
/// <param name="name">The name to be used for the created object.</param>
/// <returns>The created object after it was added to the collection.</returns>
public CdmObjectDefinition Add(CdmObjectType ofType, string name)
{
CdmObjectDefinition createdObject = this.Ctx.Corpus.MakeObject <CdmObjectDefinition>(ofType, name, false);
return(base.Add(createdObject));
}
public async Task TestProjectionUsingObjectModel()
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestProjectionUsingObjectModel");
corpus.Storage.Mount("local", new LocalAdapter(TestHelper.GetActualOutputFolderPath(testsSubpath, "TestProjectionUsingObjectModel")));
CdmFolderDefinition localRoot = corpus.Storage.FetchRootFolder("local");
CdmManifestDefinition manifestDefault = CreateDefaultManifest(corpus, localRoot);
CdmEntityDefinition entityTestSource = CreateEntityTestSource(corpus, manifestDefault, localRoot);
CdmEntityDefinition entityTestEntityProjection = CreateEntityTestEntityProjection(corpus, manifestDefault, localRoot);
CdmEntityDefinition entityTestEntityNestedProjection = CreateEntityTestEntityNestedProjection(corpus, manifestDefault, localRoot);
CdmEntityDefinition entityTestEntityAttributeProjection = CreateEntityTestEntityAttributeProjection(corpus, manifestDefault, localRoot);
CdmEntityDefinition entityTestOperationCollection = CreateEntityTestOperationCollection(corpus, manifestDefault, localRoot);
// Save manifest and entities
await manifestDefault.SaveAsAsync($"{manifestDefault.ManifestName}.manifest.cdm.json", saveReferenced : true);
string expected = "TestSource";
CdmObjectType expectedType = CdmObjectType.ProjectionDef;
string actual = null;
CdmObjectType actualType = CdmObjectType.Error;
// Try to read back the newly persisted manifest and projection based entities
CdmManifestDefinition manifestReadBack = await corpus.FetchObjectAsync <CdmManifestDefinition>($"local:/{manifestDefault.ManifestName}.manifest.cdm.json");
Assert.AreEqual(5, manifestReadBack.Entities.Count);
Assert.AreEqual(entityTestSource.EntityName, manifestReadBack.Entities[0].EntityName);
Assert.AreEqual(entityTestEntityProjection.EntityName, manifestReadBack.Entities[1].EntityName);
Assert.AreEqual(entityTestEntityNestedProjection.EntityName, manifestReadBack.Entities[2].EntityName);
Assert.AreEqual(entityTestEntityAttributeProjection.EntityName, manifestReadBack.Entities[3].EntityName);
// Read back the newly persisted manifest and projection based entity TestEntityProjection and validate
CdmEntityDefinition entityTestEntityProjectionReadBack = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityTestEntityProjection.EntityName}.cdm.json/{entityTestEntityProjection.EntityName}", manifestReadBack);
Assert.IsNotNull(entityTestEntityProjectionReadBack);
actual = ((CdmEntityReference)((CdmProjection)entityTestEntityProjectionReadBack.ExtendsEntity.ExplicitReference).Source).NamedReference;
actualType = ((CdmProjection)entityTestEntityProjectionReadBack.ExtendsEntity.ExplicitReference).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(expectedType, actualType);
// Read back the newly persisted manifest and projection based entity TestEntityNestedProjection and validate
CdmEntityDefinition entityTestEntityNestedProjectionReadBack = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityTestEntityNestedProjection.EntityName}.cdm.json/{entityTestEntityNestedProjection.EntityName}", manifestReadBack);
Assert.IsNotNull(entityTestEntityNestedProjectionReadBack);
actual = ((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)entityTestEntityNestedProjectionReadBack.ExtendsEntity).ExplicitReference).Source).ExplicitReference).Source).ExplicitReference).Source.NamedReference;
actualType = ((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)entityTestEntityNestedProjectionReadBack.ExtendsEntity).ExplicitReference).Source).ExplicitReference).Source).ExplicitReference).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(expectedType, actualType);
// Read back the newly persisted manifest and projection based entity TestEntityAttributeProjection and validate
CdmEntityDefinition entityTestEntityAttributeProjectionReadBack = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityTestEntityAttributeProjection.EntityName}.cdm.json/{entityTestEntityAttributeProjection.EntityName}", manifestReadBack);
Assert.IsNotNull(entityTestEntityAttributeProjectionReadBack);
actual = ((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmEntityAttributeDefinition)entityTestEntityAttributeProjectionReadBack.Attributes[0]).Entity).ExplicitReference).Source).NamedReference;
actualType = ((CdmProjection)((CdmEntityReference)((CdmEntityAttributeDefinition)entityTestEntityAttributeProjectionReadBack.Attributes[0]).Entity).ExplicitReference).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(expectedType, actualType);
// Read back operations collections and validate
CdmEntityDefinition entityTestOperationCollectionReadBack = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityTestOperationCollection.EntityName}.cdm.json/{entityTestOperationCollection.EntityName}", manifestReadBack);
Assert.IsNotNull(entityTestOperationCollectionReadBack);
int actualOperationCount = ((CdmProjection)entityTestOperationCollectionReadBack.ExtendsEntity.ExplicitReference).Operations.Count;
Assert.AreEqual(9, actualOperationCount);
CdmOperationCollection operations = ((CdmProjection)entityTestOperationCollectionReadBack.ExtendsEntity.ExplicitReference).Operations;
Assert.AreEqual(CdmOperationType.AddCountAttribute, operations[0].Type);
Assert.AreEqual(CdmOperationType.AddSupportingAttribute, operations[1].Type);
Assert.AreEqual(CdmOperationType.AddTypeAttribute, operations[2].Type);
Assert.AreEqual(CdmOperationType.ExcludeAttributes, operations[3].Type);
Assert.AreEqual(CdmOperationType.ArrayExpansion, operations[4].Type);
Assert.AreEqual(CdmOperationType.CombineAttributes, operations[5].Type);
Assert.AreEqual(CdmOperationType.RenameAttributes, operations[6].Type);
Assert.AreEqual(CdmOperationType.ReplaceAsForeignKey, operations[7].Type);
Assert.AreEqual(CdmOperationType.IncludeAttributes, operations[8].Type);
}
/// <summary>
/// Checks if the trait argumnet value matchs the data type defined on the trait parameter
/// </summary>
/// <param name="resOpt"></param>
/// <param name="wrtDoc"></param>
/// <param name="argumentValue"></param>
/// <returns></returns>
internal dynamic ConstTypeCheck(ResolveOptions resOpt, CdmDocumentDefinition wrtDoc, dynamic argumentValue)
{
ResolveContext ctx = this.Ctx as ResolveContext;
dynamic replacement = argumentValue;
// if parameter type is entity, then the value should be an entity or ref to one
// same is true of 'dataType' dataType
if (this.DataTypeRef == null)
{
return(replacement);
}
CdmDataTypeDefinition dt = this.DataTypeRef.FetchObjectDefinition <CdmDataTypeDefinition>(resOpt);
if (dt == null)
{
Logger.Error(ctx, Tag, nameof(ConstTypeCheck), this.AtCorpusPath, CdmLogCode.ErrUnrecognizedDataType, this.Name);
return(null);
}
// compare with passed in value or default for parameter
dynamic pValue = argumentValue;
if (pValue == null)
{
pValue = this.DefaultValue;
replacement = pValue;
}
if (pValue != null)
{
if (dt.IsDerivedFrom("cdmObject", resOpt))
{
List <CdmObjectType> expectedTypes = new List <CdmObjectType>();
string expected = null;
if (dt.IsDerivedFrom("entity", resOpt))
{
expectedTypes.Add(CdmObjectType.ConstantEntityDef);
expectedTypes.Add(CdmObjectType.EntityRef);
expectedTypes.Add(CdmObjectType.EntityDef);
expectedTypes.Add(CdmObjectType.ProjectionDef);
expected = "entity";
}
else if (dt.IsDerivedFrom("attribute", resOpt))
{
expectedTypes.Add(CdmObjectType.AttributeRef);
expectedTypes.Add(CdmObjectType.TypeAttributeDef);
expectedTypes.Add(CdmObjectType.EntityAttributeDef);
expected = "attribute";
}
else if (dt.IsDerivedFrom("dataType", resOpt))
{
expectedTypes.Add(CdmObjectType.DataTypeRef);
expectedTypes.Add(CdmObjectType.DataTypeDef);
expected = "dataType";
}
else if (dt.IsDerivedFrom("purpose", resOpt))
{
expectedTypes.Add(CdmObjectType.PurposeRef);
expectedTypes.Add(CdmObjectType.PurposeDef);
expected = "purpose";
}
else if (dt.IsDerivedFrom("traitGroup", resOpt))
{
expectedTypes.Add(CdmObjectType.TraitGroupRef);
expectedTypes.Add(CdmObjectType.TraitGroupDef);
expected = "traitGroup";
}
else if (dt.IsDerivedFrom("trait", resOpt))
{
expectedTypes.Add(CdmObjectType.TraitRef);
expectedTypes.Add(CdmObjectType.TraitDef);
expected = "trait";
}
else if (dt.IsDerivedFrom("attributeGroup", resOpt))
{
expectedTypes.Add(CdmObjectType.AttributeGroupRef);
expectedTypes.Add(CdmObjectType.AttributeGroupDef);
expected = "attributeGroup";
}
if (expectedTypes.Count == 0)
{
Logger.Error(ctx, Tag, nameof(ConstTypeCheck), wrtDoc.FolderPath + wrtDoc.Name, CdmLogCode.ErrUnexpectedDataType, this.Name);
}
// if a string constant, resolve to an object ref.
CdmObjectType foundType = CdmObjectType.Error;
Type pValueType = pValue.GetType();
if (typeof(CdmObject).IsAssignableFrom(pValueType))
{
foundType = (pValue as CdmObject).ObjectType;
}
string foundDesc = ctx.RelativePath;
if (!(pValue is CdmObject))
{
// pValue is a string or JValue
pValue = (string)pValue;
if (pValue == "this.attribute" && expected == "attribute")
{
// will get sorted out later when resolving traits
foundType = CdmObjectType.AttributeRef;
}
else
{
foundDesc = pValue;
int seekResAtt = CdmObjectReferenceBase.offsetAttributePromise(pValue);
if (seekResAtt >= 0)
{
// get an object there that will get resolved later after resolved attributes
replacement = new CdmAttributeReference(ctx, pValue, true);
(replacement as CdmAttributeReference).Ctx = ctx;
(replacement as CdmAttributeReference).InDocument = wrtDoc;
foundType = CdmObjectType.AttributeRef;
}
else
{
CdmObjectBase lu = ctx.Corpus.ResolveSymbolReference(resOpt, wrtDoc, pValue, CdmObjectType.Error, retry: true);
if (lu != null)
{
if (expected == "attribute")
{
replacement = new CdmAttributeReference(ctx, pValue, true);
(replacement as CdmAttributeReference).Ctx = ctx;
(replacement as CdmAttributeReference).InDocument = wrtDoc;
foundType = CdmObjectType.AttributeRef;
}
else
{
replacement = lu;
foundType = (replacement as CdmObject).ObjectType;
}
}
}
}
}
if (expectedTypes.IndexOf(foundType) == -1)
{
Logger.Error(ctx, Tag, nameof(ConstTypeCheck), wrtDoc.AtCorpusPath, CdmLogCode.ErrResolutionFailure, this.Name, expected, foundDesc, expected);
}
else
{
Logger.Info(ctx, Tag, nameof(ConstTypeCheck), wrtDoc.AtCorpusPath, $"resolved '{foundDesc}'");
}
}
}
return(replacement);
}
public async Task TestLoadProjection()
{
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestLoadProjection");
CdmManifestDefinition manifest = await corpus.FetchObjectAsync <CdmManifestDefinition>($"local:/default.manifest.cdm.json");
string expected = "TestSource";
string actual = null;
CdmObjectType actualType = CdmObjectType.Error;
#region TestEntityStringReference.cdm.json
CdmEntityDefinition entTestEntityStringReference = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityStringReference.cdm.json/TestEntityStringReference", manifest);
Assert.IsNotNull(entTestEntityStringReference);
actual = ((CdmEntityReference)entTestEntityStringReference.ExtendsEntity).NamedReference;
actualType = ((CdmEntityReference)entTestEntityStringReference.ExtendsEntity).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.EntityRef, actualType);
#endregion // TestEntityStringReference.cdm.json
#region TestEntityEntityReference.cdm.json
CdmEntityDefinition entTestEntityEntityReference = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityEntityReference.cdm.json/TestEntityEntityReference", manifest);
Assert.IsNotNull(entTestEntityEntityReference);
actual = ((CdmEntityReference)entTestEntityEntityReference.ExtendsEntity).NamedReference;
actualType = ((CdmEntityReference)entTestEntityEntityReference.ExtendsEntity).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.EntityRef, actualType);
#endregion // TestEntityEntityReference.cdm.json
#region TestEntityProjection.cdm.json
CdmEntityDefinition entTestEntityProjection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityProjection.cdm.json/TestEntityProjection", manifest);
Assert.IsNotNull(entTestEntityProjection);
actual = ((CdmEntityReference)((CdmProjection)entTestEntityProjection.ExtendsEntity.ExplicitReference).Source).NamedReference;
actualType = ((CdmProjection)entTestEntityProjection.ExtendsEntity.ExplicitReference).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.ProjectionDef, actualType);
#endregion // TestEntityProjection.cdm.json
#region TestEntityNestedProjection.cdm.json
CdmEntityDefinition entTestEntityNestedProjection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityNestedProjection.cdm.json/TestEntityNestedProjection", manifest);
Assert.IsNotNull(entTestEntityNestedProjection);
actual = ((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)entTestEntityNestedProjection.ExtendsEntity).ExplicitReference).Source).ExplicitReference).Source).ExplicitReference).Source.NamedReference;
actualType = ((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)entTestEntityNestedProjection.ExtendsEntity).ExplicitReference).Source).ExplicitReference).Source).ExplicitReference).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.ProjectionDef, actualType);
#endregion // TestEntityNestedProjection.cdm.json
#region TestEntityAttributeStringReference.cdm.json
CdmEntityDefinition entTestEntityAttributeStringReference = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityAttributeStringReference.cdm.json/TestEntityAttributeStringReference", manifest);
Assert.IsNotNull(entTestEntityAttributeStringReference);
actual = ((CdmEntityAttributeDefinition)entTestEntityAttributeStringReference.Attributes[0]).Entity.NamedReference;
actualType = ((CdmEntityAttributeDefinition)entTestEntityAttributeStringReference.Attributes[0]).Entity.ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.EntityRef, actualType);
#endregion // TestEntityAttributeStringReference.cdm.json
#region TestEntityAttributeEntityReference.cdm.json
CdmEntityDefinition entTestEntityAttributeEntityReference = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityAttributeEntityReference.cdm.json/TestEntityAttributeEntityReference", manifest);
Assert.IsNotNull(entTestEntityAttributeEntityReference);
actual = ((CdmEntityAttributeDefinition)entTestEntityAttributeEntityReference.Attributes[0]).Entity.NamedReference;
actualType = ((CdmEntityAttributeDefinition)entTestEntityAttributeEntityReference.Attributes[0]).Entity.ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.EntityRef, actualType);
#endregion // TestEntityAttributeEntityReference.cdm.json
#region TestEntityAttributeProjection.cdm.json
CdmEntityDefinition entTestEntityAttributeProjection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityAttributeProjection.cdm.json/TestEntityAttributeProjection", manifest);
Assert.IsNotNull(entTestEntityAttributeProjection);
actual = ((CdmProjection)((CdmEntityAttributeDefinition)entTestEntityAttributeProjection.Attributes[0]).Entity.ExplicitReference).Source.NamedReference;
actualType = ((CdmEntityAttributeDefinition)entTestEntityAttributeProjection.Attributes[0]).Entity.ExplicitReference.ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.ProjectionDef, actualType);
#endregion // TestEntityAttributeProjection.cdm.json
#region TestEntityAttributeNestedProjection.cdm.json
CdmEntityDefinition entTestEntityAttributeNestedProjection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityAttributeNestedProjection.cdm.json/TestEntityAttributeNestedProjection", manifest);
Assert.IsNotNull(entTestEntityAttributeNestedProjection);
actual = ((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmEntityAttributeDefinition)entTestEntityAttributeNestedProjection.Attributes[0]).Entity).ExplicitReference).Source).ExplicitReference).Source).ExplicitReference).Source.NamedReference;
actualType = ((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmProjection)((CdmEntityReference)((CdmEntityAttributeDefinition)entTestEntityAttributeNestedProjection.Attributes[0]).Entity).ExplicitReference).Source).ExplicitReference).Source).ExplicitReference).ObjectType;
Assert.AreEqual(expected, actual);
Assert.AreEqual(CdmObjectType.ProjectionDef, actualType);
#endregion // TestEntityAttributeNestedProjection.cdm.json
#region TestOperationCollection.cdm.json
CdmEntityDefinition entTestOperationCollection = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestOperationCollection.cdm.json/TestOperationCollection", manifest);
Assert.IsNotNull(entTestOperationCollection);
int actualOperationCount = ((CdmProjection)entTestOperationCollection.ExtendsEntity.ExplicitReference).Operations.Count;
Assert.AreEqual(9, actualOperationCount);
CdmOperationCollection operations = ((CdmProjection)entTestOperationCollection.ExtendsEntity.ExplicitReference).Operations;
Assert.AreEqual(CdmOperationType.AddCountAttribute, operations[0].Type);
Assert.AreEqual(CdmOperationType.AddSupportingAttribute, operations[1].Type);
Assert.AreEqual(CdmOperationType.AddTypeAttribute, operations[2].Type);
Assert.AreEqual(CdmOperationType.ExcludeAttributes, operations[3].Type);
Assert.AreEqual(CdmOperationType.ArrayExpansion, operations[4].Type);
Assert.AreEqual(CdmOperationType.CombineAttributes, operations[5].Type);
Assert.AreEqual(CdmOperationType.RenameAttributes, operations[6].Type);
Assert.AreEqual(CdmOperationType.ReplaceAsForeignKey, operations[7].Type);
Assert.AreEqual(CdmOperationType.IncludeAttributes, operations[8].Type);
#endregion // TestOperationCollection.cdm.json
#region TestEntityTrait.cdm.json
CdmEntityDefinition entTestEntityTrait = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityTrait.cdm.json/TestEntityTrait", manifest);
Assert.IsNotNull(entTestEntityTrait);
Assert.AreEqual("TestAttribute", ((CdmTypeAttributeDefinition)entTestEntityTrait.Attributes[0]).Name);
Assert.AreEqual("testDataType", ((CdmTypeAttributeDefinition)entTestEntityTrait.Attributes[0]).DataType.NamedReference);
#endregion // TestEntityTrait.cdm.json
#region TestEntityExtendsTrait.cdm.json
CdmEntityDefinition entTestEntityExtendsTrait = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestEntityExtendsTrait.cdm.json/TestEntityExtendsTrait", manifest);
Assert.IsNotNull(entTestEntityExtendsTrait);
Assert.AreEqual("TestExtendsTraitAttribute", ((CdmTypeAttributeDefinition)entTestEntityExtendsTrait.Attributes[0]).Name);
Assert.AreEqual("testDerivedDataType", ((CdmTypeAttributeDefinition)entTestEntityExtendsTrait.Attributes[0]).DataType.NamedReference);
#endregion // TestEntityExtendsTrait.cdm.json
#region TestProjectionTrait.cdm.json
CdmEntityDefinition entTestProjectionTrait = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestProjectionTrait.cdm.json/TestProjectionTrait", manifest);
Assert.IsNotNull(entTestProjectionTrait);
Assert.AreEqual("TestProjectionAttribute", ((CdmTypeAttributeDefinition)entTestProjectionTrait.Attributes[0]).Name);
Assert.AreEqual("testDataType", ((CdmTypeAttributeDefinition)entTestProjectionTrait.Attributes[0]).DataType.NamedReference);
#endregion // TestProjectionTrait.cdm.json
#region TestProjectionExtendsTrait.cdm.json
CdmEntityDefinition entTestProjectionExtendsTrait = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/TestProjectionExtendsTrait.cdm.json/TestProjectionExtendsTrait", manifest);
Assert.IsNotNull(entTestProjectionExtendsTrait);
Assert.AreEqual("TestProjectionAttributeB", ((CdmTypeAttributeDefinition)entTestProjectionExtendsTrait.Attributes[0]).Name);
Assert.AreEqual("testExtendsDataTypeB", ((CdmTypeAttributeDefinition)entTestProjectionExtendsTrait.Attributes[0]).DataType.NamedReference);
#endregion // TestProjectionExtendsTrait.cdm.json
}
