public static void Transaction(Action action) { using (GlobalTransactionManager.BeginTransaction()) { action(); } }
public void BasicTransactionCommitt() { using (GlobalTransactionManager.BeginTransaction()) { Int32 count = DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test')").ExecuteNonQuery(); Assert.That(count, Is.EqualTo(1)); } DbAssert.OnQuery("Select count(*) cnt from FirstTable").That("cnt", Is.EqualTo(1)).ExecuteAssert(); }
public void ContextNestedWithTwoTransactionLast() { GlobalTransactionManager.BeginTransaction(); GlobalTransactionManager.BeginTransaction(); GlobalTransactionManager.TransactionToken token = GlobalTransactionManager.Enlist(Nope); GlobalTransactionManager.TransactionContext.Set("key", "test", 1); Assert.That(token.GetFromTransactionContext("key"), Is.EqualTo("test")); }
public void VerifyThatSessionIsDisposedWhenRollbackOccurredEvenIfCreatedOutsideTransaction() { ISession session1 = NHibernateSessionManager.GetSessionFor("files\\NhConfigFile1.cfg.xml"); using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.DoomCurrentTransaction(); } Assert.That(session1.IsOpen, Is.False); }
/// <summary> /// This is the Connetion creation function, this function should enlist in the /// current transaction as well reusing the same connection for all the call /// inside a global transaction to consume less resources. /// </summary> /// <param name="connectionName"></param> /// <returns></returns> internal static GlobalTransactionManager.TransactionToken CreateConnection(string connectionName) { ConnectionData newConnData = null; if (GlobalTransactionManager.IsInTransaction) { //We are in a transaction, check if at current connection stack level there is a connection data. Object connData = GlobalTransactionManager.TransactionContext.Get(GetKeyFromConnName(connectionName)); if (null != connData) { //We already created the connection for this database in this transaction. return(GlobalTransactionManager.Enlist(DoNothing)); } //There is not a transaction in the current transaction stack level, are we in nested transaction? if (GlobalTransactionManager.TransactionsCount > 1) { //The only connection data valid is the one at the first level, lets check if it is present. connData = GlobalTransactionManager.TransactionContext.Get(GetKeyFromConnName(connectionName), 0); if (null == connData) { //We never created the connection data newConnData = new ConnectionData(connectionName); GlobalTransactionManager.TransactionContext.Set(GetKeyFromConnName(connectionName), newConnData, 0); GlobalTransactionManager.Enlist(newConnData.CloseConnection, 0); } else { newConnData = (ConnectionData)connData; } GlobalTransactionManager.TransactionToken lasttoken = null; //Now we have the connection data, we need to store this connection data in each connection that is active and //that still not have start a transaction for (Int32 Ix = 1; Ix < GlobalTransactionManager.TransactionsCount; ++Ix) { if (GlobalTransactionManager.TransactionContext.Get(GetKeyFromConnName(connectionName), Ix) == null) { //In this step of the stack there is no ConnectionData, store and increase the transaction newConnData.BeginNestedTransaction(); lasttoken = GlobalTransactionManager.Enlist(newConnData.CloseConnection, Ix); lasttoken.SetInTransactionContext(GetKeyFromConnName(connectionName), newConnData); } } //Return the last token, the one corresponding to the current transaction level. return(lasttoken); } } //We are not in nested transaction and there is not connection data, create for the first time newConnData = new ConnectionData(connectionName); GlobalTransactionManager.TransactionToken token = GlobalTransactionManager.Enlist(newConnData.CloseConnection); token.SetInTransactionContext(GetKeyFromConnName(connectionName), newConnData); return(token); }
public void GoodTransactionIsCommitted() { Action <Boolean> mock = mockRepository.CreateMock <Action <Boolean> >(); mock(true); //Sets the expectation mockRepository.ReplayAll(); using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.Enlist(mock); } }
public void VerifyTransactionClosedDoomedFalse() { ITranEvSink mock = mockRepository.CreateMock <ITranEvSink>(); Expect.Call(() => mock.Handle(null, null)) .Constraints(RhinoIs.Null(), RhinoIs.Matching <TransactionClosedEventArgs>(args => args.IsDoomed == false)); GlobalTransactionManager.TransactionClosed += mock.Handle; ExecuteAtTheEndOfTest(() => GlobalTransactionManager.TransactionClosed -= mock.Handle); mockRepository.ReplayAll(); GlobalTransactionManager.BeginTransaction().Dispose(); }
public void DoomedTransactionIsRollbacked() { Action <Boolean> mock = mockRepository.CreateMock <Action <Boolean> >(); mock(false); //Sets the expectation mockRepository.ReplayAll(); using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.Enlist(mock); GlobalTransactionManager.DoomCurrentTransaction(); } }
public void VerifyTransactionClosed() { ITranEvSink mock = mockRepository.CreateMock <ITranEvSink>(); Expect.Call(() => mock.Handle(null, EventArgs.Empty)) .IgnoreArguments() .Callback(new Func <Object, EventArgs, Boolean>((sender, e) => GlobalTransactionManager.TransactionsCount == 0)); GlobalTransactionManager.TransactionClosed += mock.Handle; ExecuteAtTheEndOfTest(() => GlobalTransactionManager.TransactionClosed -= mock.Handle); mockRepository.ReplayAll(); GlobalTransactionManager.BeginTransaction().Dispose(); }
public void EnlistWithoutATransaction() { Action <Boolean> mock = mockRepository.CreateMock <Action <Boolean> >(); mock(true); //Sets the expectation mockRepository.ReplayAll(); using (GlobalTransactionManager.Enlist(mock)) { //Do something, the important thing is that the delegate is called because we have //not a transaction active. } }
public void EnlistNestedWithTwoTransactionDisposeTwo() { Action <Boolean> mock = mockRepository.CreateMock <Action <Boolean> >(); Expect.Call(() => mock(true)).Repeat.Once(); //Sets the expectation mockRepository.ReplayAll(); IDisposable first = GlobalTransactionManager.BeginTransaction(); IDisposable second = GlobalTransactionManager.BeginTransaction(); GlobalTransactionManager.Enlist(mock, 0); GlobalTransactionManager.Enlist(mock, 1); second.Dispose(); }
public void VerifyTransactionClosingDoomedTrue() { ITranEvSink mock = mockRepository.CreateMock <ITranEvSink>(); Expect.Call(() => mock.Handle(null, null)) .Constraints(RhinoIs.Null(), RhinoIs.Matching <TransactionClosingEventArgs>(args => args.IsDoomed == true)); GlobalTransactionManager.TransactionClosing += mock.Handle; ExecuteAtTheEndOfTest(() => GlobalTransactionManager.TransactionClosing -= mock.Handle); mockRepository.ReplayAll(); using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.DoomCurrentTransaction(); } }
public void EnlistNestedWithTwoTransaction() { Action <Boolean> mock = mockRepository.CreateMock <Action <Boolean> >(); Expect.Call(() => mock(true)).Repeat.Twice(); //Sets the expectation mockRepository.ReplayAll(); using (GlobalTransactionManager.BeginTransaction()) { using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.Enlist(mock, 0); GlobalTransactionManager.Enlist(mock, 1); } } }
public void DistinctDbTransactionAccessInTransaction() { using (GlobalTransactionManager.BeginTransaction()) { DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test')") .ExecuteNonQuery(); DataAccess.OnDb("secondary") .CreateQuery("Insert into SecondaryFirstTable (field1, field2) values (1, 'test')") .ExecuteNonQuery(); //VErify that in transaction all data is queryable DbAssert.OnQuery("Select count(*) cnt from FirstTable").That("cnt", Is.EqualTo(1)).ExecuteAssert(); DbAssert.OnDb("secondary").WithQuery("Select count(*) cnt from SecondaryFirstTable").That("cnt", Is.EqualTo(1)).ExecuteAssert(); GlobalTransactionManager.DoomCurrentTransaction(); } }
public void IgnoreExceptionWhenCommitt() { Action <Boolean> mock1 = mockRepository.CreateMock <Action <Boolean> >(); mock1(true); //Sets the expectation LastCall.Throw(new ApplicationException()); Action <Boolean> mock2 = mockRepository.CreateMock <Action <Boolean> >(); mock2(true); //Sets the expectation mockRepository.ReplayAll(); using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.Enlist(mock1); GlobalTransactionManager.Enlist(mock2); } }
public void TestEnlistInGlobalTransaction() { Int32 insertedId; using (GlobalTransactionManager.BeginTransaction()) { using (ISession session = NHibernateSessionManager.GetSessionFor("files\\NhConfigFile1.cfg.xml")) { AnEntity e = AnEntity.CreateSome(); insertedId = (Int32)session.Save(e); } GlobalTransactionManager.DoomCurrentTransaction(); } DbAssert.OnQuery("select count(*) cnt from AnEntity where id = {id}") .SetInt32Param("id", insertedId) .That("cnt", Is.EqualTo(0)).ExecuteAssert(); }
public void MultipleTransactionRollbackAndCommit() { using (GlobalTransactionManager.BeginTransaction()) { using (GlobalTransactionManager.BeginTransaction()) { DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test1')").ExecuteNonQuery(); GlobalTransactionManager.DoomCurrentTransaction(); } DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test2')").ExecuteNonQuery(); } //inner transaction is rollbacked, but the external one no, so I should see second row DbAssert.OnQuery("Select count(*) cnt from FirstTable") .That("cnt", Is.EqualTo(1)).ExecuteAssert(); DbAssert.OnQuery("Select field2 from FirstTable") .That("field2", Is.EqualTo("test2")).ExecuteAssert(); }
public void TestEnlistInGlobalTransactionRead() { Int32 insertedId; using (GlobalTransactionManager.BeginTransaction()) { using (ISession session = NHibernateSessionManager.GetSessionFor("files\\NhConfigFile1.cfg.xml")) { AnEntity e = AnEntity.CreateSome(); insertedId = (Int32)session.Save(e); } //We are still in the transaction, ensure we can read the db in the same transaction DbAssert.OnDb("main").WithQuery("select count(*) cnt from AnEntity where id = {id}") .SetInt32Param("id", insertedId) .That("cnt", Is.EqualTo(1)).ExecuteAssert(); } }
public void MultipleTransactionBothRollback() { using (GlobalTransactionManager.BeginTransaction()) { using (GlobalTransactionManager.BeginTransaction()) { Int32 count = DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test1')").ExecuteNonQuery(); Assert.That(count, Is.EqualTo(1)); } using (GlobalTransactionManager.BeginTransaction()) { Int32 count = DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (2, 'test2')").ExecuteNonQuery(); Assert.That(count, Is.EqualTo(1)); } GlobalTransactionManager.DoomCurrentTransaction(); } DbAssert.OnQuery("Select count(*) cnt from FirstTable").That("cnt", Is.EqualTo(0)).ExecuteAssert(); }
public void MultipleTransactionSeeDataCommittedInNested() { using (GlobalTransactionManager.BeginTransaction()) { using (GlobalTransactionManager.BeginTransaction()) { Int32 count = DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test1')").ExecuteNonQuery(); Assert.That(count, Is.EqualTo(1)); } //First transaction is committed I should see data into db GlobalTransactionManager.DoomCurrentTransaction(); DbAssert.OnQuery("Select count(*) cnt from FirstTable") .That("cnt", Is.EqualTo(1)).ExecuteAssert(); } //Transaction is doomed, so the row disappeared DbAssert.OnQuery("Select count(*) cnt from FirstTable") .That("cnt", Is.EqualTo(0)).ExecuteAssert(); }
public void ImplicitTransactionIsDoomedIfExceptionIsThrown() { Action <Boolean> mock = mockRepository.CreateMock <Action <Boolean> >(); mock(false); //Sets the expectation mockRepository.ReplayAll(); try { using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.Enlist(mock); throw new ApplicationException(); } } catch (ApplicationException) { //Ok we catch the exception but the inner using is exited inside an application handler. } }
public void LogExceptionWhenCommitt() { Action <Boolean> mock1 = mockRepository.CreateMock <Action <Boolean> >(); Exception ex = new ArgumentException(); Expect.Call(() => mock1(true)).Throw(ex); //Sets the expectation ILogger mockLogger = mockRepository.CreateMock <ILogger>(); Expect.Call(mockLogger.ActualLevel).Repeat.Any().Return(LogLevel.Info); Expect.Call(() => mockLogger.LogError("", ex)) .Constraints(RhinoIs.Anything(), RhinoIs.Equal(ex)); mockRepository.ReplayAll(); using (Logger.Override(mockLogger)) { using (GlobalTransactionManager.BeginTransaction()) { GlobalTransactionManager.Enlist(mock1); } } }
public void TestEnlistInGlobalTransactionReadDataAccessWrittenData() { Int32 insertedId; using (GlobalTransactionManager.BeginTransaction()) { Int32 newId = GetNewId(); DataAccess.OnDb("main") .CreateQuery("insert into AnEntity (id, name, value) values ({pid}, {pname}, {pvalue})") .SetInt32Param("pid", newId) .SetStringParam("pname", "xxx") .SetInt32Param("pvalue", 108) .ExecuteNonQuery(); using (ISession session = NHibernateSessionManager.GetSessionFor("files\\NhConfigFile1.cfg.xml")) { AnEntity e = session.Load <AnEntity>(newId); Assert.That(e.Name, Is.EqualTo("xxx")); Assert.That(e.Value, Is.EqualTo(108)); } } }
public void DistinctDbTransactionExceptionRollback() { try { using (GlobalTransactionManager.BeginTransaction()) { Int32 count = DataAccess.CreateQuery("Insert into FirstTable (field1, field2) values (1, 'test')").ExecuteNonQuery(); Assert.That(count, Is.EqualTo(1)); count = DataAccess.OnDb("secondary") .CreateQuery("Insert into SecondaryFirstTable (field1, field2) values (1, 'test')") .ExecuteNonQuery(); Assert.That(count, Is.EqualTo(1)); throw new ApplicationException(); } } catch { } DbAssert.OnQuery("Select count(*) cnt from FirstTable").That("cnt", Is.EqualTo(0)).ExecuteAssert(); DbAssert.OnDb("secondary").WithQuery("Select count(*) cnt from SecondaryFirstTable").That("cnt", Is.EqualTo(0)).ExecuteAssert(); }
public void TestSessionCanWorkWhenTransactionIsClosed() { Int32 insertedId; using (ISession session = NHibernateSessionManager.GetSessionFor("files\\NhConfigFile1.cfg.xml")) { using (GlobalTransactionManager.BeginTransaction()) { AnEntity e = AnEntity.CreateSome(); session.Save(e); session.Flush(); } //Now the transaction is closed, session still need to work correctly AnEntity e1 = AnEntity.CreateSome(); insertedId = (Int32)session.Save(e1); session.Flush(); } //Need to see the second entity DbAssert.OnQuery("select count(*) cnt from AnEntity where id = {id}") .SetInt32Param("id", insertedId) .That("cnt", Is.EqualTo(1)).ExecuteAssert(); }
public void TransactionInContext() { GlobalTransactionManager.BeginTransaction(); Assert.That(overrideContext.storage.Count, Is.EqualTo(1)); }
public void TransactionIsInTransaction() { GlobalTransactionManager.BeginTransaction(); Assert.That(GlobalTransactionManager.IsInTransaction); }
protected virtual void OnTestSetUp() { scope = GlobalTransactionManager.BeginTransaction(); }