public void Repository_For_Uses_Registered_Fetching_Strategies() { IEnumerable <Order> orders; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var strategies = new IFetchingStrategy <Order, LinqToSqlRepositoryTests>[] { new OrderOrderItemsStrategy(), new OrderItemsProductStrategy() }; IRepository <Order> ordersRepository = null; ServiceLocator.Current.Expect( x => x.GetAllInstances <IFetchingStrategy <Order, LinqToSqlRepositoryTests> >()) .Return(strategies); ordersRepository = new LinqToSqlRepository <Order>().For <LinqToSqlRepositoryTests>(); orders = (from o in ordersRepository select o).ToList(); } orders.ForEach(x => Assert.That(x.CalculateTotal(), Is.GreaterThan(0))); }
public void Save_Updates_Existing_Order_Record() { int orderIDRetrieved; var updatedDate = DateTime.Now; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); using (var scope = new UnitOfWorkScope()) { var order = new LinqToSqlRepository <Order>().FirstOrDefault(); Assert.That(order, Is.Not.Null); orderIDRetrieved = order.OrderID; order.OrderDate = updatedDate; scope.Commit(); } using (new UnitOfWorkScope()) { var orderRepository = new LinqToSqlRepository <Order>(); var order = (from o in orderRepository where o.OrderID == orderIDRetrieved select o).FirstOrDefault(); Assert.That(order, Is.Not.Null); Assert.That(order.OrderDate.Value.Date, Is.EqualTo(updatedDate.Date)); Assert.That(order.OrderDate.Value.Hour, Is.EqualTo(updatedDate.Hour)); Assert.That(order.OrderDate.Value.Minute, Is.EqualTo(updatedDate.Minute)); Assert.That(order.OrderDate.Value.Second, Is.EqualTo(updatedDate.Second)); } } }
public void Query_With_No_UnitOfWork_Throws_InvalidOperationException() { Assert.Throws <InvalidOperationException>( () => { var repository = new LinqToSqlRepository <Customer> { new Customer() }; }); }
public void UnitOfWork_Is_Rolledback_When_Containing_TransactionScope_Is_Rolledback() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); int orderId; DateTime?oldDate; using (var txScope = new TransactionScope(TransactionScopeOption.Required)) using (var uowScope = new UnitOfWorkScope(IsolationLevel.Serializable)) { var ordersRepository = new LinqToSqlRepository <Order>(); var order = (from o in ordersRepository select o).First(); oldDate = order.OrderDate; order.OrderDate = DateTime.Now; orderId = order.OrderID; uowScope.Commit(); } using (var uowScope = new UnitOfWorkScope()) { var ordersRepository = new LinqToSqlRepository <Order>(); var order = (from o in ordersRepository where o.OrderID == orderId select o).First(); Assert.That(order.OrderDate, Is.EqualTo(oldDate)); } } }
public void Delete_Method() { Assert.Throws<ArgumentNullException>(() => new LinqToSqlRepository<TestEntity>(this.Connection()).Delete(null)); var entity = new TestEntity(); using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.Throws<InvalidOperationException>(() => repository.Delete(entity)); Assert.False(repository.Persist(entity).Delete(entity).Commit().Any()); } }
public void Query_Throws_Exception_When_LazyLoading_After_UnitOfWork_Is_Finished() { Customer customer; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateCustomer()); var customerRepository = new LinqToSqlRepository <Customer>(); customer = (from cust in customerRepository select cust).FirstOrDefault(); } Assert.That(customer, Is.Not.Null); Assert.Throws <ObjectDisposedException>(() => customer.Orders.Count()); }
public void Query_With_Incompatible_UnitOfWork_Throws_InvalidOperationException() { var mockUnitOfWork = MockRepository.GenerateStub <IUnitOfWork>(); UnitOfWork.Current = mockUnitOfWork; Assert.Throws <InvalidOperationException>(() => { var customerRepository = new LinqToSqlRepository <Customer>(); var results = from customer in customerRepository select customer; } ); UnitOfWork.Current = null; }
public void Query_Allows_Lazy_Load_While_UnitOfWork_Still_Running() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); var ordersRepository = new LinqToSqlRepository <Order>(); var results = from order in ordersRepository select order; Assert.DoesNotThrow(() => results.ForEach( x => Assert.That(!string.IsNullOrEmpty(x.Customer.FirstName)))); } }
public void Query_Using_QueryMethod_Returns_Matched_Records_Only() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomerInState("PA"))); var customersInPA = new Specification <Order>(x => x.Customer.State == "PA"); var ordersRepository = new LinqToSqlRepository <Order>(); var results = from order in ordersRepository.Query(customersInPA) select order; Assert.That(results.Count() > 0); } }
public void When_Calling_CalculateTotal_On_Order_Returns_Valid_When_Under_UnitOfWork() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var oredersRepository = new LinqToSqlRepository <Order>(); var order = (from o in oredersRepository select o).FirstOrDefault(); Assert.That(order.CalculateTotal(), Is.GreaterThan(0)); } }
public void When_Calling_CalculateTotal_On_Order_Returns_Valid_With_No_UnitOfWork_Throws() { Order order; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var oredersRepository = new LinqToSqlRepository <Order>(); order = (from o in oredersRepository select o).FirstOrDefault(); } Assert.Throws <ObjectDisposedException>(() => order.CalculateTotal()); }
public void When_No_FetchingStrategy_Registered_For_Makes_No_Changes() { Order order; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var oredersRepository = new LinqToSqlRepository <Order>(); order = (from o in oredersRepository select o).FirstOrDefault(); } Assert.Throws <ObjectDisposedException>(() => order.CalculateTotal()); }
public void Delete_Deletes_Record() { var newCustomer = new Customer { FirstName = ("John_DELETE_ME_" + DateTime.Now), LastName = ("Doe_DELETE_ME_" + DateTime.Now), StreetAddress1 = "This record was inserted for deletion", City = "Fictional city", State = "LA", ZipCode = "12345" }; //Re-usable query to query for the matching record. var queryForCustomer = new Func <LinqToSqlRepository <Customer>, Customer> ( x => (from cust in x where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault() ); using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Null); customerRepository.Add(newCustomer); scope.Commit(); } //Retrieve the record for deletion. using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var customerToDelete = queryForCustomer(customerRepository); Assert.That(customerToDelete, Is.Not.Null); customerRepository.Delete(customerToDelete); scope.Commit(); } //Ensure customer record is deleted. using (new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Null); } }
public void Delete_Deletes_Record() { var newCustomer = new Customer { FirstName = ("John_DELETE_ME_" + DateTime.Now), LastName = ("Doe_DELETE_ME_" + DateTime.Now), StreetAddress1 = "This record was inserted for deletion", City = "Fictional city", State = "LA", ZipCode = "12345" }; //Re-usable query to query for the matching record. var queryForCustomer = new Func<LinqToSqlRepository<Customer>, Customer> ( x => (from cust in x where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault() ); using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Null); customerRepository.Add(newCustomer); scope.Commit(); } //Retrieve the record for deletion. using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var customerToDelete = queryForCustomer(customerRepository); Assert.That(customerToDelete, Is.Not.Null); customerRepository.Delete(customerToDelete); scope.Commit(); } //Ensure customer record is deleted. using (new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Null); } }
public void Query_Allows_Eger_Loading_Using_With() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateCustomer()); var ordersRepository = new LinqToSqlRepository <Order>(); var results = from order in ordersRepository.With(x => x.Customer) select order; Assert.DoesNotThrow(() => results.ForEach(x => { Assert.That(x.Customer, Is.TypeOf(typeof(Customer))); Assert.That(!string.IsNullOrEmpty(x.Customer.FirstName)); })); } }
public void Commit_Method() { var entity = new TestEntity(); using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.False(repository.Any()); Assert.True(ReferenceEquals(repository.Persist(entity).Commit(), repository)); Assert.True(ReferenceEquals(repository.Single(), entity)); repository.Delete(entity); Assert.True(ReferenceEquals(repository.Single(), entity)); repository.Commit(); Assert.False(repository.Any()); } }
public void Nested_UnitOfWork_With_Different_Transaction_Compatibility_Works() { var changedShipDate = DateTime.Now.AddDays(1); var changedOrderDate = DateTime.Now.AddDays(2); using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext { Log = Console.Out })) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); int orderId; using (new UnitOfWorkScope()) { var ordersRepository = new LinqToSqlRepository <Order>(); orderId = ordersRepository.Select(x => x.OrderID).First(); } Assert.NotNull(orderId); using (new UnitOfWorkScope()) { var outerRepository = new LinqToSqlRepository <Order>(); var outerOrder = outerRepository.Where(x => x.OrderID == orderId).First(); outerOrder.OrderDate = changedOrderDate; using (var innerScope = new UnitOfWorkScope(UnitOfWorkScopeTransactionOptions.CreateNew)) { var innerRepository = new LinqToSqlRepository <Order>(); var innerOrder = innerRepository.Where(x => x.OrderID == orderId).First(); innerOrder.ShipDate = changedShipDate; innerScope.Commit(); } } using (new UnitOfWorkScope()) { var ordersRepository = new LinqToSqlRepository <Order>(); var order = ordersRepository.First(); Assert.That(order.OrderDate, Is.Not.EqualTo(changedOrderDate)); Assert.That(order.ShipDate, Is.Not.EqualTo(changedShipDate)); } } }
public void Save_New_Customer_Saves_Customer_When_UnitOfWork_Is_Committed() { var rnd = new Random(); var newCustomer = new Customer { FirstName = ("John_" + rnd.Next(0, 30000)), LastName = ("Doe_" + rnd.Next(0, 30000)), StreetAddress1 = "This record was inserted via a test", City = "Fictional city", State = "LA", ZipCode = "12345" }; var queryForCustomer = new Func <LinqToSqlRepository <Customer>, Customer> ( x => (from cust in x where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault() ); using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Null); customerRepository.Add(newCustomer); scope.Commit(); } //Starting a completely new unit of work and repository to check for existance. using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Not.Null); Assert.That(recordCheckResult.FirstName, Is.EqualTo(newCustomer.FirstName)); Assert.That(recordCheckResult.LastName, Is.EqualTo(newCustomer.LastName)); scope.Commit(); } }
public void Constructors() { Assert.Throws<ArgumentNullException>(() => new LinqToSqlRepository<TestEntity>((string)null)); Assert.Throws<ArgumentException>(() => new LinqToSqlRepository<TestEntity>(string.Empty)); Assert.Throws<ArgumentNullException>(() => new LinqToSqlRepository<TestEntity>((IDbConnection)null)); using (var repository = new LinqToSqlRepository<TestEntity>(this.connectionString)) { Assert.Equal(ConnectionState.Closed, repository.DataContext.Connection.State); Assert.True(repository.Field("ownsConnection").To<bool>()); } using (var connection = this.Connection()) { using (var repository = new LinqToSqlRepository<TestEntity>(connection)) { Assert.True(ReferenceEquals(repository.DataContext.Connection, connection)); Assert.False(repository.Field("ownsConnection").To<bool>()); } Assert.Equal(ConnectionState.Open, connection.State); } }
public void Save_Does_Not_Save_New_Customer_When_UnitOfWork_Is_Aborted() { var rnd = new Random(); var newCustomer = new Customer { FirstName = ("John_" + rnd.Next(30001, 50000)), LastName = ("Doe_" + rnd.Next(30001, 50000)), StreetAddress1 = "This record was inserted via a test", City = "Fictional city", State = "LA", ZipCode = "12345" }; using (new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var recordCheckResult = (from cust in customerRepository where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault(); Assert.That(recordCheckResult, Is.Null); customerRepository.Add(newCustomer); //DO NOT CALL COMMIT TO SIMMULATE A ROLLBACK. } //Starting a completely new unit of work and repository to check for existance. using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository <Customer>(); var recordCheckResult = (from cust in customerRepository where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault(); Assert.That(recordCheckResult, Is.Null); scope.Commit(); } }
public void Query_Allows_Projection_Using_Select_Projection() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); var ordersRepository = new LinqToSqlRepository <Order>(); var results = from order in ordersRepository select new { order.Customer.FirstName, order.Customer.LastName, order.ShipDate, order.OrderDate }; Assert.DoesNotThrow(() => results.ForEach(x => { Assert.That(!string.IsNullOrEmpty(x.LastName)); Assert.That(!string.IsNullOrEmpty(x.FirstName)); })); } }
public void Query_Using_QueryMethod_Returns_Matched_Records_Only() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomerInState("PA"))); var customersInPA = new Specification<Order>(x => x.Customer.State == "PA"); var ordersRepository = new LinqToSqlRepository<Order>(); var results = from order in ordersRepository.Query(customersInPA) select order; Assert.That(results.Count() > 0); } }
public void Query_Throws_Exception_When_LazyLoading_After_UnitOfWork_Is_Finished() { Customer customer; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateCustomer()); var customerRepository = new LinqToSqlRepository<Customer>(); customer = (from cust in customerRepository select cust).FirstOrDefault(); } Assert.That(customer, Is.Not.Null); Assert.Throws<ObjectDisposedException>(() => customer.Orders.Count()); }
public void DeleteAll_Method() { using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.True(ReferenceEquals(repository.DeleteAll(), repository)); Assert.False(repository.Commit().Any()); repository.Persist(new TestEntity()).Persist(new TestEntity()); Assert.Equal(2, repository.Commit().Count()); repository.DeleteAll(); Assert.False(repository.Commit().Any()); } }
public void When_Calling_CalculateTotal_On_Order_Returns_Valid_When_Under_UnitOfWork() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var oredersRepository = new LinqToSqlRepository<Order>(); var order = (from o in oredersRepository select o).FirstOrDefault(); Assert.That(order.CalculateTotal(), Is.GreaterThan(0)); } }
public void Persist_Method() { Assert.Throws<ArgumentNullException>(() => new LinqToSqlRepository<TestEntity>(this.Connection()).Persist(null)); var entity = new TestEntity { Name = "first" }; using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.False(repository.Any()); Assert.True(ReferenceEquals(repository.Persist(entity), repository)); repository.Commit(); entity = repository.Single(); Assert.NotEqual(0, entity.Id); Assert.Equal("first", entity.Name); entity.Name = "second"; repository.Commit(); entity = repository.Single(); Assert.NotEqual(0, entity.Id); Assert.Equal("second", entity.Name); Assert.Equal(1, repository.Count(x => x.Name == "second")); Assert.Equal("second", repository.Single(x => x.Name == "second").Name); } }
public void Save_New_Customer_Saves_Customer_When_UnitOfWork_Is_Committed() { var rnd = new Random(); var newCustomer = new Customer { FirstName = ("John_" + rnd.Next(0, 30000)), LastName = ("Doe_" + rnd.Next(0, 30000)), StreetAddress1 = "This record was inserted via a test", City = "Fictional city", State = "LA", ZipCode = "12345" }; var queryForCustomer = new Func<LinqToSqlRepository<Customer>, Customer> ( x => (from cust in x where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault() ); using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Null); customerRepository.Add(newCustomer); scope.Commit(); } //Starting a completely new unit of work and repository to check for existance. using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var recordCheckResult = queryForCustomer(customerRepository); Assert.That(recordCheckResult, Is.Not.Null); Assert.That(recordCheckResult.FirstName, Is.EqualTo(newCustomer.FirstName)); Assert.That(recordCheckResult.LastName, Is.EqualTo(newCustomer.LastName)); scope.Commit(); } }
public void Repository_For_Uses_Registered_Fetching_Strategies() { IEnumerable<Order> orders; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var strategies = new IFetchingStrategy<Order, LinqToSqlRepositoryTests>[] { new OrderOrderItemsStrategy(), new OrderItemsProductStrategy() }; IRepository<Order> ordersRepository = null; ServiceLocator.Current.Expect( x => x.GetAllInstances<IFetchingStrategy<Order, LinqToSqlRepositoryTests>>()) .Return(strategies); ordersRepository = new LinqToSqlRepository<Order>().For<LinqToSqlRepositoryTests>(); orders = (from o in ordersRepository select o).ToList(); } orders.ForEach(x => Assert.That(x.CalculateTotal(), Is.GreaterThan(0))); }
public void ElementType_Property() { using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.True(ReferenceEquals(repository.DataContext.GetTable<TestEntity>().AsQueryable().ElementType, repository.ElementType)); } }
public void Provider_Property() { using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.Equal(repository.DataContext.GetTable<TestEntity>().AsQueryable().Provider.ToString(), repository.Provider.ToString()); } }
public void GetEnumerator_Method() { var entity = new TestEntity(); using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.False(repository.GetEnumerator().MoveNext()); repository.Persist(entity).Commit(); var enumerator = repository.GetEnumerator(); Assert.True(enumerator.MoveNext()); Assert.False(enumerator.MoveNext()); } }
public void When_No_FetchingStrategy_Registered_For_Makes_No_Changes() { Order order; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var oredersRepository = new LinqToSqlRepository<Order>(); order = (from o in oredersRepository select o).FirstOrDefault(); } Assert.Throws<ObjectDisposedException>(() => order.CalculateTotal()); }
public void Dispose() { using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { repository.DeleteAll().Commit(); } }
public void Query_With_Incompatible_UnitOfWork_Throws_InvalidOperationException() { var mockUnitOfWork = MockRepository.GenerateStub<IUnitOfWork>(); UnitOfWork.Current = mockUnitOfWork; Assert.Throws<InvalidOperationException>(() => { var customerRepository = new LinqToSqlRepository<Customer>(); var results = from customer in customerRepository select customer; } ); UnitOfWork.Current = null; }
public void Query_With_No_UnitOfWork_Throws_InvalidOperationException() { Assert.Throws<InvalidOperationException>( () => { var repository = new LinqToSqlRepository<Customer> {new Customer()}; }); }
public void Transaction_Method() { using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.NotNull(repository.Transaction()); } }
public void Save_Does_Not_Save_New_Customer_When_UnitOfWork_Is_Aborted() { var rnd = new Random(); var newCustomer = new Customer { FirstName = ("John_" + rnd.Next(30001, 50000)), LastName = ("Doe_" + rnd.Next(30001, 50000)), StreetAddress1 = "This record was inserted via a test", City = "Fictional city", State = "LA", ZipCode = "12345" }; using (new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var recordCheckResult = (from cust in customerRepository where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault(); Assert.That(recordCheckResult, Is.Null); customerRepository.Add(newCustomer); //DO NOT CALL COMMIT TO SIMMULATE A ROLLBACK. } //Starting a completely new unit of work and repository to check for existance. using (var scope = new UnitOfWorkScope()) { var customerRepository = new LinqToSqlRepository<Customer>(); var recordCheckResult = (from cust in customerRepository where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName select cust).FirstOrDefault(); Assert.That(recordCheckResult, Is.Null); scope.Commit(); } }
public void Refresh_Method() { Assert.Throws<ArgumentNullException>(() => new LinqToSqlRepository<TestEntity>(this.Connection()).Refresh(null)); var entity = new TestEntity { Name = "first" }; using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { Assert.Throws<ArgumentException>(() => repository.Refresh(entity)); repository.Persist(entity).Commit(); var originalId = entity.Id; var originalName = entity.Name; entity.Name = "second"; Assert.True(ReferenceEquals(repository.Refresh(entity), repository)); Assert.Equal(originalId, entity.Id); Assert.Equal(originalName, entity.Name); } }
public void Save_Updates_Existing_Order_Record() { int orderIDRetrieved; var updatedDate = DateTime.Now; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); using (var scope = new UnitOfWorkScope()) { var order = new LinqToSqlRepository<Order>().FirstOrDefault(); Assert.That(order, Is.Not.Null); orderIDRetrieved = order.OrderID; order.OrderDate = updatedDate; scope.Commit(); } using (new UnitOfWorkScope()) { var orderRepository = new LinqToSqlRepository<Order>(); var order = (from o in orderRepository where o.OrderID == orderIDRetrieved select o).FirstOrDefault(); Assert.That(order, Is.Not.Null); Assert.That(order.OrderDate.Value.Date, Is.EqualTo(updatedDate.Date)); Assert.That(order.OrderDate.Value.Hour, Is.EqualTo(updatedDate.Hour)); Assert.That(order.OrderDate.Value.Minute, Is.EqualTo(updatedDate.Minute)); Assert.That(order.OrderDate.Value.Second, Is.EqualTo(updatedDate.Second)); } } }
public void Query_Allows_Eger_Loading_Using_With() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateCustomer()); var ordersRepository = new LinqToSqlRepository<Order>(); var results = from order in ordersRepository.With(x => x.Customer) select order; Assert.DoesNotThrow(() => results.ForEach(x => { Assert.That(x.Customer, Is.TypeOf(typeof (Customer))); Assert.That(!string.IsNullOrEmpty(x.Customer.FirstName)); })); } }
public void UnitOfWork_Is_Rolledback_When_Containing_TransactionScope_Is_Rolledback() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); int orderId; DateTime? oldDate; using (var txScope = new TransactionScope(TransactionScopeOption.Required)) using (var uowScope = new UnitOfWorkScope(IsolationLevel.Serializable)) { var ordersRepository = new LinqToSqlRepository<Order>(); var order = (from o in ordersRepository select o).First(); oldDate = order.OrderDate; order.OrderDate = DateTime.Now; orderId = order.OrderID; uowScope.Commit(); } using (var uowScope = new UnitOfWorkScope()) { var ordersRepository = new LinqToSqlRepository<Order>(); var order = (from o in ordersRepository where o.OrderID == orderId select o).First(); Assert.That(order.OrderDate, Is.EqualTo(oldDate)); } } }
public void Query_Allows_Lazy_Load_While_UnitOfWork_Still_Running() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); var ordersRepository = new LinqToSqlRepository<Order>(); var results = from order in ordersRepository select order; Assert.DoesNotThrow(() => results.ForEach( x => Assert.That(!string.IsNullOrEmpty(x.Customer.FirstName)))); } }
public void When_Calling_CalculateTotal_On_Order_Returns_Valid_With_No_UnitOfWork_Throws() { Order order; using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForProducts(actions.CreateProducts(5))); var oredersRepository = new LinqToSqlRepository<Order>(); order = (from o in oredersRepository select o).FirstOrDefault(); } Assert.Throws<ObjectDisposedException>(() => order.CalculateTotal()); }
public void Query_Allows_Projection_Using_Select_Projection() { using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext())) using (new UnitOfWorkScope()) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); var ordersRepository = new LinqToSqlRepository<Order>(); var results = from order in ordersRepository select new { order.Customer.FirstName, order.Customer.LastName, order.ShipDate, order.OrderDate }; Assert.DoesNotThrow(() => results.ForEach(x => { Assert.That(!string.IsNullOrEmpty(x.LastName)); Assert.That(!string.IsNullOrEmpty(x.FirstName)); })); } }
public void Nested_UnitOfWork_With_Different_Transaction_Compatibility_Works() { var changedShipDate = DateTime.Now.AddDays(1); var changedOrderDate = DateTime.Now.AddDays(2); using (var testData = new LinqToSqlDataGenerator(new TestDataDataContext{Log = Console.Out})) { testData.Batch(actions => actions.CreateOrderForCustomer(actions.CreateCustomer())); int orderId; using (new UnitOfWorkScope()) { var ordersRepository = new LinqToSqlRepository<Order>(); orderId = ordersRepository.Select(x => x.OrderID).First(); } Assert.NotNull(orderId); using (new UnitOfWorkScope()) { var outerRepository = new LinqToSqlRepository<Order>(); var outerOrder = outerRepository.Where(x => x.OrderID == orderId).First(); outerOrder.OrderDate = changedOrderDate; using (var innerScope = new UnitOfWorkScope(UnitOfWorkScopeTransactionOptions.CreateNew)) { var innerRepository = new LinqToSqlRepository<Order>(); var innerOrder = innerRepository.Where(x => x.OrderID == orderId).First(); innerOrder.ShipDate = changedShipDate; innerScope.Commit(); } } using (new UnitOfWorkScope()) { var ordersRepository = new LinqToSqlRepository<Order>(); var order = ordersRepository.First(); Assert.That(order.OrderDate, Is.Not.EqualTo(changedOrderDate)); Assert.That(order.ShipDate, Is.Not.EqualTo(changedShipDate)); } } }
public void Dispose_Method() { var entity = new TestEntity(); using (var repository = new LinqToSqlRepository<TestEntity>(this.Connection())) { repository.Persist(entity).Dispose(); Assert.Throws<ObjectDisposedException>(() => repository.Single()); repository.Dispose(); } }