public void Calling_Commit_On_Child_Scope_DoesNot_Commit_Transaction()
{
var mockLocator = MockRepository.GenerateStub<IServiceLocator>();
var mockUOWFactory = MockRepository.GenerateMock<IUnitOfWorkFactory>();
var mockUOW = MockRepository.GenerateMock<IUnitOfWork>();
var mockTransaction = MockRepository.GenerateMock<ITransaction>();
mockLocator.Stub(x => x.GetInstance<IUnitOfWorkFactory>()).Return(mockUOWFactory).Repeat.Once();
mockUOWFactory.Expect(x => x.Create()).Return(mockUOW).Repeat.Once();
mockUOW.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted)).IgnoreArguments().Return(mockTransaction).Repeat.Once();
mockTransaction.Expect(x => x.Commit()).Repeat.Never();
mockTransaction.Expect(x => x.Rollback()).Repeat.Once();
ServiceLocator.SetLocatorProvider(() => mockLocator);
using (new UnitOfWorkScope(IsolationLevel.ReadCommitted))
{
Assert.That(UnitOfWorkScope.HasStarted);
using (var childScope = new UnitOfWorkScope(IsolationLevel.ReadCommitted))
{
childScope.Commit();
}
}
Assert.That(!UnitOfWorkScope.HasStarted);
mockUOWFactory.VerifyAllExpectations();
mockUOW.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
// -------------------------------------------------------------------------------------
// Methods
// -------------------------------------------------------------------------------------
public FacadeResult CancelAccount(long id) {
#if DEBUG
using (MiniProfiler.Current.Step("AccountFacade.CancelAccount")) {
#endif
using (var context = new UnitOfWorkScope(TransactionMode.New)) {
var account = Account.GetById(id);
var validationResults = new AccountValidator()
.Validate(account);
if (validationResults.IsValid == true) {
account.IsActive = false;
User.GetAllByAccountId(id).ForEach(user => {
user.IsActive = false;
UserCacheManager.Put(user);
});
context.Commit();
AccountCacheManager.Put(account);
return new FacadeResult();
}
var error = validationResults.Errors
.First().ErrorMessage
.GetError();
return new FacadeResult(error);
#if DEBUG
}
#endif
}
}
public void Should_raise_commit_signal_when_commit_called()
{
var scopeId = Guid.Empty;
_transactionManager.ScopeCommitAction = committingScope => committingScope.Complete();
using (var scope = new UnitOfWorkScope())
{
scopeId = scope.ScopeId;
scope.Commit();
}
Assert.That(_transactionManager.CommitCount(scopeId), Is.EqualTo(1));
Assert.That(_transactionManager.RollbackCount(scopeId), Is.EqualTo(0));
}
public void Delete_Deletes_Record()
{
//Adding a dummy record.
var newAddress = new Address
{
StreetAddress1 = "This record was inserted for deletion",
City = "Fictional city",
State = "LA",
ZipCode = "12345"
};
var newCustomer = new Customer
{
FirstName = ("John_DELETE_ME_" + DateTime.Now),
LastName = ("Doe_DELETE_ME_" + DateTime.Now),
Address = newAddress
};
//Re-usable query to query for the matching record.
var queryForCustomer = new Func<Db4oRepository<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 Db4oRepository<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 Db4oRepository<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 Db4oRepository<Customer>();
var recordCheckResult = queryForCustomer(customerRepository);
Assert.That(recordCheckResult, Is.Null);
}
}
public void Can_lazyload()
{
Customer customer = null;
var testData = new EFTestData(Context);
testData.Batch(x =>
{
customer = x.CreateCustomer();
x.CreateOrderForCustomer(customer);
});
using (var scope = new UnitOfWorkScope())
{
var savedCustomer = new EFRepository<Customer>()
.First(x => x.CustomerID == customer.CustomerID);
Assert.That(savedCustomer, Is.Not.Null);
Assert.That(savedCustomer.Orders.Count, Is.EqualTo(1));
scope.Commit();
}
}
public void Can_delete()
{
Customer customer = null;
var testData = new EFTestData(Context);
testData.Batch(x => customer = x.CreateCustomer());
using (var scope = new UnitOfWorkScope())
{
var repository = new EFRepository<Customer>();
var savedCustomer = repository.First(x => x.CustomerID == customer.CustomerID);
repository.Delete(savedCustomer);
scope.Commit();
}
using (var scope = new UnitOfWorkScope())
{
var repository = new EFRepository<Customer>();
Assert.That(repository.FirstOrDefault(x => x.CustomerID == customer.CustomerID), Is.Null);
scope.Commit();
}
}
public void Can_attach_modified_entity()
{
Customer customer = null;
var testData = new EFTestData(Context);
testData.Batch(x => customer = x.CreateCustomer());
Context.Detach(customer);
Context.Dispose();
using (var scope = new UnitOfWorkScope())
{
customer.LastName = "Changed";
var repository = new EFRepository<Customer>();
repository.Attach(customer);
scope.Commit();
}
Context = new PocoContext(ConnectionString);
testData = new EFTestData(Context);
customer = testData.Get<Customer>(x => x.CustomerID == customer.CustomerID);
Assert.That(customer.LastName, Is.EqualTo("Changed"));
}
public void Can_attach()
{
Customer customer = null;
var testData = new EFTestData(Context);
testData.Batch(x => customer = x.CreateCustomer());
Context.Detach(customer);
Context.Dispose();
using (var scope = new UnitOfWorkScope())
{
var repository = new EFRepository<Customer>();
repository.Attach(customer);
customer.FirstName = "Changed";
scope.Commit();
}
Context = new CodeOnlyContext("SandboxCodeOnly").Context;
testData = new EFTestData(Context);
customer = testData.Get<Customer>(x => x.CustomerID == customer.CustomerID);
Assert.That(customer.FirstName, Is.EqualTo("Changed"));
}
public void throws_when_lazyloading_outside_of_scope()
{
Order order = null;
var testData = new EFTestData(Context);
testData.Batch(x =>
order = x.CreateOrderForCustomer(x.CreateCustomer()));
Order savedOrder = null;
using (var scope = new UnitOfWorkScope())
{
savedOrder = new EFRepository<Order>()
.First(x => x.OrderID == order.OrderID);
scope.Commit();
}
Assert.That(savedOrder, Is.Not.Null);
Assert.Throws<ObjectDisposedException>(() => { var fname = savedOrder.Customer.FirstName; });
}
public void Can_save()
{
int customerId;
using (var scope = new UnitOfWorkScope())
{
var customer = new Customer
{
FirstName = "Jane",
LastName = "Doe",
StreetAddress1 = "123 Main St.",
};
new EFRepository<Customer>().Add(customer);
scope.Commit();
customerId = customer.CustomerID;
}
var savedCustomer = new EFTestData(Context)
.Get<Customer>(x => x.CustomerID == customerId);
Assert.That(savedCustomer, Is.Not.Null);
}
public void Can_query_using_specification()
{
var testData = new EFTestData(Context);
testData.Batch(x =>
{
x.CreateCustomer(customer => customer.State = "CA");
x.CreateCustomer(customer => customer.State = "CA");
x.CreateCustomer(customer => customer.State = "PA");
});
using (var scope = new UnitOfWorkScope())
{
var specification = new Specification<Customer>(x => x.State == "CA");
var results = new EFRepository<Customer>()
.Query(specification);
Assert.That(results.Count(), Is.EqualTo(2));
scope.Commit();
}
}
public void Can_perform_simple_query()
{
var testData = new EFTestData(Context);
Customer customer = null;
testData.Batch(x => customer = x.CreateCustomer());
using (var scope = new UnitOfWorkScope())
{
var savedCustomer = new EFRepository<Customer>()
.First(x => x.CustomerID == customer.CustomerID);
Assert.That(savedCustomer, Is.Not.Null);
scope.Commit();
}
}
public void Can_modify()
{
Customer customer = null;
var testData = new EFTestData(Context);
testData.Batch(x => customer = x.CreateCustomer());
using (var scope = new UnitOfWorkScope())
{
var savedCustomer = new EFRepository<Customer>()
.First(x => x.CustomerID == customer.CustomerID);
savedCustomer.FirstName = "Changed";
scope.Commit();
}
testData.Refresh(customer);
Assert.That(customer.FirstName, Is.EqualTo("Changed"));
}
public void Commit_Scope_Calls_Flush_On_UOW_And_Commit_On_Transaction()
{
var mockLocator = MockRepository.GenerateStub<IServiceLocator>();
var mockUOWFactory = MockRepository.GenerateMock<IUnitOfWorkFactory>();
var mockUOW = MockRepository.GenerateMock<IUnitOfWork>();
var mockTransaction = MockRepository.GenerateMock<ITransaction>();
mockLocator.Stub(x => x.GetInstance<IUnitOfWorkFactory>()).Return(mockUOWFactory);
mockUOWFactory.Expect(x => x.Create()).IgnoreArguments().Return(mockUOW);
mockUOW.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted)).Return(mockTransaction);
mockUOW.Expect(x => x.Flush());
mockUOW.Expect(x => x.Dispose());
mockTransaction.Expect(x => x.Commit());
mockTransaction.Expect(x => x.Dispose());
ServiceLocator.SetLocatorProvider(() => mockLocator);
using (var scope = new UnitOfWorkScope())
{
Assert.That(UnitOfWorkScope.HasStarted);
scope.Commit();
}
Assert.That(!UnitOfWorkScope.HasStarted);
mockUOWFactory.VerifyAllExpectations();
mockUOW.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public FacadeResult<User> UpdateUserPassword(long userId, string password) {
#if DEBUG
using (MiniProfiler.Current.Step("AccountFacade.UpdateUserPassword")) {
#endif
using (var context = new UnitOfWorkScope()) {
var user = User.GetById(userId);
if (user != null) {
user.SetPassword(password);
}
var validationResults = new UserValidator()
.Validate(user);
if (validationResults.IsValid) {
context.Commit();
UserCacheManager.Put(user);
return new FacadeResult<User>(user);
}
var error = validationResults.Errors
.First().ErrorMessage
.GetError();
return new FacadeResult<User>(error);
}
#if DEBUG
}
#endif
}
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 Db4oTestDataGenerator(_db4oServer.OpenClient()))
{
testData.Batch(actions =>
actions.CreateOrderForCustomer(actions.CreateCustomer()));
int orderId;
using (new UnitOfWorkScope())
{
var ordersRepository = new Db4oRepository<Order>();
orderId = ordersRepository.Select(x => x.OrderID).First();
}
Assert.NotNull(orderId);
using (new UnitOfWorkScope())
{
var outerRepository = new Db4oRepository<Order>();
var outerOrder = outerRepository.Where(x => x.OrderID == orderId).First();
outerOrder.OrderDate = changedOrderDate;
using (var innerScope = new UnitOfWorkScope(UnitOfWorkScopeTransactionOptions.CreateNew))
{
var innerRepository = new Db4oRepository<Order>();
var innerOrder = innerRepository.Where(x => x.OrderID == orderId).First();
innerOrder.ShipDate = changedShipDate;
innerScope.Commit();
}
}
using (new UnitOfWorkScope())
{
var ordersRepository = new Db4oRepository<Order>();
var order = ordersRepository.First();
Assert.That(order.OrderDate, Is.Not.EqualTo(changedOrderDate));
Assert.That(order.ShipDate, Is.Not.EqualTo(changedShipDate));
}
}
}
public void UnitOfWork_Rolledback_When_Containing_TransactionScope_Is_Rolledback()
{
using (var testData = new Db4oTestDataGenerator(_db4oServer.OpenClient()))
{
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 Db4oRepository<Order>();
var order = (from o in ordersRepository
select o).First();
oldDate = order.OrderDate;
order.OrderDate = DateTime.Now;
orderId = order.OrderID;
uowScope.Commit();
//Note: txScope has not been committed
}
using (new UnitOfWorkScope())
{
var ordersRepository = new Db4oRepository<Order>();
var order = (from o in ordersRepository
where o.OrderID == orderId
select o).First();
Assert.That(order.OrderDate, Is.EqualTo(oldDate));
}
}
}
public FacadeResult<User> SignUp(string name, string email, string password) {
#if DEBUG
using (MiniProfiler.Current.Step("AccountFacade.SignUp")) {
#endif
using (var context = new UnitOfWorkScope(TransactionMode.New)) {
var user = User.Create(email, name, password);
var userValidation = new UserValidator()
.Validate(user);
if (userValidation.IsValid == false) {
var error = userValidation.Errors
.First().ErrorMessage
.GetError();
return new FacadeResult<User>(error);
}
context.Commit();
UserCacheManager.Put(user);
return new FacadeResult<User>(user);
}
#if DEBUG
}
#endif
}
public void Save_Updates_Existing_Order_Record()
{
var updatedDate = DateTime.Now;
using (var testData = new Db4oTestDataGenerator(_db4oServer.OpenClient()))
{
testData.Batch(actions =>
actions.CreateOrderForCustomer(actions.CreateCustomer()));
int orderId;
using (var scope = new UnitOfWorkScope())
{
var orderRepository = new Db4oRepository<Order>();
var order = orderRepository.FirstOrDefault();
Assert.That(order, Is.Not.Null);
orderId = order.OrderID;
order.OrderDate = updatedDate;
orderRepository.Save(order); //Db4o does not do change tracking!
scope.Commit();
}
using (new UnitOfWorkScope())
{
var orderRepository = new Db4oRepository<Order>();
var order = (from o in orderRepository
where o.OrderID == orderId
select o).FirstOrDefault();
Assert.That(order, Is.Not.Null);
Assert.That(order.OrderDate.Date, Is.EqualTo(updatedDate.Date));
Assert.That(order.OrderDate.Hour, Is.EqualTo(updatedDate.Hour));
Assert.That(order.OrderDate.Minute, Is.EqualTo(updatedDate.Minute));
Assert.That(order.OrderDate.Second, Is.EqualTo(updatedDate.Second));
}
}
}
public void Save_New_Customer_Saves_Customer_When_UnitOfWork_Is_Committed()
{
var newAddress = new Address
{
StreetAddress1 = "This record was inserted via a test",
City = "Fictional city",
State = "LA",
ZipCode = "12345"
};
var newCustomer = new Customer
{
FirstName = ("John_" + DateTime.Now),
LastName = ("Doe_" + DateTime.Now),
Address = newAddress
};
var queryForCustomer = new Func<Db4oRepository<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 Db4oRepository<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 Db4oRepository<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 Save_Does_Not_Save_New_Customer_When_UnitOfWork_Is_Aborted()
{
var rnd = new Random();
var newAddress = new Address
{
StreetAddress1 = "This record was inserted via a test",
City = "Fictional city",
State = "LA",
ZipCode = "12345"
};
var newCustomer = new Customer
{
FirstName = ("John_" + rnd.Next(60000, 80000)),
LastName = ("Doe_" + rnd.Next(60000, 80000)),
Address = newAddress
};
using (new UnitOfWorkScope())
{
var customerRepository = new Db4oRepository<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 Db4oRepository<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 Should_not_attempt_auto_commit_if_explicitly_comitted()
{
var scopeId = Guid.Empty;
_transactionManager.ScopeCommitAction = scope => scope.Complete();
using (var scope = new UnitOfWorkScope())
{
scopeId = scope.ScopeId;
scope.Commit();
}
Assert.That(_transactionManager.CommitCount(scopeId), Is.EqualTo(1));
Assert.That(_transactionManager.RollbackCount(scopeId), Is.EqualTo(0));
}
public FacadeResult<User> UpdateUserProfile(long userId, string name, string email) {
#if DEBUG
using (MiniProfiler.Current.Step("AccountFacade.UpdateUserProfile")) {
#endif
using (var context = new UnitOfWorkScope()) {
var user = User.GetById(userId);
if (user != null) {
user.Name = (name ?? "").Trim();
user.Email = (email ?? "").Trim().ToLower();
}
var validationResults = new UserValidator()
.Validate(user);
if (validationResults.IsValid) {
context.Commit();
UserCacheManager.Put(user);
return new FacadeResult<User>(user);
}
var error = validationResults.Errors
.First().ErrorMessage
.GetError();
return new FacadeResult<User>(error);
}
}
#if DEBUG
}