public void Prepare_returns_a_new_instance() { var objectQueryExecutionPlanFactory = new ObjectQueryExecutionPlanFactory( Common.Internal.Materialization.MockHelper.CreateTranslator<object>()); var metadataWorkspace = new MetadataWorkspace(); var edmItemCollection = new EdmItemCollection(); metadataWorkspace.RegisterItemCollection(edmItemCollection); metadataWorkspace.RegisterItemCollection(new ObjectItemCollection()); var fakeSqlProviderManifest = new FakeSqlProviderServices().GetProviderManifest("2008"); var storeItemCollection = new StoreItemCollection(FakeSqlProviderFactory.Instance, fakeSqlProviderManifest, "2008"); metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(edmItemCollection, storeItemCollection, Enumerable.Empty<XmlReader>())); var fakeSqlConnection = new FakeSqlConnection(); fakeSqlConnection.ConnectionString = "foo"; var entityConnection = new EntityConnection(metadataWorkspace, fakeSqlConnection, false); var objectContext = new ObjectContext(entityConnection); var dbExpression = new DbNullExpression(TypeUsage.Create(fakeSqlProviderManifest.GetStoreTypes().First())); var dbQueryCommandTree = new DbQueryCommandTree(metadataWorkspace, DataSpace.CSpace, dbExpression, validate: false); var parameters = new List<Tuple<ObjectParameter, QueryParameterExpression>>(); var objectQueryExecutionPlan = objectQueryExecutionPlanFactory.Prepare(objectContext, dbQueryCommandTree, typeof(object), MergeOption.NoTracking, new Span(), parameters, aliasGenerator: null); Assert.NotNull(objectQueryExecutionPlan); }
public virtual bool Opening(EntityConnection entityConnection, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(entityConnection); DebugCheck.NotNull(interceptionContext); return _internalDispatcher.Dispatch(true, (b, i) => i.ConnectionOpening(entityConnection, interceptionContext) && b); }
// <summary> // Constructs the DbContextTransaction object with the associated transaction object // </summary> // <param name="transaction">The EntityTransaction object to use</param> internal DbContextTransaction(EntityTransaction transaction) { DebugCheck.NotNull(transaction); _connection = transaction.Connection; EnsureOpenConnection(); _entityTransaction = transaction; }
static void Main(string[] args) { EntityConnection cn = new EntityConnection("name=ASIEntities7"); DbConnection dbcn = new SqlConnection( System.Configuration.ConfigurationManager.ConnectionStrings["base dados"].ConnectionString ); var alnPedro = new Aluno { NumAl = 1001, Nome = "Pedro" }; alnPedro.AlunosAssEsts = new HashSet<AlunosAssEst>(); var alnPaula = new Aluno { NumAl = 1002, Nome = "Paula" }; alnPaula.AlunosAssEsts = new HashSet<AlunosAssEst>(); using (var ctx1 = new ASIEntities7(cn)) { // em alternativa a usar o Sql Server Profiler, pode fazer: //ctx1.Database.Log = Console.Write; ctx1.Alunos.Add(alnPedro); ctx1.Alunos.Add(alnPaula); // ExecuteDML(dbcn, "A trocar as voltas ao EF6 inserindo o Jose ADO.Net(1001)...", "INSERT INTO [BD3_1].[dbo].[Alunos] ([NumAl],[Nome]) VALUES (1001, 'Jose ADO.Net')"); SaveContextChanges(ctx1, PoliticaConcorrencia.UsarInfoBD); } using (var ctxPessimista = new ASIEntities7(cn)) { // em alternativa a usar o Sql Server Profiler, pode fazer: //ctx4.Database.Log = Console.Write; Aluno alnPedroCtx = (from a in ctxPessimista.Alunos where a.NumAl == 1001 select a).First(); alnPedroCtx.Nome = "Pedro ContextoEF6"; ExecuteDML(dbcn, "O ADO.Net vai mudar o nome do Pedro para 'Pedro ADO.Net'.", "UPDATE [BD3_1].[dbo].[Alunos] SET [Nome] = 'Pedro ADO.Net' WHERE [NumAl] = 1001"); Console.WriteLine("O EF6 vai mudar o nome do Pedro para 'Pedro ContextoEF6'. Antes de gravar, alnPedroCtx.Nome = {0}", alnPedroCtx.Nome); SaveContextChanges(ctxPessimista, PoliticaConcorrencia.UsarInfoBD); Console.WriteLine("Depois de gravadas as alteracoes com uma politica pessimista (vale o que esta na BD), o nome do Pedro no ambito do contexto EF6 é: alnPedroCtx.Nome = {0})", alnPedroCtx.Nome); } Console.WriteLine(); using (var ctxOptimista = new ASIEntities7(cn)) { // em alternativa a usar o Sql Server Profiler, pode fazer: //ctx5.Database.Log = Console.Write; Aluno alnPedroCtx = (from a in ctxOptimista.Alunos where a.NumAl == 1001 select a).First(); alnPedroCtx.Nome = "Pedro ContextoEF6"; ExecuteDML(dbcn, "O ADO.Net vai mudar o nome do Pedro para 'Pedro ADO.Net Outra Vez'.", "UPDATE [BD3_1].[dbo].[Alunos] SET [Nome] = 'Pedro ADO.Net Outra Vez' WHERE [NumAl] = 1001"); Console.WriteLine("O EF6 vai mudar o nome do Pedro para 'Pedro ContextoEF6'. Antes de gravar, alnPedroCtx.Nome = {0}", alnPedroCtx.Nome); SaveContextChanges(ctxOptimista, PoliticaConcorrencia.UsarInfoCtx); Console.WriteLine("Depois de gravadas as alteracoes com uma politica optimista (vale o que esta no Contexto), o nome do Pedro no ambito do contexto EF6 é: alnPedroCtx.Nome = {0})", alnPedroCtx.Nome); } Console.WriteLine("Press any key to exit..."); Console.ReadLine(); }
/// <summary> /// Constructs the DbContextTransaction object with the associated connection object /// and with the given isolation level /// </summary> /// <param name="connection">The EntityConnection object owning this transaction </param> /// <param name="isolationLevel">The database isolation level with which the underlying store transaction will be created</param> internal DbContextTransaction(EntityConnection connection, IsolationLevel isolationLevel) { DebugCheck.NotNull(connection); _connection = connection; EnsureOpenConnection(); _entityTransaction = _connection.BeginTransaction(isolationLevel); }
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()); }
private EntityConnection GetEntityConnection() { string connectionString = String.Format( "metadata=TestDB.csdl|TestDB.msl|TestDB.ssdl;provider=MySql.Data.MySqlClient; provider connection string=\"{0}\"", GetConnectionString(true)); EntityConnection connection = new EntityConnection(connectionString); return connection; }
internal EntityTransaction(EntityConnection connection, DbTransaction storeTransaction) { DebugCheck.NotNull(connection); DebugCheck.NotNull(storeTransaction); _connection = connection; _storeTransaction = storeTransaction; }
internal EntityTransaction(EntityConnection connection, DbTransaction storeTransaction) { Contract.Requires(connection != null); Contract.Requires(storeTransaction != null); _connection = connection; _storeTransaction = storeTransaction; }
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 EntityConnectionX() { EntityConnection connection = new EntityConnection("name=NorthwindEntities"); // Open the connection. connection.Open(); this.Connection = connection; }
internal virtual EntityStoreSchemaGeneratorDatabaseSchemaLoader CreateDbSchemaLoader( EntityConnection connection, Version storeSchemaModelVersion) { return new EntityStoreSchemaGeneratorDatabaseSchemaLoader( connection, storeSchemaModelVersion); }
public void Verify_that_metadata_is_the_same_for_two_workspaces_created_from_two_entity_connections_with_same_connection_strings() { var connection1 = new EntityConnection(connectionString); var connection2 = new EntityConnection(connectionString); var workspace1 = connection1.GetMetadataWorkspace(); var workspace2 = connection2.GetMetadataWorkspace(); Assert.Same(workspace1.GetItemCollection(DataSpace.CSpace), workspace2.GetItemCollection(DataSpace.CSpace)); Assert.Same(workspace1.GetItemCollection(DataSpace.SSpace), workspace2.GetItemCollection(DataSpace.SSpace)); Assert.Same(workspace1.GetItemCollection(DataSpace.CSSpace), workspace2.GetItemCollection(DataSpace.CSSpace)); }
public virtual EntityConnectionProxy CreateNew(DbConnection storeConnection) { var clonedConnection = new EntityConnection(_entityConnection.GetMetadataWorkspace(), storeConnection); var currentTransaction = _entityConnection.CurrentTransaction; if (currentTransaction != null && DbInterception.Dispatch.Transaction.GetConnection( currentTransaction.StoreTransaction, _entityConnection.InterceptionContext) == storeConnection) { clonedConnection.UseStoreTransaction(currentTransaction.StoreTransaction); } return new EntityConnectionProxy(clonedConnection); }
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(); } }
Verify_that_conceptual_metadata_is_the_same_for_two_workspaces_created_from_two_entity_connections_with_reordered_metadata_in_connection_strings () { var connectionString2 = string.Format( @"metadata=res://EntityFramework.FunctionalTests.Transitional/System.Data.Entity.Metadata.MetadataCachingModel.msl|res://EntityFramework.FunctionalTests.Transitional/System.Data.Entity.Metadata.MetadataCachingModel.ssdl|res://EntityFramework.FunctionalTests.Transitional/System.Data.Entity.Metadata.MetadataCachingModel.csdl;provider=System.Data.SqlClient;provider connection string=""{0}""", ModelHelpers.SimpleConnectionString("tempdb")); var connection1 = new EntityConnection(connectionString); var connection2 = new EntityConnection(connectionString2); var workspace1 = connection1.GetMetadataWorkspace(); var workspace2 = connection2.GetMetadataWorkspace(); Assert.Same(workspace1.GetItemCollection(DataSpace.CSpace), workspace2.GetItemCollection(DataSpace.CSpace)); }
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 static bool insertDataToTable1(SqlConnection connection, System.Data.SqlClient.SqlTransaction transaction, int numberID, string text) { bool response = false; MetadataWorkspace workspace = new MetadataWorkspace ( new string[] { string.Format("res://{0}/MyTestDB.csdl" , "*"), string.Format("res://{0}/MyTestDB.ssdl" , "*"), string.Format("res://{0}/MyTestDB.msl" , "*") }, new Assembly[] { Assembly.GetAssembly(typeof (jfso.demos.SqlTransaction.DAL.MyTestDV)) } ); EntityConnection _conn = new EntityConnection(workspace, connection); try { using (var ctx = new MyTestDV(_conn, false)) { ctx.Database.UseTransaction(transaction); ctx.TestTable1.Add( new TestTable1() { ID = numberID, Text = text }); ctx.SaveChanges(); response = true; } } catch (Exception) { response = false; } return response; }
static void Main(string[] args) { using (var ts = new TransactionScope()) { EntityConnection cn = new EntityConnection("name=ASIEntities7"); using (var ctx = new ASIEntities7(cn)) { // em alternativa a usar o Sql Server Profiler, pode fazer: ctx.Database.Log = Console.Write; //Em EF 5: //((IObjectContextAdapter)ctx).ObjectContext.Connection.Open(); ctx.Database.Connection.Open(); var al = (from a in ctx.Alunos where a.NumAl == 1111 select a) .First(); al.Nome = "xico"; using (var ctx1 = new ASIEntities7(cn)) { //Em EF5: //((IObjectContextAdapter)ctx1).ObjectContext.Connection.Open(); //ctx1.Database.Connection.Open(); var al1 = (from a in ctx.Alunos where a.NumAl == 4444 select a) .First(); al1.Nome = "xxxx"; ctx1.SaveChanges(); } ctx.SaveChanges(); } // ponto 1: observar no Sql Server Profiler ts.Complete(); } }
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 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); }
void Temp() { #region EntityConnectionCreationAndUsage EntityConnectionStringBuilder entityBuilder = new EntityConnectionStringBuilder { Provider = "System.Data.SqlClient", ProviderConnectionString = "the database connection string", Metadata = @"res://*/MySample.csdl|res://*/MySample.ssdl|res://*/MySample.msl" }; EntityConnection entityConn = new EntityConnection(entityBuilder.ToString()); using (MySampleContainer ctx = new MySampleContainer(entityConn)) { //use the DbContext as required } #endregion }
public void ExecutionStrategy_is_used_to_recover_from_a_transient_error() { var storeConnectionState = ConnectionState.Open; var transientExceptionThrown = false; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.Setup(m => m.Open()).Callback(() => storeConnectionState = ConnectionState.Open); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); storeConnectionMock.Protected().Setup<DbTransaction>("BeginDbTransaction", IsolationLevel.Unspecified) .Returns<IsolationLevel>( il => { if (!transientExceptionThrown) { transientExceptionThrown = true; storeConnectionState = ConnectionState.Broken; throw new TimeoutException(); } return new Mock<DbTransaction>().Object; }); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true); var executionStrategyMock = new Mock<IDbExecutionStrategy>(); executionStrategyMock.Setup(m => m.Execute(It.IsAny<Func<DbTransaction>>())).Returns<Func<DbTransaction>>( a => { storeConnectionMock.Protected() .Verify<DbTransaction>( "BeginDbTransaction", Times.Never(), IsolationLevel.Unspecified); Assert.Throws<TimeoutException>(() => a()); storeConnectionMock.Protected() .Verify<DbTransaction>( "BeginDbTransaction", Times.Once(), IsolationLevel.Unspecified); var result = a(); storeConnectionMock.Protected() .Verify<DbTransaction>( "BeginDbTransaction", Times.Exactly(2), IsolationLevel.Unspecified); return result; }); MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object)); try { entityConnection.BeginTransaction(); } finally { MutableResolver.ClearResolvers(); } executionStrategyMock.Verify(m => m.Execute(It.IsAny<Func<DbTransaction>>()), Times.Once()); }
public void EntityConnection_automatically_opened_if_underlying_StoreConnection_is_opened_with_ambient_txn() { using (new TransactionScope()) { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var metadataWorkspaceMock = new Mock<MetadataWorkspace>(MockBehavior.Strict); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, storeConnectionMock.Object, true, true); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state // open underlying store connection without explicitly opening entityConnection entityConnection.StoreConnection.OpenAsync().Wait(); storeConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state is automatically updated Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // now close 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); Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); } }
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.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); 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.OpenAsync().Wait(); 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.OpenAsync().Wait(); 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); }
public void ExecutionStrategy_is_used() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Returns( () => { storeConnectionState = ConnectionState.Open; return Task.FromResult(true); }); 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.ExecuteAsync(It.IsAny<Func<Task>>(), It.IsAny<CancellationToken>())) .Returns<Func<Task>, CancellationToken>( (f, c) => { storeConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Never()); f().Wait(); storeConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once()); return Task.FromResult(true); }); MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object)); try { entityConnection.OpenAsync().Wait(); } finally { MutableResolver.ClearResolvers(); } executionStrategyMock.Verify(m => m.ExecuteAsync(It.IsAny<Func<Task>>(), It.IsAny<CancellationToken>()), 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.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); 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.OpenAsync().Wait(); 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 }
// <summary> // Constructs a new EntityCommand given a EntityConnection and an EntityCommandDefition. This // constructor is used by ObjectQueryExecution plan to execute an ObjectQuery. // </summary> // <param name="connection"> The connection against which this EntityCommand should execute </param> // <param name="entityCommandDefinition"> The prepared command definition that can be executed using this EntityCommand </param> internal EntityCommand( EntityConnection connection, EntityCommandDefinition entityCommandDefinition, DbInterceptionContext context, EntityDataReaderFactory factory = null) : this(entityCommandDefinition, context, factory) { _connection = connection; }
public void Exceptions_from_Underlying_dbConnection_are_wrapped() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Throws( new AggregateException(new InvalidOperationException())); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, dbConnectionMock.Object, true, true); Assert.Equal( Strings.EntityClient_ProviderSpecificError("Open"), Assert.Throws<EntityException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); dbConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once()); }
internal ObjectContextForMock(EntityConnection connection, IEntityAdapter entityAdapter = null) : base(null, null, null, entityAdapter) { _connection = connection; }
/// <summary> /// Constructs the EntityCommand object with the given eSQL statement and the connection object to use /// </summary> /// <param name="statement"> The eSQL command text to execute </param> /// <param name="connection"> The connection object </param> /// <param name="resolver"> Resolver used to resolve DbProviderServices </param> public EntityCommand(string statement, EntityConnection connection, IDbDependencyResolver resolver) : this(statement, connection) { _dependencyResolver = resolver; }
internal EntityCommand(string statement, EntityConnection connection, EntityDataReaderFactory factory) : this(statement, new DbInterceptionContext(), factory) { _connection = connection; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.EntityClient.EntityCommand" /> class with the specified statement, connection and transaction. /// </summary> /// <param name="statement">The text of the command.</param> /// <param name="connection">A connection to the data source.</param> /// <param name="transaction">The transaction in which the command executes.</param> public EntityCommand(string statement, EntityConnection connection, EntityTransaction transaction) : this(statement, connection, transaction, new EntityDataReaderFactory()) { }
internal EntityCommand( string statement, EntityConnection connection, EntityTransaction transaction, EntityDataReaderFactory factory) : this(statement, connection, factory) { _transaction = transaction; }
public bool ConnectionOpening(EntityConnection connection, DbInterceptionContext interceptionContext) { return !interceptionContext.DbContexts.Contains(_context, ReferenceEquals); }
internal EntityCommand(string statement, EntityConnection connection, EntityDataReaderFactory factory) : this(statement, factory) { _connection = connection; }