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); }