/// <summary>
/// The factory method for constructing the EntityType object.
/// </summary>
/// <param name="name">The name of the entity type.</param>
/// <param name="namespaceName">The namespace of the entity type.</param>
/// <param name="dataSpace">The dataspace in which the EntityType belongs to.</param>
/// <param name="baseType">The base type.</param>
/// <param name="keyMemberNames">Name of key members for the type.</param>
/// <param name="members">Members of the entity type (primitive and navigation properties).</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <returns>The EntityType object.</returns>
/// <exception cref="System.ArgumentException">Thrown if either name, namespace arguments are null.</exception>
/// <remarks>The newly created EntityType will be read only.</remarks>
public static EntityType Create(
string name,
string namespaceName,
DataSpace dataSpace,
EntityType baseType,
IEnumerable <string> keyMemberNames,
IEnumerable <EdmMember> members,
IEnumerable <MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, "name");
Check.NotEmpty(namespaceName, "namespaceName");
Check.NotNull(baseType, "baseType");
var entity = new EntityType(name, namespaceName, dataSpace, keyMemberNames, members)
{
BaseType = baseType
};
if (metadataProperties != null)
{
entity.AddMetadataProperties(metadataProperties);
}
entity.SetReadOnly();
return(entity);
}
public void Returns_rows_affected_when_there_is_a_reader()
{
var mockPrimitiveType = new Mock<PrimitiveType>();
mockPrimitiveType.Setup(m => m.BuiltInTypeKind).Returns(BuiltInTypeKind.PrimitiveType);
mockPrimitiveType.Setup(m => m.PrimitiveTypeKind).Returns(PrimitiveTypeKind.Int32);
mockPrimitiveType.Setup(m => m.DataSpace).Returns(DataSpace.CSpace);
string memberName = "property";
var edmProperty = new EdmProperty(memberName, TypeUsage.Create(mockPrimitiveType.Object));
var entityType = new EntityType("", "", DataSpace.CSpace, Enumerable.Empty<string>(), new[] { edmProperty });
entityType.SetReadOnly();
var mockUpdateTranslator = new Mock<UpdateTranslator>(MockBehavior.Strict);
mockUpdateTranslator.Setup(m => m.CommandTimeout).Returns(() => null);
var entityConnection = new Mock<EntityConnection>().Object;
mockUpdateTranslator.Setup(m => m.Connection).Returns(entityConnection);
var mockDbModificationCommandTree = new Mock<DbModificationCommandTree>();
mockDbModificationCommandTree.SetupGet(m => m.HasReader).Returns(true);
var mockDynamicUpdateCommand = new Mock<DynamicUpdateCommand>(new Mock<TableChangeProcessor>().Object, mockUpdateTranslator.Object,
ModificationOperator.Delete, PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value: 0),
PropagatorResult.CreateStructuralValue(new[] { PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value: 0) },
entityType,
isModified: false),
mockDbModificationCommandTree.Object, /*outputIdentifiers*/ null)
{
CallBase = true
};
var mockDbCommand = new Mock<DbCommand>();
int dbValue = 66;
var mockDbDataReader = new Mock<DbDataReader>();
mockDbDataReader.Setup(m => m.GetValue(It.IsAny<int>())).Returns(dbValue);
int rowsToRead = 2;
mockDbDataReader.Setup(m => m.Read()).Returns(() =>
{
rowsToRead--;
return rowsToRead > 0;
});
mockDbDataReader.Setup(m => m.FieldCount).Returns(1);
mockDbDataReader.Setup(m => m.GetName(0)).Returns(memberName);
mockDbCommand.Protected().Setup<DbDataReader>("ExecuteDbDataReader", CommandBehavior.SequentialAccess).Returns(mockDbDataReader.Object);
var identifierValues = new Dictionary<int, object>();
mockDynamicUpdateCommand.Protected().Setup<DbCommand>("CreateCommand", identifierValues).Returns(mockDbCommand.Object);
var generatedValues = new List<KeyValuePair<PropagatorResult, object>>();
var rowsAffectedResult = mockDynamicUpdateCommand.Object.Execute(identifierValues, generatedValues);
Assert.Equal(1, rowsAffectedResult);
Assert.Equal(1, generatedValues.Count);
Assert.Equal(dbValue, generatedValues[0].Value);
Assert.Equal(0, generatedValues[0].Key.GetSimpleValue());
}
public void IsReadOnly_is_implemented()
{
var metadataItem = new EntityType("E", "N", DataSpace.CSpace);
Assert.False(metadataItem.Annotations.IsReadOnly);
metadataItem.SetReadOnly();
Assert.True(metadataItem.Annotations.IsReadOnly);
}
public void Properties_collection_is_live_until_entity_goes_readonly()
{
var entityType = new EntityType();
Assert.False(entityType.IsReadOnly);
Assert.NotSame(entityType.Properties, entityType.Properties);
entityType.SetReadOnly();
Assert.Same(entityType.Properties, entityType.Properties);
}
public void Properties_collection_is_live_until_entity_goes_readonly()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
Assert.False(entityType.IsReadOnly);
Assert.NotSame(entityType.Properties, entityType.Properties);
entityType.SetReadOnly();
Assert.Same(entityType.Properties, entityType.Properties);
}
public void AddAnnotation_throws_if_metadata_item_is_readonly()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var value = new object();
entityType.SetReadOnly();
Assert.Equal(
Strings.OperationOnReadOnlyCollection,
Assert.Throws <InvalidOperationException>(() => entityType.AddAnnotation("name", value))
.Message);
}
public void Setting_annotation_value_throws_if_metadata_item_is_readonly()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var value1 = new object();
var value2 = new object();
entityType.AddAnnotation("name", value1);
entityType.SetReadOnly();
Assert.Equal(
Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(() => entityType.Annotations.Single().Value = value2)
.Message);
}
public void Setting_annotation_value_throws_if_metadata_item_is_readonly()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var value1 = new object();
var value2 = new object();
entityType.AddAnnotation("name", value1);
entityType.SetReadOnly();
Assert.Equal(
Strings.OperationOnReadOnlyItem,
Assert.Throws<InvalidOperationException>(() => entityType.Annotations.Single().Value = value2)
.Message);
}
/// <summary>
/// The factory method for constructing the EntityType object.
/// </summary>
/// <param name="name">The name of the entity type.</param>
/// <param name="namespaceName">The namespace of the entity type.</param>
/// <param name="dataSpace">The dataspace in which the EntityType belongs to.</param>
/// <param name="keyMemberNames">Name of key members for the type.</param>
/// <param name="members">Members of the entity type (primitive and navigation properties).</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <returns>The EntityType object.</returns>
/// <exception cref="T:System.ArgumentException">Thrown if either name, namespace arguments are null.</exception>
/// <remarks>The newly created EntityType will be read only.</remarks>
public static EntityType Create(
string name,
string namespaceName,
DataSpace dataSpace,
IEnumerable <string> keyMemberNames,
IEnumerable <EdmMember> members,
IEnumerable <MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, nameof(name));
Check.NotEmpty(namespaceName, nameof(namespaceName));
EntityType entityType = new EntityType(name, namespaceName, dataSpace, keyMemberNames, members);
if (metadataProperties != null)
{
entityType.AddMetadataProperties(metadataProperties.ToList <MetadataProperty>());
}
entityType.SetReadOnly();
return(entityType);
}
public static void Adding_a_NavigationProperty_to_an_EntityType_can_be_forced_when_read_only()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace);
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var navigationProperty =
NavigationProperty.Create(
"NavigationProperty",
typeUsage,
associationType,
sourceEnd,
targetEnd,
null);
source.SetReadOnly();
Assert.True(source.IsReadOnly);
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(
() => source.AddMember(navigationProperty)).Message);
Assert.Equal(0, source.Members.Count);
source.AddNavigationProperty(navigationProperty);
Assert.True(source.IsReadOnly);
Assert.Equal(1, source.Members.Count);
Assert.Same(navigationProperty, source.Members[0]);
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(
() => source.AddMember(navigationProperty)).Message);
}
public static void Adding_a_NavigationProperty_to_an_EntityType_can_be_forced_when_read_only()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace);
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var navigationProperty =
NavigationProperty.Create(
"NavigationProperty",
typeUsage,
associationType,
sourceEnd,
targetEnd);
source.SetReadOnly();
Assert.True(source.IsReadOnly);
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws<InvalidOperationException>(
() => source.AddMember(navigationProperty)).Message);
Assert.Equal(0, source.Members.Count);
source.AddNavigationProperty(navigationProperty);
Assert.True(source.IsReadOnly);
Assert.Equal(1, source.Members.Count);
Assert.Same(navigationProperty, source.Members[0]);
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws<InvalidOperationException>(
() => source.AddMember(navigationProperty)).Message);
}
/// <summary>
/// The factory method for constructing the EntityType object.
/// </summary>
/// <param name="name">The name of the entity type.</param>
/// <param name="namespaceName">The namespace of the entity type.</param>
/// <param name="dataSpace">The dataspace in which the EntityType belongs to.</param>
/// <param name="keyMemberNames">Name of key members for the type.</param>
/// <param name="members">Members of the entity type (primitive and navigation properties).</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <exception cref="System.ArgumentException">Thrown if either name, namespace arguments are null.</exception>
/// <notes>The newly created EntityType will be read only.</notes>
public static EntityType Create(
string name,
string namespaceName,
DataSpace dataSpace,
IEnumerable<string> keyMemberNames,
IEnumerable<EdmMember> members,
IEnumerable<MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, "name");
Check.NotEmpty(namespaceName, "namespaceName");
var entity = new EntityType(name, namespaceName, dataSpace, keyMemberNames, members);
if (metadataProperties != null)
{
entity.AddMetadataProperties(metadataProperties.ToList());
}
entity.SetReadOnly();
return entity;
}
public void Returns_rows_affected_when_there_are_result_columns()
{
var mockPrimitiveType = new Mock<PrimitiveType>();
mockPrimitiveType.Setup(m => m.BuiltInTypeKind).Returns(BuiltInTypeKind.PrimitiveType);
mockPrimitiveType.Setup(m => m.PrimitiveTypeKind).Returns(PrimitiveTypeKind.Int32);
mockPrimitiveType.Setup(m => m.DataSpace).Returns(DataSpace.CSpace);
var edmProperty = new EdmProperty("property", TypeUsage.Create(mockPrimitiveType.Object));
var entityType = new EntityType("", "", DataSpace.CSpace, Enumerable.Empty<string>(), new[] { edmProperty });
entityType.SetReadOnly();
var stateEntry = new ExtractedStateEntry(
EntityState.Unchanged,
PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value: 0),
PropagatorResult.CreateStructuralValue(
new[] { PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value: 0) },
entityType,
isModified: false),
new Mock<IEntityStateEntry>().Object);
var updateTranslatorMock = new Mock<UpdateTranslator>();
updateTranslatorMock.Setup(m => m.CommandTimeout).Returns(() => null);
var entityConnection = new Mock<EntityConnection>().Object;
updateTranslatorMock.Setup(m => m.Connection).Returns(entityConnection);
updateTranslatorMock.Setup(m => m.InterceptionContext).Returns(new DbInterceptionContext());
var dbCommandMock = new Mock<DbCommand>();
var stateEntries = new ReadOnlyCollection<IEntityStateEntry>(new List<IEntityStateEntry>());
var mockFunctionUpdateCommand = new Mock<FunctionUpdateCommand>(
updateTranslatorMock.Object, stateEntries, stateEntry, dbCommandMock.Object)
{
CallBase = true
};
var dbValue = 66;
var dbDataReaderMock = new Mock<DbDataReader>();
dbDataReaderMock.Setup(m => m.GetValue(It.IsAny<int>())).Returns(dbValue);
var rowsToRead = 2;
dbDataReaderMock.Setup(m => m.Read()).Returns(
() =>
{
rowsToRead--;
return rowsToRead > 0;
});
dbCommandMock.Protected().Setup<DbDataReader>("ExecuteDbDataReader", CommandBehavior.SequentialAccess).Returns(
dbDataReaderMock.Object);
var timesSetInputIdentifiers = 0;
var identifierValues = new Dictionary<int, object>();
mockFunctionUpdateCommand.Setup(m => m.SetInputIdentifiers(It.IsAny<Dictionary<int, object>>()))
.Callback<Dictionary<int, object>>(
identifierValuesPassed =>
{
timesSetInputIdentifiers++;
Assert.Same(identifierValues, identifierValuesPassed);
});
var generatedValues = new List<KeyValuePair<PropagatorResult, object>>();
var mockObjectStateManager = new Mock<ObjectStateManager>();
var objectStateEntryMock = new Mock<ObjectStateEntry>(mockObjectStateManager.Object, null, EntityState.Unchanged);
var currentValueRecordMock = new Mock<CurrentValueRecord>(objectStateEntryMock.Object);
var idColumn = new KeyValuePair<string, PropagatorResult>(
"ID",
PropagatorResult.CreateServerGenSimpleValue(
PropagatorFlags.NoFlags, /*value:*/ 0, currentValueRecordMock.Object, recordOrdinal: 0));
mockFunctionUpdateCommand.Protected().Setup<List<KeyValuePair<string, PropagatorResult>>>("ResultColumns")
.Returns((new[] { idColumn }).ToList());
var rowsAffectedResult = mockFunctionUpdateCommand.Object.Execute(identifierValues, generatedValues);
Assert.Equal(1, rowsAffectedResult);
Assert.Equal(1, timesSetInputIdentifiers);
Assert.Equal(1, generatedValues.Count);
Assert.Same(idColumn.Value, generatedValues[0].Key);
Assert.Equal(dbValue, generatedValues[0].Value);
}
public void AddAnnotation_throws_if_metadata_item_is_readonly()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var value = new object();
entityType.SetReadOnly();
Assert.Equal(
Strings.OperationOnReadOnlyCollection,
Assert.Throws<InvalidOperationException>(() => entityType.AddAnnotation("name", value))
.Message);
}
