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