public void EntityConnection_automatically_closed_if_underlying_StoreConnection_is_closed_without_txn()
{
var storeConnectionState = ConnectionState.Closed;
var storeConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
storeConnectionMock.Setup(m => m.Open()).Callback(() => storeConnectionState = ConnectionState.Open);
storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed);
storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
// open entityConnection - both entityConnection and store connection should now be open
var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, storeConnectionMock.Object, true);
entityConnection.Open();
Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state
// now close the underlying store connection without explicitly closing entityConnection
entityConnection.StoreConnection.Close();
Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state automatically updated
Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State);
// now re-open the store connection and EntityConnection is "resurrected" to an Open state
entityConnection.StoreConnection.Open();
Assert.Equal(ConnectionState.Open, entityConnection.State);
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State);
}
public void StoreConnection_state_mimics_EntityConnection_state_if_only_EntityConnection_is_used_without_txn()
{
var storeConnectionState = ConnectionState.Closed;
var storeConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
storeConnectionMock.Setup(m => m.Open()).Callback(() => storeConnectionState = ConnectionState.Open);
storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed);
storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, storeConnectionMock.Object, true);
Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state
// open entityConnection (automatically opens store connection)
entityConnection.Open();
Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state
// close entityConnection without explicitly closing underlying store connection
entityConnection.Close();
Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state
}
public void AddNewTest()
{
using (System.Data.Entity.Core.EntityClient.EntityConnection entity = new System.Data.Entity.Core.EntityClient.EntityConnection("MyProjectEF1"))
{
entity.Open();
EntityCommand cmd = entity.CreateCommand();
cmd.CommandText = @"select doubt d from uLibrary as d where d.";
}
MyProjectEF mp = new MyProjectEF();
mp.uLibrary.ToList();
mp.uUsers.Add(new uUser()
{
UserName = "******",
Password = Base64Helper.Base64Encode("msc@123321"),
Email = "*****@*****.**",
CreationDate = DateTime.Now,
EditDate = DateTime.Now,
FirstName = "Edwin",
LastName = "Nie",
FullName = "Edwin Nie",
LCV = false
});
mp.SaveChanges();
}
public void DependencyResolver_used_to_resolve_DbProviderServices()
{
const string query = @"
SELECT VALUE p
FROM CodeFirstContainer.Products AS p
WHERE p.ID > 3";
var mockResolver = new Mock<IDbDependencyResolver>();
mockResolver
.Setup(
r => r.GetService(
It.Is<Type>(t => t == typeof(DbProviderServices)),
It.Is<string>(s => s == "System.Data.SqlClient")))
.Returns(SqlProviderServices.Instance);
using (var connection = new EntityConnection(SimpleModelEntityConnectionString))
{
connection.Open();
new EntityCommand(query, connection, mockResolver.Object)
.ExecuteReader(CommandBehavior.SequentialAccess);
}
mockResolver.Verify(m => m.GetService(typeof(DbProviderServices), "System.Data.SqlClient"), Times.Once());
}
public EntityConnectionX()
{
EntityConnection connection = new EntityConnection("name=NorthwindEntities");
// Open the connection.
connection.Open();
this.Connection = connection;
}
public void Verify_that_opening_connection_does_not_create_new_MetadataWorkspace()
{
var connection = new EntityConnection(connectionString);
var workspace = connection.GetMetadataWorkspace();
connection.Open();
Assert.Same(workspace, connection.GetMetadataWorkspace());
}
public void Exception_is_thrown_if_dbConnection_is_null()
{
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, null, true);
Assert.Equal(
Strings.EntityClient_ConnectionStringNeededBeforeOperation,
Assert.Throws <InvalidOperationException>(() => entityConnection.Open()).Message);
}
private void ejemploentity() {
using (EntityConnection conn = new EntityConnection("name=travelEntitiesGeneral"))
{
conn.Open();
EntityCommand cmd = conn.CreateCommand();
cmd.CommandText = @"select c.BlogID from travelEntitiesGeneral.Blogs as c where c.BlogPosts.Count > 0";
EntityDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
while (reader.Read())
{
Console.WriteLine("BlogID = {0}", reader["BlogID"]);
}
conn.Close();
}
}
static void Main(string[] args)
{
string city = "London";
using (EntityConnection cn = new EntityConnection("Name=Entities"))
{
cn.Open();
EntityCommand cmd = cn.CreateCommand();
cmd.CommandText = @"SELECT VALUE c FROM Entities.Customers AS c WHERE
c.Address.City = @city";
cmd.Parameters.AddWithValue("city", city);
DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
while (rdr.Read())
Console.WriteLine(rdr["CompanyName"].ToString());
rdr.Close();
}
}
public void Underlying_dbConnection_is_not_being_reopened_if_it_was_initally_open()
{
var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true);
entityConnection.Open();
dbConnectionMock.Verify(m => m.Open(), Times.Never());
Assert.Equal(ConnectionState.Open, dbConnectionMock.Object.State);
}
public void EntityConnection_with_closed_underlying_connection_maintains_closed_if_metadata_initialization_fails()
{
var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Verifiable();
dbConnectionMock.Setup(m => m.Close()).Verifiable();
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Closed);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Throws <InvalidOperationException>();
var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true);
Assert.Throws <InvalidOperationException>(() => entityConnection.Open());
Assert.Equal(ConnectionState.Closed, entityConnection.State);
}
public void Underlying_dbConnection_is_opened_if_it_was_initially_closed()
{
var dbConnectionState = ConnectionState.Closed;
var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Callback(() => dbConnectionState = ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true);
entityConnection.Open();
dbConnectionMock.Verify(m => m.Open(), Times.Once());
}
public void Opening_EntityConnection_sets_its_State_to_Opened()
{
var dbConnectionState = ConnectionState.Closed;
var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Callback(() => dbConnectionState = ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true);
entityConnection.Open();
Assert.Equal(ConnectionState.Open, entityConnection.State);
}
public SGCoopSTEntities()
: base("name=SGCoopSTEntities")
{
string providerName = "System.Data.SqlClient";
string serverName = "10.10.11.115";
string databaseName = "SGCoopST";
string password="******";
string userid = "sa";
// Initialize the connection string builder for the
// underlying provider.
SqlConnectionStringBuilder sqlBuilder =
new SqlConnectionStringBuilder();
// Set the properties for the data source.
sqlBuilder.DataSource = serverName;
sqlBuilder.InitialCatalog = databaseName;
sqlBuilder.IntegratedSecurity = false;
sqlBuilder.Password = password;
sqlBuilder.UserID = userid;
// Build the SqlConnection connection string.
string providerString = sqlBuilder.ToString();
// Initialize the EntityConnectionStringBuilder.
EntityConnectionStringBuilder entityBuilder =
new EntityConnectionStringBuilder();
//Set the provider name.
entityBuilder.Provider = providerName;
// Set the provider-specific connection string.
entityBuilder.ProviderConnectionString = providerString;
// Set the Metadata location.
entityBuilder.Metadata = @"res://*/GOLDMEM.Entity.GMModel.csdl
|res://*/GOLDMEM.Entity.GMModel.ssdl
|res://*/GOLDMEM.Entity.GMModel.msl";
EntityConnection enCon = new EntityConnection(entityBuilder.ToString());
if (enCon.State== System.Data.ConnectionState.Closed)
{
enCon.Open();
}
}
public void Underlying_dbConnection_is_being_closed_if_it_was_initially_closed_and_metadata_initialization_fails()
{
var dbConnectionState = ConnectionState.Closed;
var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Callback(() => dbConnectionState = ConnectionState.Open);
dbConnectionMock.Setup(m => m.Close()).Verifiable();
dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState);
var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Throws <InvalidOperationException>();
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true);
Assert.Throws <InvalidOperationException>(() => entityConnection.Open());
dbConnectionMock.Verify(m => m.Close(), Times.Once());
}
public void When_Same_Primary_Key_Name_Is_Used_For_Two_Tables_Correct_Number_Of_MetaData_Rows_Is_Returned()
{
this.CreateIfNotExists();
var workspace = CreateMetadataWorkspace();
var connection = new EntityConnection(workspace, new SqlCeConnection(dbConnectionString));
connection.Open();
var command = connection.CreateCommand();
command.CommandText = TableDetailSql;
var rowCount = 0;
using (var reader = command.ExecuteReader(CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
rowCount++;
}
}
Assert.Equal(4, rowCount);
}
public void EntityConnection_with_closed_underlying_connection_maintains_closed_if_store_connection_does_not_open_correctly()
{
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Verifiable();
dbConnectionMock.Setup(m => m.Close()).Verifiable();
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Closed);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo");
var entityConnection = new EntityConnection(
CreateMetadataWorkspaceMock().Object, dbConnectionMock.Object, true, true);
Assert.Equal(
Strings.EntityClient_ConnectionNotOpen,
Assert.Throws<InvalidOperationException>(() => entityConnection.Open()).Message);
Assert.Equal(ConnectionState.Closed, entityConnection.State);
}
public void ExecutionStrategy_is_used()
{
var storeConnectionState = ConnectionState.Closed;
var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
storeConnectionMock.Setup(m => m.Open()).Callback(() => storeConnectionState = ConnectionState.Open);
storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake");
storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState);
var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true);
var executionStrategyMock = new Mock<IDbExecutionStrategy>();
executionStrategyMock.Setup(m => m.Execute(It.IsAny<Action>())).Callback<Action>(
a =>
{
storeConnectionMock.Verify(m => m.Open(), Times.Never());
a();
storeConnectionMock.Verify(m => m.Open(), Times.Once());
});
MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object));
try
{
entityConnection.Open();
}
finally
{
MutableResolver.ClearResolvers();
}
executionStrategyMock.Verify(m => m.Execute(It.IsAny<Action>()), Times.Once());
}
public void Exception_is_thrown_when_store_connection_doesnt_open()
{
var storeConnectionState = ConnectionState.Closed;
var storeConnectionMock = new Mock<DbConnection>();
storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed);
storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake");
storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState);
var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true);
Assert.Equal(
Strings.EntityClient_ConnectionNotOpen,
Assert.Throws<InvalidOperationException>(() => entityConnection.Open()).Message);
}
public void Underlying_dbConnection_is_not_being_closed_if_it_was_initially_open_and_attempt_is_made_to_reopen_it()
{
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Verifiable();
dbConnectionMock.Setup(m => m.Close()).Verifiable();
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo");
var entityConnection = new EntityConnection(
new Mock<MetadataWorkspace>(MockBehavior.Strict).Object, dbConnectionMock.Object, true, true);
entityConnection.Open();
dbConnectionMock.Verify(m => m.Close(), Times.Never());
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State);
}
public void Exception_is_not_thrown_when_trying_to_open_already_opened_connection()
{
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "fake");
var metadataWorkspace = CreateMetadataWorkspaceMock().Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true);
Assert.DoesNotThrow(() => entityConnection.Open());
}
public void Exception_is_thrown_when_trying_to_open_a_broken_connection()
{
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Broken);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "fake");
var metadataWorkspace = CreateMetadataWorkspaceMock().Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true);
Assert.Equal(
Strings.EntityClient_CannotOpenBrokenConnection,
Assert.Throws<InvalidOperationException>(() => entityConnection.Open()).Message);
}
public void Opening_EntityConnection_sets_its_State_to_Opened()
{
var dbConnectionState = ConnectionState.Closed;
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Callback(() => dbConnectionState = ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo");
var metadataWorkspaceMock = CreateMetadataWorkspaceMock();
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true);
entityConnection.Open();
dbConnectionMock.Raise(
conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
Assert.Equal(ConnectionState.Open, entityConnection.State);
}
public void Underlying_dbConnection_is_not_being_closed_if_it_was_initially_opened_such_that_it_cannot_be_reopend()
{
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Verifiable();
dbConnectionMock.Setup(m => m.Close()).Verifiable();
dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo");
var entityConnection = new EntityConnection(
new Mock<MetadataWorkspace>(MockBehavior.Strict).Object, dbConnectionMock.Object, true, true);
Assert.Equal(
Strings.EntityClient_CannotReopenConnection,
Assert.Throws<InvalidOperationException>(() => entityConnection.Open()).Message);
dbConnectionMock.Verify(m => m.Close(), Times.Never());
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State);
}
private static void FunWithEntityDataReader() {
using (EntityConnection cn = new EntityConnection("name=AutoLotEntities")) {
cn.Open();
string queryString = "SELECT VALUE car from AutoLotEntities.Cars as car WHERE car.Color='Black'";
using (EntityCommand cmd = cn.CreateCommand()) {
cmd.CommandText = queryString;
using (EntityDataReader dr = cmd.ExecuteReader(System.Data.CommandBehavior.SequentialAccess)) {
while (dr.Read()) {
Console.WriteLine(dr["CarID"]);
}
}
}
}
}
public void Exception_is_thrown_if_dbConnection_is_null()
{
var metadataWorkspaceMock = new Mock<MetadataWorkspace>(MockBehavior.Strict);
var metadataWorkspace = metadataWorkspaceMock.Object;
var entityConnection = new EntityConnection(metadataWorkspace, null, true, true);
Assert.Equal(
Strings.EntityClient_ConnectionStringNeededBeforeOperation,
Assert.Throws<InvalidOperationException>(() => entityConnection.Open()).Message);
}
private static void test()
{
// Specify the provider name, server and database.
string providerName = "System.Data.SqlClient";
string serverName = ".";
string databaseName = "AdventureWorks";
// Initialize the connection string builder for the
// underlying provider.
SqlConnectionStringBuilder sqlBuilder =
new SqlConnectionStringBuilder();
// Set the properties for the data source.
sqlBuilder.DataSource = serverName;
sqlBuilder.InitialCatalog = databaseName;
sqlBuilder.IntegratedSecurity = true;
// Build the SqlConnection connection string.
string providerString = sqlBuilder.ToString();
// Initialize the EntityConnectionStringBuilder.
EntityConnectionStringBuilder entityBuilder =
new EntityConnectionStringBuilder();
//Set the provider name.
entityBuilder.Provider = providerName;
// Set the provider-specific connection string.
entityBuilder.ProviderConnectionString = providerString;
// Set the Metadata location.
entityBuilder.Metadata = @"res://*/AdventureWorksModel.csdl|
res://*/AdventureWorksModel.ssdl|
res://*/AdventureWorksModel.msl";
Console.WriteLine(entityBuilder.ToString());
using (EntityConnection conn =
new EntityConnection(entityBuilder.ToString()))
{
conn.Open();
Console.WriteLine("Just testing the connection.");
conn.Close();
}
}
public void EntityConnection_automatically_closed_if_underlying_StoreConnection_is_closed_without_txn()
{
var storeConnectionState = ConnectionState.Closed;
var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
storeConnectionMock.Setup(m => m.Open()).Callback(() => storeConnectionState = ConnectionState.Open);
storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed);
storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState);
storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake");
// open entityConnection - both entityConnection and store connection should now be open
var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true);
entityConnection.Open();
storeConnectionMock.Raise(
conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state
// now close the underlying store connection without explicitly closing entityConnection
entityConnection.StoreConnection.Close();
storeConnectionMock.Raise(
conn => conn.StateChange -= null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed));
Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state automatically updated
Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State);
// now re-open the store connection and EntityConnection is "resurrected" to an Open state
entityConnection.StoreConnection.Open();
storeConnectionMock.Raise(
conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
Assert.Equal(ConnectionState.Open, entityConnection.State);
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State);
}
private void MetadataCachingWithGarbageCollectionTemplate(Action garbageCollection)
{
MetadataWorkspace.ClearCache();
var weakReferences = new WeakReference[3];
// load metadata
using (var connection1 = new EntityConnection(connectionString))
{
connection1.Open();
weakReferences[0] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
weakReferences[1] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
weakReferences[2] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
}
// perform necessary garbage collection steps
garbageCollection();
// verify that metadata was cached
using (var connection2 = new EntityConnection(connectionString))
{
connection2.Open();
Assert.Same(weakReferences[0].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
Assert.Same(weakReferences[1].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
Assert.Same(weakReferences[2].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
}
}
public void Open_should_dispatch_and_optionally_open_underlying_connection()
{
var mockConnection = new Mock<DbConnection>();
mockConnection.SetupGet(m => m.DataSource).Returns("Foo");
var dispatcher = new EntityConnectionDispatcher();
var mockConnectionInterceptor = new Mock<IEntityConnectionInterceptor>();
dispatcher.InternalDispatcher.Add(mockConnectionInterceptor.Object);
var mockStoreItemCollection = new Mock<StoreItemCollection>();
mockStoreItemCollection
.SetupGet(m => m.StoreProviderFactory)
.Returns(DbProviderServices.GetProviderFactory(new SqlConnection()));
var mockMetadataWorkspace = new Mock<MetadataWorkspace>();
mockMetadataWorkspace
.Setup(m => m.GetItemCollection(DataSpace.SSpace))
.Returns(mockStoreItemCollection.Object);
var connection
= new EntityConnection(
mockMetadataWorkspace.Object,
mockConnection.Object,
true,
true,
dispatcher);
var objectContext = new ObjectContext();
connection.AssociateContext(objectContext);
mockConnectionInterceptor
.Setup(m => m.ConnectionOpening(connection, It.IsAny<DbInterceptionContext>()))
.Callback<EntityConnection, DbInterceptionContext>(
(_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts))
.Returns(false);
connection.Open();
mockConnection.Verify(m => m.Open(), Times.Never());
Assert.Equal(ConnectionState.Open, connection.State);
mockConnectionInterceptor
.Setup(m => m.ConnectionOpening(connection, It.IsAny<DbInterceptionContext>()))
.Callback<EntityConnection, DbInterceptionContext>(
(_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts))
.Returns(true);
mockConnection
.Setup(m => m.Open())
.Callback(
() => mockConnection
.SetupGet(m => m.State).Returns(ConnectionState.Open)
.Raises(
m => m.StateChange += null,
new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)));
connection.Open();
mockConnection.Verify(m => m.Open(), Times.Once());
Assert.Equal(ConnectionState.Open, connection.State);
}
public void Underlying_dbConnection_is_opened_if_it_was_initially_closed()
{
var dbConnectionState = ConnectionState.Closed;
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.Open()).Callback(() => dbConnectionState = ConnectionState.Open);
dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState);
dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo");
var metadataWorkspace = CreateMetadataWorkspaceMock().Object;
var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true);
entityConnection.Open();
dbConnectionMock.Raise(
conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
dbConnectionMock.Verify(m => m.Open(), Times.Once());
}
public void StoreConnection_state_mimics_EntityConnection_state_if_only_EntityConnection_is_used_without_txn()
{
var storeConnectionState = ConnectionState.Closed;
var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
storeConnectionMock.Setup(m => m.Open()).Callback(() => storeConnectionState = ConnectionState.Open);
storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed);
storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState);
storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake");
var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true);
Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state
// open entityConnection (automatically opens store connection)
entityConnection.Open();
storeConnectionMock.Raise(
conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state
// close entityConnection without explicitly closing underlying store connection
entityConnection.Close();
storeConnectionMock.Raise(
conn => conn.StateChange -= null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed));
Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state
Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state
}
public void Should_use_interception()
{
var mockConnection = new Mock<DbConnection>();
mockConnection.SetupGet(m => m.DataSource).Returns("Foo");
mockConnection.SetupGet(m => m.State).Returns(ConnectionState.Closed);
var mockStoreItemCollection = new Mock<StoreItemCollection>();
mockStoreItemCollection
.SetupGet(m => m.ProviderFactory)
.Returns(DbProviderServices.GetProviderFactory(new SqlConnection()));
var mockMetadataWorkspace = new Mock<MetadataWorkspace>();
mockMetadataWorkspace
.Setup(m => m.GetItemCollection(DataSpace.SSpace))
.Returns(mockStoreItemCollection.Object);
var objectContext = new ObjectContext();
var mockConnectionInterceptor = new Mock<IDbConnectionInterceptor>();
mockConnectionInterceptor
.Setup(m => m.Opening(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()))
.Callback<DbConnection, DbConnectionInterceptionContext>(
(_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts));
mockConnectionInterceptor
.Setup(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()))
.Callback<DbConnection, DbConnectionInterceptionContext>(
(_, c) => mockConnection.Verify(m => m.Open(), Times.Once()));
mockConnection
.Setup(m => m.Open())
.Callback(
() =>
{
mockConnection
.SetupGet(m => m.State).Returns(ConnectionState.Open);
mockConnection.Raise(
m => m.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
});
EntityConnection connection;
DbInterception.Add(mockConnectionInterceptor.Object);
try
{
connection
= new EntityConnection(
mockMetadataWorkspace.Object,
mockConnection.Object,
true,
true);
connection.AssociateContext(objectContext);
connection.Open();
}
finally
{
DbInterception.Remove(mockConnectionInterceptor.Object);
}
mockConnectionInterceptor.Verify(m => m.Opening(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()),
Times.Once());
mockConnectionInterceptor.Verify(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()),
Times.Once());
mockConnectionInterceptor
.Verify(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once());
mockConnectionInterceptor.Verify(
m => m.StateGetting(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()),
Times.Exactly(3));
mockConnectionInterceptor.Verify(
m => m.StateGot(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()),
Times.Exactly(3));
mockConnection.Verify(m => m.State, Times.Exactly(3));
Assert.Equal(ConnectionState.Open, connection.State);
}
public void UserDefinedFunction()
{
using (EntityConnection conn = new EntityConnection("name=testEntities"))
{
conn.Open();
string query = @"SELECT e.FirstName AS Name FROM testEntities.Employees AS e
WHERE testModel.Store.spFunc(e.Id, '') = 6";
using (EntityCommand cmd = new EntityCommand(query, conn))
{
EntityDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
Assert.IsTrue(reader.Read());
Assert.AreEqual("Scooby", reader[0]);
}
}
}
public ActionResult EntitySQL(int id = 0)
{
string esqlQuery = @"SELECT VALUE customers FROM AdventureWorksEntities.Customers AS customers WHERE customers.CustomerID == @id";
var customers = new List<Customer2>();
using(var conn = new EntityConnection("name=AdventureWorksEntities"))
{
conn.Open();
using(var cmd = conn.CreateCommand())
{
cmd.CommandText = esqlQuery;
var param = new EntityParameter {
ParameterName = "id",
Value = id
};
cmd.Parameters.Add(param);
using(var reader = cmd.ExecuteReader(System.Data.CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
var customer = new Customer2
{
CustomerID = int.Parse(reader["CustomerID"].ToString()),
CustomerName = reader["FirstName"] + " " + reader["MiddleName"] + " " + reader["LastName"]
};
customers.Add(customer);
}
}
}
conn.Close();
}
return View(customers);
}
