public void Cannot_create_property_of_invalid_type()
{
var rowType =
RowType.Create(
new[]
{
EdmProperty.Primitive("property", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))
},
null);
Assert.Equal(
Strings.EdmProperty_InvalidPropertyType(rowType.FullName),
Assert.Throws <ArgumentException>(() => EdmProperty.Create("invalidProperty", TypeUsage.Create(rowType))).Message);
}
public void Can_update_existing_facet_with_shallow_copy()
{
var typeUsage1 = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
Assert.Equal(5, typeUsage1.Facets.Count);
Assert.True((bool)typeUsage1.Facets["Nullable"].Value);
var typeUsage2 = typeUsage1.ShallowCopy(Facet.Create(MetadataItem.NullableFacetDescription, false));
Assert.Equal(5, typeUsage1.Facets.Count);
Assert.Equal(5, typeUsage2.Facets.Count);
Assert.True((bool)typeUsage1.Facets["Nullable"].Value);
Assert.False((bool)typeUsage2.Facets["Nullable"].Value);
}
public void Can_get_list_of_declared_properties()
{
var rowType = new RowType();
Assert.Empty(rowType.DeclaredProperties);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rowType.AddMember(property);
Assert.Equal(1, rowType.DeclaredProperties.Count);
rowType.RemoveMember(property);
}
[Fact] // Codeplex 1735
public void EdmAssociationType_ValidateReferentialConstraint_throws_if_types_of_related_properties_dont_match()
{
var principal = new EntityType(
"Principal", "N", DataSpace.CSpace,
new[] { "IdInt", "IdString" },
new EdmMember[]
{
new EdmProperty("IdInt", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))),
new EdmProperty("IdString", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)))
});
var dependent = new EntityType(
"Dependent", "N", DataSpace.CSpace,
new[] { "Id" },
new EdmMember[]
{
new EdmProperty("Id", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))),
new EdmProperty("IdString", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))),
new EdmProperty("IdInt", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)))
});
var associationType = new AssociationType("AT", "N", true, DataSpace.CSpace);
var fromRole = new AssociationEndMember("Principal", new RefType(principal), RelationshipMultiplicity.ZeroOrOne);
var toRole = new AssociationEndMember("Dependent", new RefType(dependent), RelationshipMultiplicity.Many);
associationType.Constraint = new ReferentialConstraint(
fromRole, toRole,
new[] { principal.Properties["IdString"], principal.Properties["IdInt"] },
new[] { dependent.Properties["IdString"], dependent.Properties["IdInt"] });
var validationContext
= new EdmModelValidationContext(new EdmModel(DataSpace.CSpace), true);
DataModelErrorEventArgs errorEventArgs = null;
validationContext.OnError += (_, e) => errorEventArgs = e;
EdmModelSemanticValidationRules
.EdmAssociationType_ValidateReferentialConstraint
.Evaluate(validationContext, associationType);
Assert.NotNull(errorEventArgs);
Assert.Equal(
Strings.EdmModel_Validator_Semantic_TypeMismatchRelationshipConstraint("IdString", "Dependent", "IdString", "Principal", "AT"),
errorEventArgs.ErrorMessage);
Assert.Same(associationType.Constraint, errorEventArgs.Item);
}
public void Can_get_and_set_name()
{
var function
= new FunctionParameter(
"P",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
ParameterMode.InOut);
Assert.Equal("P", function.Name);
function.Name = "Foo";
Assert.Equal("Foo", function.Name);
}
public void Create_throws_if_member_value_not_in_range_of_underlying_type()
{
var underlyingType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Byte);
var member = EnumMember.Create("M", Int32.MaxValue, null);
Assert.Equal(
new ArgumentException(
Strings.EnumMemberValueOutOfItsUnderylingTypeRange(
member.Value, member.Name, underlyingType.Name), "members")
.Message,
Assert.Throws <ArgumentException>(
() => EnumType.Create("EnumName", "N", underlyingType, true, new[] { member }, null))
.Message);
}
public void IsUnderlyingPrimitiveType_returns_true_when_underlying_primitive_property()
{
var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
var property = EdmProperty.Primitive("P", primitiveType);
Assert.True(property.IsUnderlyingPrimitiveType);
var enumType = new EnumType();
property = EdmProperty.Enum("P", enumType);
Assert.True(property.IsUnderlyingPrimitiveType);
}
internal static PrimitiveType GetSpatialNormalizedPrimitiveType(EdmType type)
{
PrimitiveType type1 = (PrimitiveType)type;
if (Helper.IsGeographicType(type1) && type1.PrimitiveTypeKind != PrimitiveTypeKind.Geography)
{
return(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geography));
}
if (Helper.IsGeometricType(type1) && type1.PrimitiveTypeKind != PrimitiveTypeKind.Geometry)
{
return(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geometry));
}
return(type1);
}
public void Attempt_to_add_member_of_wrong_DataSpace_to_StructuralType_throws_ArgumentException()
{
var ex1 = Assert.Throws <ArgumentException>(
() => new ComplexType("CT", "NS1", DataSpace.SSpace)
.AddMember(
new EdmProperty(
"p",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Byte)))));
Assert.True(ex1.Message.StartsWith(
Resources.Strings.AttemptToAddEdmMemberFromWrongDataSpace(
"p", "CT", DataSpace.CSpace, DataSpace.SSpace)));
Assert.Equal("member", ex1.ParamName);
}
public void Can_set_name_and_parent_notified()
{
var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
var property = EdmProperty.Primitive("P", primitiveType);
var entityTypeMock = new Mock <StructuralType>();
property.ChangeDeclaringTypeWithoutCollectionFixup(entityTypeMock.Object);
property.Name = "Foo";
entityTypeMock.Verify(e => e.NotifyItemIdentityChanged(), Times.Once());
}
public void EdmType_SystemNamespaceEncountered_not_triggered_for_Edm_primitive_types()
{
var validationContext
= new EdmModelValidationContext(new EdmModel(DataSpace.CSpace), true);
DataModelErrorEventArgs errorEventArgs = null;
validationContext.OnError += (_, e) => errorEventArgs = e;
EdmModelSemanticValidationRules
.EdmType_SystemNamespaceEncountered
.Evaluate(validationContext, PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Decimal));
Assert.Null(errorEventArgs);
}
private static Facet CreateConstFacet(string facetName, PrimitiveTypeKind facetTypeKind, object value)
{
return
(Facet.Create(
new FacetDescription(
facetName,
PrimitiveType.GetEdmPrimitiveType(facetTypeKind),
null,
null,
value,
true,
null),
value));
}
public void Nullable_CSpace_primitive_type_returned_for_non_nullable_SSpace_primitive_type()
{
var sSpaceTypeUsage =
FakeSqlProviderServices
.Instance.GetProviderManifest("2008")
.GetStoreType(TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)));
var cSpaceTypeUsage = sSpaceTypeUsage.ModelTypeUsage;
Assert.Equal(DataSpace.CSpace, cSpaceTypeUsage.EdmType.GetDataSpace());
Assert.Equal(
((PrimitiveType)sSpaceTypeUsage.EdmType).PrimitiveTypeKind,
((PrimitiveType)cSpaceTypeUsage.EdmType).PrimitiveTypeKind);
Assert.True((bool)sSpaceTypeUsage.Facets["Nullable"].Value);
}
public void IsUnicodeConstant_returns_true_for_const_Unicode_facet_and_value_cannot_be_changed()
{
var typeUsage =
TypeUsage.Create(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
new[] { CreateConstFacet("Unicode", PrimitiveTypeKind.Boolean, true) });
var property = new EdmProperty("P", typeUsage);
Assert.True(property.IsUnicodeConstant);
Assert.Equal(true, property.IsUnicode);
property.IsFixedLength = false;
Assert.Equal(true, property.IsUnicode);
}
public void IsMaxLengthConstant_returns_true_for_const_MaxLength_facet_and_value_cannot_be_changed()
{
var typeUsage =
TypeUsage.Create(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
new[] { CreateConstFacet("MaxLength", PrimitiveTypeKind.Int32, 200) });
var property = new EdmProperty("P", typeUsage);
Assert.True(property.IsMaxLengthConstant);
Assert.Equal(200, property.MaxLength);
property.MaxLength = 300;
Assert.Equal(200, property.MaxLength);
}
public void Create_throws_if_namespaceName_is_null_or_empty()
{
var underlyingType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
Assert.Equal(
Strings.ArgumentIsNullOrWhitespace("namespaceName"),
Assert.Throws <ArgumentException>(
() => EnumType.Create("EnumName", null, underlyingType, true, null, null))
.Message);
Assert.Equal(
Strings.ArgumentIsNullOrWhitespace("namespaceName"),
Assert.Throws <ArgumentException>(
() => EnumType.Create("EnumName", String.Empty, underlyingType, true, null, null))
.Message);
}
public void WriteFunctionImportReturnTypeAttributes_writes_Type_attribute_for_non_inline_definition()
{
var fixture = new Fixture();
var returnParameter =
new FunctionParameter(
"RetValue",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.ReturnValue);
fixture.Writer.WriteFunctionReturnTypeElementHeader();
fixture.Writer.WriteFunctionImportReturnTypeAttributes(returnParameter, null, false);
Assert.Equal("<ReturnType Type=\"Int32\"", fixture.ToString());
}
public void IsScaleConstant_returns_true_for_const_Scale_facet_and_value_cannot_be_changed()
{
var typeUsage =
TypeUsage.Create(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
new[] { CreateConstFacet("Scale", PrimitiveTypeKind.Byte, (byte)10) });
var property = new EdmProperty("P", typeUsage);
Assert.True(property.IsScaleConstant);
Assert.Equal(10, (byte)property.Scale);
property.Scale = 15;
Assert.Equal(10, (byte)property.Scale);
}
public void Add_is_implemented()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var metadataItem = new EntityType("E", "N", DataSpace.CSpace);
metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV"));
var count = metadataItem.MetadataProperties.Count;
var annotation = MetadataProperty.CreateAnnotation("AN", "AV");
metadataItem.Annotations.Add(annotation);
Assert.Same(annotation, metadataItem.MetadataProperties.ElementAt(count));
Assert.Same(annotation, metadataItem.Annotations.Single());
}
public void SetMetadataProperties_sets_metadata_properties()
{
var typeUsage =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var property = EdmProperty.Create("foo", typeUsage);
property.SetMetadataProperties(
new List <MetadataProperty>
{
MetadataProperty.Create(
"foo", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "bar")
});
Assert.NotNull(property.MetadataProperties.SingleOrDefault(p => p.Name == "foo" && (string)p.Value == "bar"));
}
public void Can_add_entity_set_to_container()
{
var entityContainer = new EntityContainer("Container", DataSpace.CSpace);
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var entitySet = EntitySet.Create("S", "dbo", "T", "Q", entityType, new[] { new MetadataProperty("P", typeUsage, "V") });
Assert.Equal(0, entityContainer.EntitySets.Count);
Assert.Null(entitySet.EntityContainer);
entityContainer.AddEntitySetBase(entitySet);
Assert.Equal(1, entityContainer.EntitySets.Count);
Assert.Same(entitySet, entityContainer.EntitySets.Single());
Assert.Same(entityContainer, entitySet.EntityContainer);
}
public void Can_remove_member()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
Assert.Empty(entityType.Members);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
Assert.Equal(1, entityType.Members.Count);
entityType.RemoveMember(property);
Assert.Empty(entityType.Members);
}
public void VisitFunctionReturnParameter_writes_return_and_collection_header_for_primitive_return_type()
{
var schemaWriterMock = new Mock <EdmXmlSchemaWriter>();
var returnParameter =
new FunctionParameter(
"r",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
ParameterMode.ReturnValue);
new EdmSerializationVisitor(schemaWriterMock.Object).VisitFunctionReturnParameter(returnParameter);
schemaWriterMock.Verify(sw => sw.WriteFunctionReturnTypeElementHeader(), Times.Never());
schemaWriterMock.Verify(sw => sw.WriteCollectionTypeElementHeader(), Times.Never());
schemaWriterMock.Verify(sw => sw.WriteRowTypeElementHeader(), Times.Never());
schemaWriterMock.Verify(sw => sw.WriteEndElement(), Times.Never());
}
public void EdmModel_NameIsNotAllowed_triggered_for_conceptual_property_with_period()
{
var property = EdmProperty.CreatePrimitive("Property.With.Dots", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var validationContext
= new EdmModelValidationContext(new EdmModel(DataSpace.CSpace), true);
DataModelErrorEventArgs errorEventArgs = null;
validationContext.OnError += (_, e) => errorEventArgs = e;
EdmModelSyntacticValidationRules
.EdmModel_NameIsNotAllowed
.Evaluate(validationContext, property);
Assert.NotNull(errorEventArgs);
}
public void Can_set_primitive_type_and_new_type_usage_is_create_with_facets()
{
var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String);
var property = EdmProperty.Primitive("P", primitiveType);
property.StoreGeneratedPattern = StoreGeneratedPattern.Computed;
property.ConcurrencyMode = ConcurrencyMode.Fixed;
property.MaxLength = 42;
property.PrimitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary);
Assert.Equal(StoreGeneratedPattern.Computed, property.StoreGeneratedPattern);
Assert.Equal(ConcurrencyMode.Fixed, property.ConcurrencyMode);
Assert.Equal(42, property.MaxLength);
}
public void WriteFunctionImportParameterElement_writes_full_element_with_attributes()
{
var fixture = new Fixture();
var functionImportParameter =
new FunctionParameter(
"miles",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.InOut);
fixture.Writer.WriteFunctionImportParameterElementHeader(functionImportParameter);
Assert.Equal(
"<Parameter Name=\"miles\" Mode=\"InOut\" Type=\"Int32\"",
fixture.ToString());
}
public void Count_is_implemented()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var metadataItem = new EntityType("E", "N", DataSpace.CSpace);
metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV"));
var count = metadataItem.MetadataProperties.Count;
Assert.Equal(0, metadataItem.Annotations.Count);
metadataItem.Annotations.Add(MetadataProperty.CreateAnnotation("AN", "AV"));
Assert.Equal(count + 1, metadataItem.MetadataProperties.Count);
Assert.Equal(1, metadataItem.Annotations.Count);
}
public void WriteFunctionParameterHeader_should_write_element_and_attributes()
{
var fixture = new Fixture();
var typeUsage
= TypeUsage.Create(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
new FacetValues
{
MaxLength = 123
});
var functionParameter
= new FunctionParameter(
"Foo",
typeUsage,
ParameterMode.In);
fixture.Writer.WriteFunctionParameterHeader(functionParameter);
Assert.Equal(
"<Parameter Name=\"Foo\" Type=\"String\" Mode=\"In\" MaxLength=\"123\"",
fixture.ToString());
fixture = new Fixture();
typeUsage
= TypeUsage.Create(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Decimal),
new FacetValues
{
Precision = (byte?)4,
Scale = (byte?)8
});
functionParameter
= new FunctionParameter(
"Foo",
typeUsage,
ParameterMode.In);
fixture.Writer.WriteFunctionParameterHeader(functionParameter);
Assert.Equal(
"<Parameter Name=\"Foo\" Type=\"Decimal\" Mode=\"In\" Precision=\"4\" Scale=\"8\"",
fixture.ToString());
}
public void WriteFunctionMapping_should_write_complex_parameter_bindings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet);
var storageModificationFunctionMapping
= new ModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
new[]
{
new ModificationFunctionParameterBinding(
new FunctionParameter(
"P",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
ParameterMode.In),
new ModificationFunctionMemberPath(
new[]
{
EdmProperty.CreateComplex("C1", new ComplexType()),
EdmProperty.CreateComplex("C2", new ComplexType()),
new EdmProperty("M")
},
null),
true)
},
null,
null);
fixture.Writer.WriteFunctionMapping("InsertFunction", storageModificationFunctionMapping);
Assert.Equal(
@"<InsertFunction FunctionName=""N.F"">
<ComplexProperty Name=""C1"" TypeName=""."">
<ComplexProperty Name=""C2"" TypeName=""."">
<ScalarProperty Name=""M"" ParameterName=""P"" Version=""Current"" />
</ComplexProperty>
</ComplexProperty>
</InsertFunction>",
fixture.ToString());
}
public void Declared_members_should_be_accessible_by_name()
{
var entityType =
EntityType.Create(
"Blog",
"BlogModel",
DataSpace.CSpace,
new[] { "Id", "Title" },
new[] {
EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
EdmProperty.CreatePrimitive("Title", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))
},
null);
Assert.NotNull(entityType.DeclaredMembers["Id"]);
Assert.NotNull(entityType.DeclaredMembers["Title"]);
}
