public EntityTypeBuilder WithMetadataProperty <T>(string name, object value)
{
this.metadataProperties.Add(
MetadataProperty.Create(name, this.typeUsageFactory.Create <T>(), value));
return(this);
}
public void CloneWithDefiningQuery_does_not_creat_schema_and_table_extended_attributes_if_they_are_null()
{
var property =
EdmProperty.CreatePrimitive(
"Id",
ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32));
var customMetadataProperty =
MetadataProperty.Create(
"http://tempUri:myProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value");
var entityType =
EntityType.Create("EntityType", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property }, null);
var entitySet = EntitySet.Create("EntityTypeSet", null, null, null, entityType, new[] { customMetadataProperty });
var clonedEntitySet = EntitySetDefiningQueryConverter.CloneWithDefiningQuery(entitySet, "definingQuery");
Assert.Null(clonedEntitySet.Schema);
Assert.Null(clonedEntitySet.Table);
Assert.False(entitySet.MetadataProperties.Any(p => p.Name.EndsWith(StoreSchemaAttributeNamespace + ":Schema")));
Assert.False(entitySet.MetadataProperties.Any(p => p.Name.EndsWith(StoreSchemaAttributeNamespace + ":Name")));
}
private static EntityType CreateEntityTypeWithExtendedProperty(XNamespace copyToSSDLNamespace, string copyToSSDLValue)
{
var extendedPropertyContents =
new XElement(
(XNamespace)"http://myExtendedProperties" + "MyProp",
new XAttribute(
(XNamespace)"http://myExtendedProperties" + "MyAttribute", "MyValue"),
new XAttribute(
copyToSSDLNamespace + "CopyToSSDL", copyToSSDLValue));
var extendedPropertyMetadataProperty =
MetadataProperty.Create(
"http://myExtendedProperties:MyProp",
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
true,
false),
extendedPropertyContents
);
return(EntityType.Create(
"TestEntityType",
"Model1",
DataSpace.CSpace,
new[] { "Id" },
new[] { EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)) },
new[] { extendedPropertyMetadataProperty }));
}
public void CollectStoreModelErrors_returns_errors_on_model_items()
{
var edmSchemaError = new EdmSchemaError("msg", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List <EdmSchemaError> {
edmSchemaError
});
var entityType =
EntityType.Create(
"foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0],
new[] { errorMetadataProperty });
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(entityType);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Equal(1, schemaErrors.Count);
Assert.Same(edmSchemaError, schemaErrors.Single());
}
private static void EdmSerializationVisitor_writes_expected_xml <T>(
Func <T> constructor,
bool invalid,
Action <EdmSerializationVisitor, T> visitAction,
string expectedFormat)
where T : MetadataItem
{
var errors = new List <EdmSchemaError>()
{
new EdmSchemaError("Message1.", 1, EdmSchemaErrorSeverity.Error),
new EdmSchemaError("Message2.", 2, EdmSchemaErrorSeverity.Warning)
};
var typeUsage1 = TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean));
var property1 = MetadataProperty.Create(
MetadataItemHelper.SchemaInvalidMetadataPropertyName, typeUsage1, invalid);
var typeUsage2 = TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType());
var property2 = MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName, typeUsage2, errors);
var item = constructor();
item.AddMetadataProperties(new List <MetadataProperty>()
{
property1, property2
});
var builder = new StringBuilder();
var settings = new XmlWriterSettings {
ConformanceLevel = ConformanceLevel.Fragment
};
using (var writer = XmlWriter.Create(builder, settings))
{
visitAction(new EdmSerializationVisitor(writer, 3.0), item);
}
var errorsString = String.Concat(
Strings.MetadataItemErrorsFoundDuringGeneration,
errors[0].ToString(),
errors[1].ToString());
var expectedXml = String.Format(
CultureInfo.InvariantCulture,
expectedFormat,
errorsString);
AssertEqual(expectedXml, builder.ToString());
}
private static MetadataProperty CreateAnnotationMetadataProperty(string name, string value)
{
return
(MetadataProperty.Create(
string.Format(
CultureInfo.InvariantCulture,
"{0}:{1}",
SchemaManager.AnnotationNamespace,
name),
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
isUnicode: false,
isFixedLength: false),
value));
}
public void GenerateModel_combines_store_model_and_mapping_errors()
{
var storeModelError = new EdmSchemaError("storeError", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List <EdmSchemaError> {
storeModelError
});
var entityType =
EntityType.Create(
"foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0],
new[] { errorMetadataProperty });
var storeModel = new EdmModel(DataSpace.SSpace);
storeModel.AddItem(entityType);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(
storeModel.Containers.Single(),
EntityContainer.Create("C", DataSpace.CSpace, null, null, null));
mappingContext.Errors.Add(new EdmSchemaError("mappingError", 911, EdmSchemaErrorSeverity.Warning));
var mockModelGenerator = new Mock <ModelGenerator>(new ModelBuilderSettings(), "storeNamespace");
mockModelGenerator
.Setup(g => g.CreateStoreModel())
.Returns(() => storeModel);
mockModelGenerator
.Setup(g => g.CreateMappingContext(It.IsAny <EdmModel>()))
.Returns(() => mappingContext);
var errors = new List <EdmSchemaError>();
mockModelGenerator.Object.GenerateModel(errors);
Assert.Equal(new[] { storeModelError, mappingContext.Errors.Single() }, errors);
}
public void CollectStoreModelErrors_returns_errors_from_function_return_rowtypes()
{
var edmSchemaError = new EdmSchemaError("msg", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List <EdmSchemaError> {
edmSchemaError
});
var rowType = RowType.Create(new EdmProperty[0], new[] { errorMetadataProperty });
var function =
EdmFunction.Create(
"foo",
"bar",
DataSpace.SSpace,
new EdmFunctionPayload
{
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
rowType,
ParameterMode.ReturnValue)
}
},
null);
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(function);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Equal(1, schemaErrors.Count);
Assert.Same(edmSchemaError, schemaErrors.Single());
}
public void Validation_error_not_reported_for_types_marked_as_invalid()
{
var invalidAttribute =
MetadataProperty.Create(
"EdmSchemaInvalid",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
true);
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(
EntityType.Create("E", "N", DataSpace.SSpace, new string[0], new EdmMember[0], new[] { invalidAttribute }));
using (var writer = XmlWriter.Create(new StringBuilder()))
{
var ssdlSerializer = new SsdlSerializer();
ssdlSerializer.OnError += (_, e) => { throw new Exception("Should not be invoked."); };
Assert.True(ssdlSerializer.Serialize(model, "N", "invName", "42", writer));
}
}
public void CloneWithDefiningQuery_creates_new_equivalent_entity_set_but_with_defining_query()
{
var property =
EdmProperty.CreatePrimitive(
"Id",
ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32));
var customMetadataProperty =
MetadataProperty.Create(
"http://tempUri:myProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value");
var entityType =
EntityType.Create("EntityType", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property }, null);
var entitySet = EntitySet.Create("EntityTypeSet", "dbo", "EntityTypes", null, entityType, new[] { customMetadataProperty });
var clonedEntitySet = EntitySetDefiningQueryConverter.CloneWithDefiningQuery(entitySet, "definingQuery");
Assert.NotNull(clonedEntitySet);
Assert.NotSame(clonedEntitySet, entitySet);
Assert.Same(entitySet.Name, clonedEntitySet.Name);
Assert.Same(entitySet.ElementType, clonedEntitySet.ElementType);
Assert.Null(clonedEntitySet.Schema);
Assert.Null(clonedEntitySet.Table);
Assert.Equal(
entitySet.Schema,
clonedEntitySet.MetadataProperties.Single(p => p.Name == StoreSchemaAttributeNamespace + ":Schema")
.Value);
Assert.Equal(
entitySet.Table,
clonedEntitySet.MetadataProperties.Single(p => p.Name == StoreSchemaAttributeNamespace + ":Name")
.Value);
Assert.Equal(
entitySet.MetadataProperties.Single(p => p.Name == "http://tempUri:myProperty").Value,
clonedEntitySet.MetadataProperties.Single(p => p.Name == "http://tempUri:myProperty").Value);
}
