Пример #1
0
        public void IsInTransaction_Should_Return_False_When_No_Transaction_Exists()
        {
            var mockSession = MockRepository.GenerateStub <ISession>();
            var unitOfWork  = new NHUnitOfWork(mockSession);

            Assert.That(!unitOfWork.IsInTransaction);
        }
Пример #2
0
        public void BasicTest()
        {
            var m = new Monkey();

            m.Name      = "George";
            m.FlingsPoo = true;
            m.Bananas   = new List <Banana>();
            m.Bananas.Add(new Banana()
            {
                Color = "green"
            });
            m.Bananas.Add(new Banana()
            {
                Color = "yellow"
            });

            //Create new Monkey
            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                uow.Save(m);
            }

            //Delete monkey
            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                uow.Delete(m);
            }
        }
Пример #3
0
        public void EmployeeProvideDataTest()
        {
            var uows = new MITD.Domain.Repository.UnitOfWorkScope(
                new Data.NH.NHUnitOfWorkFactory(() => PMSAdmin.Persistence.NH.PMSAdminSession.GetSession()));

            using (var uow = new NHUnitOfWork(PMSSession.GetSession()))
                using (var uow2 = uows.CurrentUnitOfWork)
                {
                    var pmsAdminService = new PMS.ACL.PMSAdmin.PMSAdminService(
                        new PMSAdmin.Application.UnitService(new PMSAdmin.Persistence.NH.UnitRepository(uows), new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
                        new PMSAdmin.Application.JobService(new PMSAdmin.Persistence.NH.JobRepository(uows),
                                                            new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
                        new PMSAdmin.Application.CustomFieldService(new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
                        new PMSAdmin.Application.JobPositionService(new PMSAdmin.Persistence.NH.JobPositionRepository(uows)),
                        new PMSAdmin.Application.JobIndexService(new PMSAdmin.Persistence.NH.JobIndexRepository(uows),
                                                                 new PMSAdmin.Persistence.NH.CustomFieldRepository(uows))
                        ,
                        new PMSAdmin.Application.UnitIndexService(new PMSAdmin.Persistence.NH.UnitIndexRepository(uows),
                                                                  new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)
                                                                  ));
                    var rep      = new PMS.Persistence.NH.EmployeeRepository(uow);
                    var provider = new PMS.Application.CalculationDataProvider(rep, pmsAdminService,
                                                                               new PMS.Persistence.NH.JobIndexPointRepository(uow));
                    var emp = rep.First();
                    MITD.PMSReport.Domain.Model.CalculationData empData;
                    //var data = provider.Provide(emp, out empData);
                }
        }
Пример #4
0
        static void Main(string[] args)
        {
            Account a = new Account("a", 100);

            WriteLine($"name:{a.Name},amount:{a.Balance}");

            Account b = new Account("b", 100);

            WriteLine($"name:{a.Name},amount:{a.Balance}");

            decimal amount = 50M;

            WriteLine($"a to b amount:{amount}");

            IUnitOfWork nhUnitOfWork = new NHUnitOfWork();

            IAccountRepository accountRepository = new AccountRepository(nhUnitOfWork);

            AccountService service = new AccountService(accountRepository, nhUnitOfWork);

            service.Transfer(a, b, amount);

            WriteLine("Transfered");
            WriteLine($"name:{a.Name},amount:{a.Balance}");
            WriteLine($"name:{a.Name},amount:{a.Balance}");

            ReadKey();
        }
Пример #5
0
        public static LibraryService CreateLibraryService()
        {
            IUnitOfWork          uow;
            IBookRepository      bookRespository;
            IBookTitleRepository bookTitleRepository;
            IMemberRepository    memberRespository;

            string persistenceStrategy = ConfigurationManager.AppSettings["PersistenceStrategy"];

            if (persistenceStrategy == "EF")
            {
                uow                 = new EFUnitOfWork();
                bookRespository     = new BookRepository(uow);
                bookTitleRepository = new BookTitleRepository(uow);
                memberRespository   = new MemberRepository(uow);
            }
            else
            {
                uow                 = new NHUnitOfWork();
                bookRespository     = new DataAccessLayerDemo.NHibernate.Repositories.BookRepository(uow);
                bookTitleRepository = new DataAccessLayerDemo.NHibernate.Repositories.BookTitleRepository(uow);
                memberRespository   = new DataAccessLayerDemo.NHibernate.Repositories.MemberRepository(uow);
            }

            return(new LibraryService(uow, bookTitleRepository, bookRespository, memberRespository));
        }
Пример #6
0
        public WarehouseTest()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._warehouseRsponstroy = new WarehouseRepository(uow);
            AutoMapperBootStrapper.ConfigureAutoMapper();
        }
        public WorkflowActivityTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._workflowActivityNodeRepository = new WorkflowActivityNodeRepository(uow);
            this._workflowActivityRepository     = new WorkflowActivityRepository(uow);
        }
Пример #8
0
        private static void CreateAccount(int number, Instrument instrument)
        {
            using var uow = new NHUnitOfWork();
            uow.OpenSession(_currentReadTenantIds);
            uow.BeginTransaction();

            Console.WriteLine(
                $"Creating Account#: {number} under Instrument#: {instrument.Number} for Tenant ID: {_currentWriteTenantId}");

            var account = new Account
            {
                AccountNumber = number,
                Instrument    = instrument
            };

            try
            {
                instrument.AddAccount(account);
                uow.Session.SaveOrUpdate(account);

                uow.Commit();
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine($"Unable to create Account: {ex.Message}");
                uow.Rollback();
            }
        }
Пример #9
0
        public ProductTest()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._productRsponstroy = new ProductRepository(uow);
            AutoMapperBootStrapper.ConfigureAutoMapper();
        }
        public void TestDatapiontRepositoryFindByTEntityKeyMethod()
        {
            NHUnitOfWork        nhUnitOfWork        = new NHUnitOfWork();
            DataPointRepository dataPointRepository = new DataPointRepository(nhUnitOfWork);

            DataPoint dataPoint = dataPointRepository.FindBy(14);
        }
        public void TestDBPersistence()
        {
            var m = new Monkey();

            m.Name      = "George";
            m.FlingsPoo = true;
            m.Bananas   = new List <Banana>();
            m.Bananas.Add(new Banana()
            {
                Color = "green"
            });
            m.Bananas.Add(new Banana()
            {
                Color = "yellow"
            });

            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                uow.Save(m);
            }

            m.Name = "Rachael";

            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                uow.Save(m);
            }

            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                uow.Delete(m);
            }
        }
Пример #12
0
        public SupplierTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._supplierRepository        = new SupplierRepository(uow);
            this._supplierProductRepository = new SupplierProductRepository(uow);
        }
Пример #13
0
 public NHRepository(ISession session, ExceptionManager exManager, ILogger log)
 {
     this.session        = session;
     this.exManager      = exManager;
     this.log            = log;
     this.sessionFactory = NHUnitOfWork.BuildSessionFactory();
 }
Пример #14
0
 public void NHUnitOfWorkDisposeSessionTest()
 {
     var input = new List<IMeasure> { new SimpleMeasure("ReteA", 10U) };
     var loc = _entitiesFactory.CreateLocation("Location1", input);
     var uow = new NHUnitOfWork(_sessionFactory);
     uow.Dispose();
     uow.Save(loc);
 }
Пример #15
0
 public void EmployeeRepTest()
 {
     using (var uow = new NHUnitOfWork(PMSSession.GetSession()))
     {
         var rep = new EmployeeRepository(uow);
         var x   = rep.GetPoints(rep.First(), new CalculationId(10));
     }
 }
Пример #16
0
        public RightsServiceTest()
        {
            IUnitOfWork       uow = new NHUnitOfWork();
            IRightsRepository _rightsRepository = new RightsRepository(uow);

            this._rightsService = new RightsService(_rightsRepository, uow);
            AutoMapperBootStrapper.ConfigureAutoMapper();
        }
Пример #17
0
        public PurchaseOrderTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._purchaseOrderRepoistroy       = new PurchaseOrderRepository(uow);
            this._purchaseOrderDetailRepoistroy = new PurchaseOrderDetailRepository(uow);
            this._purchaseTypeRepoistroy        = new PurchaseTypeRepository(uow);
        }
        public ArrivalReceiptTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._arrivalReceiptRepository       = new ArrivalReceiptRepository(uow);
            this._arrivalReceiptDetailRepository = new ArrivalReceiptDetailRepository(uow);
            this._arrivalNoticeDetailRepository  = new ArrivalNoticeDetailRepository(uow);
            this._arrivalNoticeRepository        = new ArrivalNoticeRepository(uow);
        }
Пример #19
0
        public PaymentTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._paymentTypeRepository = new PaymentTypeRepository(uow);
            this._paymentTypeService    = new PaymentTypeService(this._paymentTypeRepository, uow);

            this._paymentRepository = new PaymentRepository(uow);
            this._paymentService    = new PaymentService(this._paymentRepository, uow);
        }
Пример #20
0
        public ProjectTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._projectRepository           = new ProjectRepository(uow);
            this._projectAttendanceRepository = new ProjectAttendanceRepository(uow);
            this._projectMaterialRepository   = new ProjectMaterialRepository(uow);
            this._projectProductRepository    = new ProjectProductRepository(uow);
            this._projectTypeRepository       = new ProjectTypeRepository(uow);
        }
Пример #21
0
        public InOutBoundTests()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._inOutBoundRepository           = new InOutBoundRepository(uow);
            this._arrivalReceiptRepository       = new ArrivalReceiptRepository(uow);
            this._arrivalReceiptDetailRepository = new ArrivalReceiptDetailRepository(uow);
            this._inOutReasonRepository          = new InOutReasonRepository(uow);
            this._spotInventoryRepository        = new SpotInventoryRepository(uow);
        }
Пример #22
0
        public UsersServiceTest()
        {
            IUnitOfWork      uow = new NHUnitOfWork();
            IUsersRepository _usersRepository = new UsersRepository(uow);

            IOrganizationRepository _organizationRepository = new OrganizationRepository(uow);

            this._userService         = new UsersService(_usersRepository, _organizationRepository, uow);
            this._organizationService = new OrganizationService(_organizationRepository, uow);
            AutoMapperBootStrapper.ConfigureAutoMapper();
        }
Пример #23
0
        public void AdvancedTest()
        {
            //Create new Monkey
            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                var temp = new Monkey();
                temp.Name      = "George";
                temp.FlingsPoo = true;
                temp.Bananas   = new List <Banana>();
                temp.Bananas.Add(new Banana()
                {
                    Color = "green"
                });
                temp.Bananas.Add(new Banana()
                {
                    Color = "yellow"
                });

                uow.Save(temp);
            }

            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                Monkey temp = uow.Get <Monkey>(1);
                Assert.IsTrue(temp.Name == "George" && temp.Bananas[1].Color == "yellow");
            }

            //Modify monkey
            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                Monkey temp = uow.Get <Monkey>(1);
                temp.Name = "Bill";
                uow.Save(temp);
            }

            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                Monkey temp = uow.Get <Monkey>(1);
                Assert.IsTrue(temp.Name == "Bill");
            }

            //Delete monkey
            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                Monkey temp = uow.Get <Monkey>(1);
                uow.Delete(temp);
            }

            using (var uow = new NHUnitOfWork(Properties.Settings.Default.DBConnStr))
            {
                Monkey temp = uow.Get <Monkey>(1);
                Assert.IsNull(temp);
            }
        }
Пример #24
0
        public void BeginTransaction_Throws_InvalidOperationException_When_Transaction_Already_Running()
        {
            var mockSession = MockRepository.GenerateStub<ISession>();
            mockSession.Stub(x => x.BeginTransaction(IsolationLevel.Unspecified))
                .IgnoreArguments().Return(MockRepository.GenerateStub<global::NHibernate.ITransaction>());

            var unitOfWork = new NHUnitOfWork(mockSession);
            unitOfWork.BeginTransaction();

            Assert.That(unitOfWork.IsInTransaction);
            Assert.Throws<InvalidOperationException>(() => unitOfWork.BeginTransaction());
        }
Пример #25
0
        public MapaController()
        {
            var unitOfWorkRepository = new NHUnitOfWorkRepository <Mapa>();
            var unitOfWork           = new NHUnitOfWork <Mapa>(unitOfWorkRepository);
            var mapaRepository       = new MapaRepository(unitOfWork);

            this._mapaServices = new MapaServices(mapaRepository);

            var fileRepostory = new MapaFileRepository();

            this._fileServices = new FileServices(fileRepostory);
        }
Пример #26
0
        public void LogServiceTest()
        {
            //LocatorCreator.Execute();



            var container = new WindsorContainer();

            container.Register(Component.For <ILoggerService>().ImplementedBy <DbLoggerService>().LifeStyle.BoundTo <IService>());
            //container.Register(Component.For<ILogRepository>().ImplementedBy<LogRepository>().LifeStyle.Transient);

            container.Register(Component.For <IConnectionProvider>()
                               .UsingFactoryMethod(c => new ConnectionProvider(() =>
            {
                var s = System.Configuration.ConfigurationManager.
                        ConnectionStrings["PMSDBConnection"].ConnectionString;
                var res = new SqlConnection(s);
                res.Open();
                return(res);
            })).LifestyleBoundTo <IService>());

            DataAccessConfigHelper.ConfigureContainer <UserRepository>(container,
                                                                       () =>
            {
                var session = PMSSecuritySession.GetSession(container.Resolve <IConnectionProvider>().GetConnection());
                return(session);
            }, "PMSSecurity");

            var locator = new WindsorServiceLocator(container);

            ServiceLocator.SetLocatorProvider(() => locator);

            //var userRep = ServiceLocator.Current.GetInstance<UserRepository>();


            var uows = new MITD.Domain.Repository.UnitOfWorkScope(
                new Data.NH.NHUnitOfWorkFactory(() => PMSSecurity.Persistence.NH.PMSSecuritySession.GetSession()));



            using (var uow = new NHUnitOfWork(PMSSession.GetSession()))
                using (var uow2 = uows.CurrentUnitOfWork)
                {
                    var logFactory = new LoggerServiceFactory();
                    var logManager = new LogManagerService(logFactory);
                    var logService = new LogService(logManager);

                    var gid = Guid.NewGuid();
                    Log log = new EventLog(new LogId(gid), "diddd", LogLevel.Information, null, "clll", "mett", "ttttt", "mmmmmmm");

                    logService.AddEventLog(log.Code, log.LogLevel, null, log.ClassName, log.MethodName, log.Title, log.Messages);
                }
        }
Пример #27
0
        public void Flush_Calls_Underlying_ISession_Flush()
        {
            var mockSession = MockRepository.GenerateMock <ISession>();

            mockSession.Expect(x => x.Flush());

            var unitOfWork = new NHUnitOfWork(mockSession);

            unitOfWork.Flush();

            mockSession.VerifyAllExpectations();
        }
        public static void ReloadData()
        {
            var session = CurrencyAndMeasurementSession.GetSession();
            var uow = new NHUnitOfWork(session);
            var transaction = new NHTransactionHandler();
            var configurator = new AggregateRootConfigurator(new TIBA.Core.EventPublisher());
            //create an uomType before create uom
            var nhExMap = new NHRepositoryExceptionMapper(new List<System.Tuple<DBActionType, string, Exception>>());

            var target = new UnitOfMeasureRepository(transaction, uow, nhExMap, configurator);

            UnitOfMeasureParserHelper.RegisterParsersFromRepository(target);
        }
Пример #29
0
 private void initialized()
 {
     using (var uow = new NHUnitOfWork(PMSSession.GetSession()))
     {
         var periodRep = new PeriodRepository(uow);
         for (int i = 0; i < 5; i++)
         {
             var period = new Period(new PeriodId(periodRep.GetNextId()), "Test", DateTime.Now, DateTime.Now, 91);
             periodRep.Add(period);
         }
         uow.Commit();
     }
 }
Пример #30
0
 public void can_create_payroll_of_active_employees()
 {
     using (var uow = new NHUnitOfWork()) {
         var ees    = _employees.FetchAllActive();
         var actual = ees.Count;
         var pr     = PayrollReport.Create(ees, Date.Now);
         EventBroker.getInstance().Command(new CommandIncludeSalaryDeductionInReport(pr));
         Assert.True(ees.Count > 0);
         Assert.Equal(pr.Records.Count, actual);
         _payrolls.Save(pr);
         uow.Commit();
     }
 }
Пример #31
0
        public void BeginTransaction_Throws_InvalidOperationException_When_Transaction_Already_Running()
        {
            var mockSession = MockRepository.GenerateStub <ISession>();

            mockSession.Stub(x => x.BeginTransaction(IsolationLevel.Unspecified))
            .IgnoreArguments().Return(MockRepository.GenerateStub <global::NHibernate.ITransaction>());

            var unitOfWork = new NHUnitOfWork(mockSession);

            unitOfWork.BeginTransaction();

            Assert.That(unitOfWork.IsInTransaction);
            Assert.Throws <InvalidOperationException>(() => unitOfWork.BeginTransaction());
        }
Пример #32
0
        public SupplierTests()
        {
            AutoMapperBootStrapper.ConfigureAutoMapper();
            IUnitOfWork uow = new NHUnitOfWork();

            this._supplierProductRepository = new SupplierProductRepository(uow);
            this._supplierProductService    = new SupplierProductService(this._supplierProductRepository, uow);

            this._usersRepository   = new UsersRepository(uow);
            this._productRepository = new ProductRepository(uow);

            this._supplierRepository = new SupplierRepository(uow);
            this._supplierService    = new SupplierService(this._supplierRepository, this._usersRepository, this._productRepository, uow);
        }
Пример #33
0
        public InOutBoundTest()
        {
            IUnitOfWork uow = new NHUnitOfWork();

            this._outBoundRsponstroy       = new OutBoundRepository(uow);
            this._inBoundRsponstroy        = new InBoundRepository(uow);
            this._inOutBoundRsponstroy     = new InOutBoundRepository(uow);
            this._productRepository        = new ProductRepository(uow);
            this._warehouseRepository      = new WarehouseRepository(uow);
            this._warehouseShelfRepository = new WarehouseShelfRepository(uow);
            this._inOutBoundService        = new InOutBoundService(_inOutBoundRsponstroy, _outBoundRsponstroy, _inBoundRsponstroy, _productRepository, _warehouseRepository, _warehouseShelfRepository, uow);

            AutoMapperBootStrapper.ConfigureAutoMapper();
        }
Пример #34
0
        public void Begin_Transaction_Should_Start_A_New_Transaction_With_Default_IsolationLevel()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            var mockTransaction = MockRepository.GenerateStub<global::NHibernate.ITransaction>();

            mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
                        .Return(mockTransaction);

            var unitOfWork = new NHUnitOfWork(mockSession);
            Assert.That(!unitOfWork.IsInTransaction);
            unitOfWork.BeginTransaction();

            Assert.That(unitOfWork.IsInTransaction);
            mockSession.VerifyAllExpectations();
        }
Пример #35
0
        public void GetSessionFor_returns_different_session_for_types_handled_by_different_factory()
        {
            var resolver = new Mock<INHSessionResolver>();
            resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
            resolver.Setup(x => x.GetSessionKeyFor<int>()).Returns(Guid.NewGuid());
            resolver.Setup(x => x.OpenSessionFor<string>()).Returns(new Mock<ISession>().Object);
            resolver.Setup(x => x.OpenSessionFor<int>()).Returns(new Mock<ISession>().Object);

            var unitOfWork = new NHUnitOfWork(resolver.Object);
            var stringSession = unitOfWork.GetSession<string>();
            var intSession = unitOfWork.GetSession<int>();

            Assert.AreNotSame(stringSession, intSession);
            resolver.Verify(x => x.GetSessionKeyFor<string>());
            resolver.Verify(x => x.GetSessionKeyFor<int>());
            resolver.Verify(x => x.OpenSessionFor<string>());
            resolver.Verify(x => x.OpenSessionFor<int>());
        }
Пример #36
0
        public void Flush_calls_flush_on_all_open_ISession_instances()
        {
            var resolver = new Mock<INHSessionResolver>();
            resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
            resolver.Setup(x => x.GetSessionKeyFor<int>()).Returns(Guid.NewGuid());
            var session = new Mock<ISession>();
            resolver.Setup(x => x.OpenSessionFor<string>()).Returns(session.Object);
            resolver.Setup(x => x.OpenSessionFor<int>()).Returns(session.Object);

            var unitOfWork = new NHUnitOfWork(resolver.Object);
            unitOfWork.GetSession<string>();
            unitOfWork.GetSession<int>();

            unitOfWork.Flush();
            resolver.Object.OpenSessionFor<string>();
            session.Verify(x => x.Flush());
            resolver.Object.OpenSessionFor<int>();
            session.Verify(x => x.Flush());
        }
Пример #37
0
        public void GetSessionFor_returns_session_for_type()
        {
            var resolver = new Mock<INHSessionResolver>();
            resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
            resolver.Setup(x => x.OpenSessionFor<string>()).Returns(new Mock<ISession>().Object);

            var unitOfWork = new NHUnitOfWork(resolver.Object);
            var session = unitOfWork.GetSession<string>();
            Assert.IsNotNull(session);
        }
Пример #38
0
        public void Flush_Calls_Underlying_ISession_Flush()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            mockSession.Expect(x => x.Flush());

            var unitOfWork = new NHUnitOfWork(mockSession);
            unitOfWork.Flush();

            mockSession.VerifyAllExpectations();
        }
Пример #39
0
        public void IsInTransaction_Should_Return_False_When_No_Transaction_Exists()
        {
            var mockSession = MockRepository.GenerateStub<ISession>();
            var unitOfWork = new NHUnitOfWork(mockSession);

            Assert.That(!unitOfWork.IsInTransaction);
        }
Пример #40
0
        public void TransactionalFlush_Rollsback_Transaction_When_Flush_Throws_Exception()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            var mockTransaction = MockRepository.GenerateMock<global::NHibernate.ITransaction>();

            mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
                                        .Return(mockTransaction);
            mockSession.Expect(x => x.Flush()).Throw(new Exception());

            mockTransaction.Expect(x => x.Rollback());

            var unitOfWork = new NHUnitOfWork(mockSession);
            Assert.Throws<Exception>(unitOfWork.TransactionalFlush);

            mockSession.VerifyAllExpectations();
            mockTransaction.VerifyAllExpectations();
        }
Пример #41
0
        public void TransactionalFlush_Starts_A_Transaction_With_Specified_IsolationLevel_And_Commits_When_Flush_Succeeds()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            var mockTransaction = MockRepository.GenerateMock<global::NHibernate.ITransaction>();

            mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadUncommitted))
                                        .Return(mockTransaction);
            mockSession.Expect(x => x.Flush());

            mockTransaction.Expect(x => x.Commit());

            var unitOfWork = new NHUnitOfWork(mockSession);
            unitOfWork.TransactionalFlush(IsolationLevel.ReadUncommitted);

            mockSession.VerifyAllExpectations();
            mockTransaction.VerifyAllExpectations();
        }
Пример #42
0
        public void TransactionalFlush_Uses_Existing_Transaction_When_Transactional_AlreadyRunning()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            var mockTransaction = MockRepository.GenerateMock<global::NHibernate.ITransaction>();

            mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
                       .Return(mockTransaction)
                       .Repeat.Once(); //Expect BeginTransaction to be called only once.

            var unitOfWork = new NHUnitOfWork(mockSession);
            unitOfWork.BeginTransaction();
            unitOfWork.TransactionalFlush();

            mockSession.VerifyAllExpectations();
            mockTransaction.VerifyAllExpectations();
        }
Пример #43
0
        public void NHUnitOfWorkOperationsTest()
        {
            //CREATE = SAVE AND COMMIT
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                // populate the database
                var input = new List<IMeasure> { new SimpleMeasure("ReteA", 10U) };
                var loc = _entitiesFactory.CreateLocation("Location1", input);
                loc.TotalTime = TimeVal;

                var input2 = new List<IMeasure> { new SimpleMeasure("ReteB", 50U), new SimpleMeasure("ReteC", 100U) };
                var loc2 = _entitiesFactory.CreateLocation("Location2", input2);
                loc2.TotalTime = TimeVal1;

                //this saves everything else via cascading
                uow.Save(loc);
                uow.Save(loc2);

                uow.Commit();
            }

            // READ =
            // Get, GetLocationByName and GetAll
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                var locA = uow.GetLocationByName("Location1");
                Assert.AreEqual(locA.Name, "Location1");
                Assert.AreEqual(locA.TotalTime, TimeVal);

                var locB = uow.Get<Location>(locA.Id);
                Assert.AreEqual(locB.Name, "Location1");
                Assert.AreEqual(locB.TotalTime, TimeVal);

                IList<Location> locations = uow.GetAll<Location>();
                Assert.AreEqual(locations.Count, 2);
                foreach (var location in locations)
                {
                    //For a visual feedback
                    Console.WriteLine(location.ToString());
                    if (location.Name == "Location1")
                    {
                        Assert.AreEqual(location.TotalTime, TimeVal);
                    }
                    else if (location.Name == "Location2")
                    {
                        Assert.AreEqual(location.TotalTime, TimeVal1);
                    }
                    else
                    {
                        Log.Debug(location.Name);
                        Assert.Fail("Location name not matching");
                    }
                }

                var networks = uow.GetAll<Network>();
                Assert.AreEqual(networks.Count, 3);

                uow.Commit();
            }

            Location longLivedLocation;
            const string locName = "Location1";

            // UPDATE = SAVE AND COMMIT
            // update within a single unit of work
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                longLivedLocation = uow.GetLocationByName(locName);
                longLivedLocation.TotalTime = TimeVal2;
                uow.Commit();
            }

            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                var locB = uow.Get<Location>(longLivedLocation.Id);
                Assert.AreEqual(locB.TotalTime, TimeVal2);
            }

            // update of an entity retrieved in a unit of work
            // BEWARE OF DIRTY WRITES!!! THEY ARE STILL DIFFERENT TRANSACTIONS!!!
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                longLivedLocation.TotalTime = TimeVal3;
                uow.Save(longLivedLocation);
                uow.Commit();
            }

            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                var tmp = uow.GetLocationByName(locName);
                Assert.AreEqual(tmp.TotalTime, TimeVal3);
                uow.Commit();
            }

            // ROLLBACK
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                longLivedLocation = uow.GetLocationByName("Location1");
                longLivedLocation.TotalTime = TimeVal4;

                var input = new List<IMeasure> { new SimpleMeasure("ReteC", 10U) };
                var loc = _entitiesFactory.CreateLocation("Location3", input);
                loc.TotalTime = TimeVal;
                uow.Save(loc);

                uow.Rollback();
            }

            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                var locB = uow.Get<Location>(longLivedLocation.Id);
                //old value
                Assert.AreEqual(locB.TotalTime, TimeVal3);

                var locations = uow.GetAll<Location>();
                Assert.AreEqual(locations.Count, 2);
                foreach (var location in locations)
                {
                    if(location.Name!="Location1" && location.Name!="Location2")
                    {
                        Log.Debug(location.Name);
                        Assert.Fail("Location added in rollbacked unit of work");
                    }
                }
            }

            // LAZY LOADING
            // It seems it does not work (always eager loading). Less performances, zero problems...
            // Check it by hand, looking at logs
            Log.Debug("LAZY LOADING");
            Location locLazy;
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                locLazy = uow.GetLocationByName("Location1");
            }
            Assert.AreEqual(locLazy.Name, "Location1");
            Assert.AreEqual(locLazy.TotalTime, TimeVal3);

            var up = new List<IMeasure> { new SimpleMeasure("ReteA", 20U) };
            locLazy.UpdateStats(up);
            Log.Debug(locLazy.ToString());

            IList<Location> locLazies;
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                locLazies = uow.GetAll<Location>();
            }

            up = new List<IMeasure> { new SimpleMeasure("ReteA", 10U), new SimpleMeasure("ReteB", 40U) };
            locLazies[1].UpdateStats(up);
            Log.Debug(locLazies[1].ToString());

            // DELETE
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                var locations = uow.GetAll<Location>();

                    foreach (var location in locations)
                    {
                        uow.Delete(location);
                    }

                    uow.Commit();
            }

            // check deletion cascade
            using (var uow = new NHUnitOfWork(_sessionFactory))
            {
                var locations = uow.GetAll<Location>();
                Assert.AreEqual(locations.Count, 0);

                var networks = uow.GetAll<Network>();
                Assert.AreEqual(networks.Count, 0);
            }
        }
Пример #44
0
        public void Comitting_Transaction_Releases_Transaction_From_UnitOfWork()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
                       .Return(MockRepository.GenerateStub<global::NHibernate.ITransaction>());

            var unitOfWork = new NHUnitOfWork(mockSession);
            var transaction = unitOfWork.BeginTransaction();

            Assert.That(unitOfWork.IsInTransaction);
            transaction.Commit();
            Assert.That(!unitOfWork.IsInTransaction);
            mockSession.VerifyAllExpectations();
        }
Пример #45
0
        public void Dispose_UnitOfWork_Disposed_Underlying_Transaction_And_Session()
        {
            var mockSession = MockRepository.GenerateMock<ISession>();
            var mockTransaction = MockRepository.GenerateMock<global::NHibernate.ITransaction>();
            mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
                       .Return(mockTransaction);
            mockTransaction.Expect(x => x.Dispose());
            mockSession.Expect(x => x.Dispose());

            using (var unitOfWork = new NHUnitOfWork(mockSession))
            {
                unitOfWork.BeginTransaction();
            }
            mockSession.VerifyAllExpectations();
            mockTransaction.VerifyAllExpectations();
        }
Пример #46
0
 public void NHUnitOfWorkDisposeTransactionTest()
 {
     var uow = new NHUnitOfWork(_sessionFactory);
     uow.Dispose();
     uow.Commit();
 }