private static EntityContainer ConvertToEntityContainer(
System.Data.Entity.Core.SchemaObjectModel.EntityContainer element,
DbProviderManifest providerManifest,
Converter.ConversionCache convertedItemCache,
Dictionary <SchemaElement, GlobalItem> newGlobalItems)
{
EntityContainer entityContainer = new EntityContainer(element.Name, Converter.GetDataSpace(providerManifest));
newGlobalItems.Add((SchemaElement)element, (GlobalItem)entityContainer);
foreach (EntityContainerEntitySet entitySet in element.EntitySets)
{
entityContainer.AddEntitySetBase((EntitySetBase)Converter.ConvertToEntitySet(entitySet, providerManifest, convertedItemCache, newGlobalItems));
}
foreach (EntityContainerRelationshipSet relationshipSet in element.RelationshipSets)
{
entityContainer.AddEntitySetBase((EntitySetBase)Converter.ConvertToAssociationSet(relationshipSet, providerManifest, convertedItemCache, entityContainer, newGlobalItems));
}
foreach (System.Data.Entity.Core.SchemaObjectModel.Function functionImport in element.FunctionImports)
{
entityContainer.AddFunctionImport(Converter.ConvertToFunction(functionImport, providerManifest, convertedItemCache, entityContainer, newGlobalItems));
}
if (element.Documentation != null)
{
entityContainer.Documentation = Converter.ConvertToDocumentation(element.Documentation);
}
Converter.AddOtherContent((SchemaElement)element, (MetadataItem)entityContainer);
return(entityContainer);
}
public void AssociationSets_and_EntitySets_are_thread_safe()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
entityContainer.AddEntitySetBase(new AssociationSet("A", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)));
entityContainer.AddEntitySetBase(new EntitySet("E", null, null, null, new EntityType("E", "N", DataSpace.CSpace)));
const int cycles = 200;
const int threadCount = 30;
Action readAssociationSets = () =>
{
for (var i = 0; i < cycles; ++i)
{
var associationSets = entityContainer.AssociationSets;
//touching BaseEntitySets.Source triggers a reset to AssociationSets
var sourceCount = entityContainer.BaseEntitySets.Source.Count;
Assert.True(sourceCount == 1);
var associationSetsAfterReset = entityContainer.AssociationSets;
Assert.True(associationSets != null, "First reference to AssociationSets should not be null");
Assert.True(associationSetsAfterReset != null, "Second reference to AssociationSets should not be null");
Assert.False(ReferenceEquals(associationSets, associationSetsAfterReset), "The AssociationSets instances should be different");
}
};
Action readEntitySets = () =>
{
for (var i = 0; i < cycles; ++i)
{
var entitySets = entityContainer.EntitySets;
//touching BaseEntitySets.Source triggers a reset to EntitySets
var sourceCount = entityContainer.BaseEntitySets.Source.Count;
Assert.True(sourceCount == 1);
var entitySetsAfterReset = entityContainer.EntitySets;
Assert.True(entitySets != null, "First reference to EntitySets should not be null");
Assert.True(entitySetsAfterReset != null, "Second reference to EntitySets should not be null");
Assert.False(ReferenceEquals(entitySets, entitySetsAfterReset), "The EntitySets instances should be different");
}
};
var tasks = new List <Thread>();
for (var i = 0; i < (threadCount / 2); ++i)
{
tasks.Add(new Thread(new ThreadStart(readEntitySets)));
tasks.Add(new Thread(new ThreadStart(readAssociationSets)));
}
tasks.ForEach(t => t.Start());
tasks.ForEach(t => t.Join());
}
public void StoreSchemaGen_attributes_written_using_store_namespace_prefix_and_without_namespace_declaration_on_the_element()
{
var entityType = new EntityType("MyEntity", "Model", DataSpace.SSpace);
var entitySet = new EntitySet("Entities", null, "Entities", null, entityType);
entitySet.AddMetadataProperties(
CreateMetadataProperties(
new[] { new KeyValuePair <string, string>(XmlConstants.EntityStoreSchemaGeneratorNamespace + ":property", "value") }));
var container = new EntityContainer("Container.Store", DataSpace.SSpace);
container.AddEntitySetBase(entitySet);
var model = EdmModel.CreateStoreModel(container, null, null);
var sb = new StringBuilder();
using (var writer = XmlWriter.Create(sb))
{
new EdmSerializationVisitor(writer, 3.0).Visit(model, "ns", "A", "b");
}
Assert.Contains(
"<EntitySet Name=\"Entities\" EntityType=\"Self.MyEntity\" Table=\"Entities\" store:property=\"value\" />",
sb.ToString());
}
/// <summary>
/// The factory method for constructing the EntityContainer object.
/// </summary>
/// <param name="name">The name of the entity container to be created.</param>
/// <param name="dataSpace">DataSpace in which this entity container belongs to.</param>
/// <param name="entitySets">Entity sets that will be included in the new container. Can be null.</param>
/// <param name="functionImports">Functions that will be included in the new container. Can be null.</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <returns>The EntityContainer object.</returns>
/// <exception cref="T:System.ArgumentException">Thrown if the name argument is null or empty string.</exception>
/// <remarks>The newly created EntityContainer will be read only.</remarks>
public static EntityContainer Create(
string name,
DataSpace dataSpace,
IEnumerable <EntitySetBase> entitySets,
IEnumerable <EdmFunction> functionImports,
IEnumerable <MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, nameof(name));
EntityContainer entityContainer = new EntityContainer(name, dataSpace);
if (entitySets != null)
{
foreach (EntitySetBase entitySet in entitySets)
{
entityContainer.AddEntitySetBase(entitySet);
}
}
if (functionImports != null)
{
foreach (EdmFunction functionImport in functionImports)
{
if (!functionImport.IsFunctionImport)
{
throw new ArgumentException(Strings.OnlyFunctionImportsCanBeAddedToEntityContainer((object)functionImport.Name));
}
entityContainer.AddFunctionImport(functionImport);
}
}
if (metadataProperties != null)
{
entityContainer.AddMetadataProperties(metadataProperties.ToList <MetadataProperty>());
}
entityContainer.SetReadOnly();
return(entityContainer);
}
public void WriteMappingFragment_should_write_store_entity_set_name()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new EntitySetMapping(
entitySet,
new EntityContainerMapping(entityContainer));
TypeMapping typeMapping = new EntityTypeMapping(storageEntitySetMapping);
var mappingFragment = new MappingFragment(entitySet, typeMapping, false);
fixture.Writer.WriteMappingFragmentElement(mappingFragment);
Assert.Equal(
@"<MappingFragment StoreEntitySet=""ES"" />",
fixture.ToString());
}
public void Can_clear_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Equal(1, entitySetMapping.ModificationFunctionMappings.Count());
entitySetMapping.ClearModificationFunctionMappings();
Assert.Equal(0, entitySetMapping.ModificationFunctionMappings.Count());
}
public void WriteMappingFragment_should_write_store_entity_set_name()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new EntitySetMapping(
entitySet,
new EntityContainerMapping(entityContainer));
TypeMapping typeMapping = new EntityTypeMapping(storageEntitySetMapping);
var mappingFragment = new MappingFragment(entitySet, typeMapping, false);
fixture.Writer.WriteMappingFragmentElement(mappingFragment);
Assert.Equal(
@"<MappingFragment StoreEntitySet=""ES"" />",
fixture.ToString());
}
public void Can_get_collection_of_association_sets()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
entityContainer.AddEntitySetBase(new AssociationSet("A", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)));
Assert.Equal(1, entityContainer.AssociationSets.Count);
Assert.Empty(entityContainer.EntitySets);
}
public void Can_get_collection_of_association_sets()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
entityContainer.AddEntitySetBase(new AssociationSet("A", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)));
Assert.Equal(1, entityContainer.AssociationSets.Count);
Assert.Empty(entityContainer.EntitySets);
}
public void Can_get_collection_of_entity_sets()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
entityContainer.AddEntitySetBase(new EntitySet("E", null, null, null, new EntityType("E", "N", DataSpace.CSpace)));
Assert.Equal(1, entityContainer.EntitySets.Count);
Assert.Empty(entityContainer.AssociationSets);
}
public void Can_get_collection_of_entity_sets()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
entityContainer.AddEntitySetBase(new EntitySet("E", null, null, null, new EntityType()));
Assert.Equal(1, entityContainer.EntitySets.Count);
Assert.Empty(entityContainer.AssociationSets);
}
public void Cannot_add_entity_set_to_readonly_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") });
entityContainer.SetReadOnly();
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(() => entityContainer.AddEntitySetBase(entitySet)).Message);
}
public void Can_remove_set_from_container()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
var associationSet = new AssociationSet("A", new AssociationType());
entityContainer.AddEntitySetBase(associationSet);
Assert.Equal(1, entityContainer.AssociationSets.Count);
entityContainer.RemoveEntitySetBase(associationSet);
Assert.Empty(entityContainer.AssociationSets);
Assert.Null(associationSet.EntityContainer);
}
public void Can_remove_set_from_container()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
var associationSet = new AssociationSet("A", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace));
entityContainer.AddEntitySetBase(associationSet);
Assert.Equal(1, entityContainer.AssociationSets.Count);
entityContainer.RemoveEntitySetBase(associationSet);
Assert.Empty(entityContainer.AssociationSets);
Assert.Null(associationSet.EntityContainer);
}
public void Visit_should_not_write_store_schema_generator_namespace_on_Schema_if_entity_sets_do_not_use_it()
{
var entityType = new EntityType("MyEntity", "Model", DataSpace.SSpace);
var entitySet = new EntitySet("Entities", null, "Entities", null, entityType);
var container = new EntityContainer("Container.Store", DataSpace.SSpace);
container.AddEntitySetBase(entitySet);
var model = EdmModel.CreateStoreModel(container, null, null);
var schemaWriterMock = new Mock <EdmXmlSchemaWriter>();
new EdmSerializationVisitor(schemaWriterMock.Object).Visit(model, "fakeProvider", "42");
schemaWriterMock.Verify(sw => sw.WriteSchemaElementHeader(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), true), Times.Never());
schemaWriterMock.Verify(sw => sw.WriteSchemaElementHeader(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), false), Times.Once());
}
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 WriteEntitySetMappingElement_should_write_modification_function_mappings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new EntitySetMapping(
entitySet,
new EntityContainerMapping(entityContainer));
var storageModificationFunctionMapping
= new ModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty <ModificationFunctionParameterBinding>(),
null,
null);
storageEntitySetMapping.AddModificationFunctionMapping(
new EntityTypeModificationFunctionMapping(
entityType,
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping));
fixture.Writer.WriteEntitySetMappingElement(storageEntitySetMapping);
Assert.Equal(
@"<EntitySetMapping Name=""ES"">
<EntityTypeMapping TypeName="".E"">
<ModificationFunctionMapping>
<InsertFunction FunctionName=""N.F"" />
<UpdateFunction FunctionName=""N.F"" />
<DeleteFunction FunctionName=""N.F"" />
</ModificationFunctionMapping>
</EntityTypeMapping>
</EntitySetMapping>",
fixture.ToString());
}
public void WriteEntitySetMappingElement_should_write_modification_function_mappings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new EntitySetMapping(
entitySet,
new EntityContainerMapping(entityContainer));
var storageModificationFunctionMapping
= new ModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty<ModificationFunctionParameterBinding>(),
null,
null);
storageEntitySetMapping.AddModificationFunctionMapping(
new EntityTypeModificationFunctionMapping(
entityType,
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping));
fixture.Writer.WriteEntitySetMappingElement(storageEntitySetMapping);
Assert.Equal(
@"<EntitySetMapping Name=""ES"">
<EntityTypeMapping TypeName="".E"">
<ModificationFunctionMapping>
<InsertFunction FunctionName=""N.F"" />
<UpdateFunction FunctionName=""N.F"" />
<DeleteFunction FunctionName=""N.F"" />
</ModificationFunctionMapping>
</EntityTypeMapping>
</EntitySetMapping>",
fixture.ToString());
}
public void Can_get_rows_affected_parameter_name()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out),
null);
Assert.Equal("rows_affected", storageModificationFunctionMapping.RowsAffectedParameterName);
}
public void Can_add_association_set_to_container()
{
var entityContainer = new EntityContainer("Container", DataSpace.CSpace);
var associationType
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)),
TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace))
};
var associationSet = new AssociationSet("A", associationType);
Assert.Equal(0, entityContainer.EntitySets.Count);
Assert.Null(associationSet.EntityContainer);
entityContainer.AddEntitySetBase(associationSet);
Assert.Equal(1, entityContainer.AssociationSets.Count);
Assert.Same(associationSet, entityContainer.AssociationSets.Single());
Assert.Same(entityContainer, associationSet.EntityContainer);
}
public void Can_retrieve_properties()
{
var entityType = new EntityType("ET", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", "T", "Q", entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var parameterBindings
= new[]
{
new ModificationFunctionParameterBinding(
new FunctionParameter(),
new ModificationFunctionMemberPath(Enumerable.Empty<EdmMember>(), null),
true)
};
var rowsAffectedParameter = new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out);
var resultBindings
= new[]
{
new ModificationFunctionResultBinding(
"C",
EdmProperty.CreatePrimitive(
"P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)))
};
var mapping
= new ModificationFunctionMapping(
entitySet, entityType, function,
parameterBindings, rowsAffectedParameter, resultBindings);
Assert.Same(rowsAffectedParameter, mapping.RowsAffectedParameter);
Assert.Same(function, mapping.Function);
Assert.Equal(parameterBindings, mapping.ParameterBindings);
Assert.Equal(resultBindings, mapping.ResultBindings);
}
public void Can_add_association_set_to_container()
{
var entityContainer = new EntityContainer("Container", DataSpace.CSpace);
var associationType
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)),
TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace))
};
var associationSet = new AssociationSet("A", associationType);
Assert.Equal(0, entityContainer.EntitySets.Count);
Assert.Null(associationSet.EntityContainer);
entityContainer.AddEntitySetBase(associationSet);
Assert.Equal(1, entityContainer.AssociationSets.Count);
Assert.Same(associationSet, entityContainer.AssociationSets.Single());
Assert.Same(entityContainer, associationSet.EntityContainer);
}
public void SetReadOnly_is_called_on_child_mapping_items()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new EntitySetMapping(
entitySet,
new EntityContainerMapping(container));
var functionMapping =
new ModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<ModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMapping =
new EntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMapping);
var entityTypeMapping = new EntityTypeMapping(entitySetMapping);
entitySetMapping.AddTypeMapping(entityTypeMapping);
Assert.False(entityTypeMapping.IsReadOnly);
Assert.False(entityFunctionMapping.IsReadOnly);
entitySetMapping.SetReadOnly();
Assert.True(entityTypeMapping.IsReadOnly);
Assert.True(entityFunctionMapping.IsReadOnly);
}
/// <summary>
/// Converts an entity container from SOM to metadata
/// </summary>
/// <param name="element">The SOM element to process</param>
/// <param name="providerManifest">The provider manifest to be used for conversion</param>
/// <param name="convertedItemCache">The item collection for currently existing metadata objects</param>
/// <param name="newGlobalItems">The new GlobalItem objects that are created as a result of this conversion</param>
/// <returns>The entity container object resulting from the convert</returns>
private static EntityContainer ConvertToEntityContainer(
Som.EntityContainer element,
DbProviderManifest providerManifest,
ConversionCache convertedItemCache,
Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems)
{
// Creating a new entity container object and populate with converted entity set objects
var entityContainer = new EntityContainer(element.Name, GetDataSpace(providerManifest));
newGlobalItems.Add(element, entityContainer);
foreach (var entitySet in element.EntitySets)
{
entityContainer.AddEntitySetBase(
ConvertToEntitySet(
entitySet,
providerManifest,
convertedItemCache,
newGlobalItems));
}
// Populate with converted relationship set objects
foreach (var relationshipSet in element.RelationshipSets)
{
Debug.Assert(
relationshipSet.Relationship.RelationshipKind == RelationshipKind.Association,
"We do not support containment set");
entityContainer.AddEntitySetBase(
ConvertToAssociationSet(
relationshipSet,
providerManifest,
convertedItemCache,
entityContainer,
newGlobalItems));
}
// Populate with converted function imports
foreach (var functionImport in element.FunctionImports)
{
entityContainer.AddFunctionImport(
ConvertToFunction(
functionImport,
providerManifest, convertedItemCache, entityContainer, newGlobalItems));
}
// Extract the optional Documentation
if (element.Documentation != null)
{
entityContainer.Documentation = ConvertToDocumentation(element.Documentation);
}
AddOtherContent(element, entityContainer);
return entityContainer;
}
private static void SetupMocksForTableChecking(
Mock<DbCommand> dbCommandMock, Mock<DbConnection> connectionMock, Mock<InternalContext> internalContextMock)
{
var dataReader = Core.Common.Internal.Materialization.MockHelper.CreateDbDataReader();
dbCommandMock.Protected().Setup<DbParameter>("CreateDbParameter")
.Returns(new Mock<DbParameter>().Object);
dbCommandMock.Protected().Setup<DbParameterCollection>("DbParameterCollection")
.Returns(new Mock<DbParameterCollection>().Object);
dbCommandMock.Setup(m => m.ExecuteScalar()).Returns(0);
dbCommandMock.Protected().Setup<DbDataReader>(
"ExecuteDbDataReader", It.IsAny<CommandBehavior>())
.Returns(dataReader);
connectionMock.Protected().Setup<DbCommand>("CreateDbCommand").Returns(dbCommandMock.Object);
connectionMock.Setup(m => m.ConnectionString).Returns("FakeConnection");
connectionMock.Setup(m => m.DataSource).Returns("Foo");
connectionMock.Protected().Setup<DbProviderFactory>("DbProviderFactory").Returns(SqlClientFactory.Instance);
var entityType = new EntityType(
"FakeEntityType", "FakeNamespace", DataSpace.CSpace, new[] { "key" }, new EdmMember[] { new EdmProperty("key") });
var entitySet = new EntitySet("FakeSet", "FakeSchema", "FakeTable", null, entityType);
var entityContainer = new EntityContainer("C", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var mockObjectContext = Core.Objects.MockHelper.CreateMockObjectContext<object>();
var storeItemCollectionMock =
Mock.Get((StoreItemCollection)mockObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.SSpace));
storeItemCollectionMock
.Setup(m => m.GetItems<EntityContainer>())
.Returns(
new ReadOnlyCollection<EntityContainer>(
new List<EntityContainer>
{
entityContainer
}));
var clonedObjectContextMock = new Mock<ClonedObjectContext>();
clonedObjectContextMock.Setup(m => m.Connection).Returns(connectionMock.Object);
clonedObjectContextMock.Setup(m => m.ObjectContext).Returns(new ObjectContextProxy(mockObjectContext));
internalContextMock.Setup(m => m.CodeFirstModel).Returns(new DbCompiledModel());
internalContextMock.Setup(m => m.ProviderName).Returns("System.Data.SqlClient");
internalContextMock.Setup(m => m.ObjectContext).Returns(mockObjectContext);
internalContextMock.Setup(m => m.CreateObjectContextForDdlOps()).Returns(clonedObjectContextMock.Object);
}
public void SetReadOnly_is_called_on_child_mapping_items()
{
var entityType = new EntityType("ET", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", "T", "Q", entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var parameterBindings
= new[]
{
new ModificationFunctionParameterBinding(
new FunctionParameter(),
new ModificationFunctionMemberPath(Enumerable.Empty<EdmMember>(), null),
true)
};
var rowsAffectedParameter = new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out);
var resultBindings
= new[]
{
new ModificationFunctionResultBinding(
"C",
EdmProperty.CreatePrimitive(
"P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)))
};
var mapping
= new ModificationFunctionMapping(
entitySet, entityType, function,
parameterBindings, rowsAffectedParameter, resultBindings);
Assert.False(mapping.IsReadOnly);
parameterBindings.Each(b => Assert.False(b.IsReadOnly));
resultBindings.Each(b => Assert.False(b.IsReadOnly));
mapping.SetReadOnly();
Assert.True(mapping.IsReadOnly);
parameterBindings.Each(b => Assert.True(b.IsReadOnly));
resultBindings.Each(b => Assert.True(b.IsReadOnly));
}
/// <summary>
/// The factory method for constructing the EntityContainer object.
/// </summary>
/// <param name="name">The name of the entity container to be created.</param>
/// <param name="dataSpace">DataSpace in which this entity container belongs to.</param>
/// <param name="entitySets">Entity sets that will be included in the new container. Can be null.</param>
/// <param name="functionImports">Functions that will be included in the new container. Can be null.</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <returns>The EntityContainer object.</returns>
/// <exception cref="System.ArgumentException">Thrown if the name argument is null or empty string.</exception>
/// <remarks>The newly created EntityContainer will be read only.</remarks>
public static EntityContainer Create(
string name, DataSpace dataSpace, IEnumerable<EntitySetBase> entitySets,
IEnumerable<EdmFunction> functionImports, IEnumerable<MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, "name");
var entityContainer = new EntityContainer(name, dataSpace);
if (entitySets != null)
{
foreach (var entitySet in entitySets)
{
entityContainer.AddEntitySetBase(entitySet);
}
}
if (functionImports != null)
{
foreach (var function in functionImports)
{
if (!function.IsFunctionImport)
{
throw new ArgumentException(Strings.OnlyFunctionImportsCanBeAddedToEntityContainer(function.Name));
}
entityContainer.AddFunctionImport(function);
}
}
if (metadataProperties != null)
{
entityContainer.AddMetadataProperties(metadataProperties.ToList());
}
entityContainer.SetReadOnly();
return entityContainer;
}
public void AssociationSets_and_EntitySets_are_thread_safe()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
entityContainer.AddEntitySetBase(new AssociationSet("A", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)));
entityContainer.AddEntitySetBase(new EntitySet("E", null, null, null, new EntityType("E", "N", DataSpace.CSpace)));
const int cycles = 200;
const int threadCount = 30;
Action readAssociationSets = () =>
{
for (var i = 0; i < cycles; ++i)
{
var associationSets = entityContainer.AssociationSets;
//touching BaseEntitySets.Source triggers a reset to AssociationSets
var sourceCount = entityContainer.BaseEntitySets.Source.Count;
Assert.True(sourceCount == 1);
var associationSetsAfterReset = entityContainer.AssociationSets;
Assert.True(associationSets != null, "First reference to AssociationSets should not be null");
Assert.True(associationSetsAfterReset != null, "Second reference to AssociationSets should not be null");
Assert.False(ReferenceEquals(associationSets, associationSetsAfterReset), "The AssociationSets instances should be different");
}
};
Action readEntitySets = () =>
{
for (var i = 0; i < cycles; ++i)
{
var entitySets = entityContainer.EntitySets;
//touching BaseEntitySets.Source triggers a reset to EntitySets
var sourceCount = entityContainer.BaseEntitySets.Source.Count;
Assert.True(sourceCount == 1);
var entitySetsAfterReset = entityContainer.EntitySets;
Assert.True(entitySets != null, "First reference to EntitySets should not be null");
Assert.True(entitySetsAfterReset != null, "Second reference to EntitySets should not be null");
Assert.False(ReferenceEquals(entitySets, entitySetsAfterReset), "The EntitySets instances should be different");
}
};
var tasks = new List<Thread>();
for (var i = 0; i < (threadCount/2); ++i)
{
tasks.Add(new Thread(new ThreadStart(readEntitySets)));
tasks.Add(new Thread(new ThreadStart(readAssociationSets)));
}
tasks.ForEach(t => t.Start());
tasks.ForEach(t => t.Join());
}
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_get_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Same(entityFunctionMappings, entitySetMapping.ModificationFunctionMappings.Single());
}
public void Executes_in_a_transaction_using_ExecutionStrategy()
{
var shaperMock = MockHelper.CreateShaperMock<object>();
shaperMock.Setup(m => m.GetEnumerator()).Returns(
() => new DbEnumeratorShim<object>(((IEnumerable<object>)new[] { new object() }).GetEnumerator()));
var objectResultMock = new Mock<ObjectResult<object>>(shaperMock.Object, null, null)
{
CallBase = true
};
var entityType = new EntityType(
"FakeEntityType", "FakeNamespace", DataSpace.CSpace, new[] { "key" }, new EdmMember[] { new EdmProperty("key") });
var entitySet = new EntitySet("FakeSet", "FakeSchema", "FakeTable", null, entityType);
var entityContainer = new EntityContainer("FakeContainer", DataSpace.CSpace);
entityContainer.AddEntitySetBase(entitySet);
entitySet.ChangeEntityContainerWithoutCollectionFixup(entityContainer);
entitySet.SetReadOnly();
var model = new EdmModel(DataSpace.CSpace);
var omicMock = new Mock<DefaultObjectMappingItemCollection>(new EdmItemCollection(model), new ObjectItemCollection())
{
CallBase = true
};
var objectTypeMapping = new ObjectTypeMapping(entityType, entityType);
objectTypeMapping.AddMemberMap(
new ObjectPropertyMapping((EdmProperty)entityType.Members.First(), (EdmProperty)entityType.Members.First()));
omicMock.Setup(m => m.GetMap(It.IsAny<GlobalItem>())).Returns(objectTypeMapping);
var metadataWorkspaceMock = new Mock<MetadataWorkspace>
{
CallBase = true
};
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.OSpace)).Returns(true);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
metadataWorkspaceMock.Setup(m => m.GetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>()))
.Returns(entityContainer);
metadataWorkspaceMock.Setup(m => m.TryGetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>(), out entityContainer))
.Returns(true);
var storeItemCollection = new StoreItemCollection(
GenericProviderFactory<DbProviderFactory>.Instance, new SqlProviderManifest("2008"), "System.Data.FakeSqlClient", "2008");
metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollection);
#pragma warning disable 618
metadataWorkspaceMock.Object.RegisterItemCollection(omicMock.Object);
#pragma warning restore 618
var objectStateManagerMock = new Mock<ObjectStateManager>(metadataWorkspaceMock.Object)
{
CallBase = true
};
var entityKey = new EntityKey(entitySet, "keyValue");
var entityEntry = objectStateManagerMock.Object.AddKeyEntry(entityKey, entitySet);
var objectContextMock = Mock.Get(
CreateObjectContext(
metadataWorkspaceMock: metadataWorkspaceMock,
objectStateManagerMock: objectStateManagerMock));
var entityWrapperMock = new Mock<IEntityWrapper>();
entityWrapperMock.Setup(m => m.EntityKey).Returns(entityKey);
var entityWrapperFactoryMock = new Mock<EntityWrapperFactory>();
entityWrapperFactoryMock.Setup(
m => m.WrapEntityUsingStateManagerGettingEntry(
It.IsAny<object>(), It.IsAny<ObjectStateManager>(), out entityEntry))
.Returns(entityWrapperMock.Object);
objectContextMock.Setup(m => m.EntityWrapperFactory).Returns(entityWrapperFactoryMock.Object);
var executionPlanMock = new Mock<ObjectQueryExecutionPlan>(
MockBehavior.Loose, null, null, null, MergeOption.NoTracking, false, null, null);
executionPlanMock.Setup(
m => m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()))
.Returns(objectResultMock.Object);
objectContextMock.Setup(
m => m.PrepareRefreshQuery(It.IsAny<RefreshMode>(), It.IsAny<EntitySet>(), It.IsAny<List<EntityKey>>(), It.IsAny<int>()))
.Returns(new Tuple<ObjectQueryExecutionPlan, int>(executionPlanMock.Object, 1));
// Verify that ExecuteInTransaction calls ObjectQueryExecutionPlan.Execute
objectContextMock.Setup(
m =>
m.ExecuteInTransaction(It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), It.IsAny<bool>(), It.IsAny<bool>()))
.Returns<Func<ObjectResult<object>>, IDbExecutionStrategy, bool, bool>(
(f, t, s, r) =>
{
executionPlanMock.Verify(
m =>
m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()),
Times.Never());
var result = f();
executionPlanMock.Verify(
m =>
m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()),
Times.Once());
return result;
});
// Verify that ExecutionStrategy.Execute calls ExecuteInTransaction
var executionStrategyMock = new Mock<IDbExecutionStrategy>();
executionStrategyMock.Setup(m => m.Execute(It.IsAny<Func<ObjectResult<object>>>()))
.Returns<Func<ObjectResult<object>>>(
f =>
{
objectContextMock.Verify(
m =>
m.ExecuteInTransaction(
It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), false, true),
Times.Never());
var result = f();
objectContextMock.Verify(
m =>
m.ExecuteInTransaction(
It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), false, true),
Times.Once());
return result;
});
MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object));
try
{
objectContextMock.Object.Refresh(RefreshMode.StoreWins, new object());
}
finally
{
MutableResolver.ClearResolvers();
}
// Finally verify that ExecutionStrategy.Execute was called
executionStrategyMock.Verify(m => m.Execute(It.IsAny<Func<ObjectResult<object>>>()), Times.Once());
}
public void Cannot_remove_modification_function_mapping_when_read_only()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new EntitySetMapping(
entitySet,
new EntityContainerMapping(container));
var functionMapping =
new ModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<ModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new EntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
entitySetMapping.SetReadOnly();
Assert.Equal(
Strings.OperationOnReadOnlyItem,
Assert.Throws<InvalidOperationException>(
() => entitySetMapping.RemoveModificationFunctionMapping(entityFunctionMappings)).Message);
}
private static void SetupFooFunction(MetadataWorkspace metadataWorkspace)
{
var metadataWorkspaceMock = Mock.Get(metadataWorkspace);
var entityType = (EdmType)new EntityType(
"ReturnedEntity", "FooNamespace", DataSpace.CSpace,
new[] { "key" }, new EdmMember[] { new EdmProperty("key") });
var collectionTypeMock = new Mock<CollectionType>(entityType)
{
CallBase = true
};
metadataWorkspaceMock.Setup(m => m.TryDetermineCSpaceModelType(It.IsAny<Type>(), out entityType))
.Returns(true);
var entityContainer = new EntityContainer("Bar", DataSpace.CSpace);
metadataWorkspaceMock.Setup(m => m.TryGetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>(), out entityContainer))
.Returns(true);
var functionImport = new EdmFunction(
"Foo", "Bar", DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = false,
IsFunctionImport = true,
ReturnParameters = new[]
{
new FunctionParameter(
EdmConstants.ReturnType,
TypeUsage.Create(collectionTypeMock.Object),
ParameterMode.ReturnValue),
}
});
entityContainer.AddFunctionImport(functionImport);
entityContainer.AddEntitySetBase(new EntitySet("Foo", "", "", "", (EntityType)entityType));
var edmItemCollection = (EdmItemCollection)metadataWorkspace.GetItemCollection(DataSpace.CSpace);
var storeItemCollection = (StoreItemCollection)metadataWorkspace.GetItemCollection(DataSpace.SSpace);
var containerMappingMock = new Mock<EntityContainerMapping>(entityContainer);
FunctionImportMapping targetFunctionMapping = new FunctionImportMappingNonComposable(
functionImport, functionImport, new List<List<FunctionImportStructuralTypeMapping>>(), edmItemCollection);
containerMappingMock.Setup(
m => m.TryGetFunctionImportMapping(
It.IsAny<EdmFunction>(), out targetFunctionMapping)).Returns(true);
var storageMappingItemCollection = new Mock<StorageMappingItemCollection>(
edmItemCollection, storeItemCollection, new string[0])
{
CallBase = true
};
storageMappingItemCollection.Setup(m => m.GetItems<EntityContainerMapping>())
.Returns(
new ReadOnlyCollection<EntityContainerMapping>(
new List<EntityContainerMapping>
{
containerMappingMock.Object
}));
metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.CSSpace, It.IsAny<bool>()))
.Returns(storageMappingItemCollection.Object);
}
public void Cannot_add_entity_set_to_readonly_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") });
entityContainer.SetReadOnly();
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws<InvalidOperationException>(() => entityContainer.AddEntitySetBase(entitySet)).Message);
}
