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 Test_Can_Query_MonthlySalesSummary_Based_On_Currency()
{
IList<MonthlySalesSummary> report;
using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
using (var scope = new UnitOfWorkScope())
{
testData.Batch(actions => actions.CreateMonthlySalesSummaryWithAmount(
new Money{Amount = 100, Currency = "YEN"}
));
var repository = new NHRepository<MonthlySalesSummary>();
report = (from summary in repository
where summary.TotalSale.Currency == "YEN"
select summary).ToList();
scope.Commit();
}
Assert.That(report, Is.Not.Null);
Assert.That(report.Count, Is.GreaterThan(0));
report.ForEach(rep =>
{
Assert.That(rep.TotalSale, Is.Not.Null);
Assert.That(rep.TotalSale.Amount, Is.GreaterThan(0));
Assert.That(rep.TotalSale.Currency, Is.Not.Null);
Assert.That(rep.TotalSale.Currency, Is.EqualTo("YEN"));
});
}
public void Test_Can_Get_MonthlySalesSummary_With_Money_Type()
{
IList<MonthlySalesSummary> report;
using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
using (var scope = new UnitOfWorkScope())
{
testData.Batch(action => action.CreateMonthlySalesSummaryForMonth(1));
var repository = new NHRepository<MonthlySalesSummary>();
report = (from summary in repository
where summary.Month == 1
select summary).ToList();
scope.Commit();
}
Assert.That(report, Is.Not.Null);
Assert.That(report.Count, Is.GreaterThan(0));
report.ForEach(rep =>
{
Assert.That(rep.Month == 1);
Assert.That(rep.TotalSale, Is.Not.Null);
Assert.That(rep.TotalSale.Amount, Is.GreaterThan(0));
Assert.That(rep.TotalSale.Currency, Is.Not.Null);
});
}
public void PerformActivity(Guid actorId, Guid flowId, IDictionary <string, object> attributeValues = null, string transitionName = null)
{
using (var scope = new UnitOfWorkScope(autoCommit: false))
{
try
{
var organizationApplication = ServiceLocator.Current.GetInstance <IOrganizationApplication>();
var actor = organizationApplication.FindActor(actorId);
var flowRepository = ServiceLocator.Current.GetInstance <IRepository <Flow> >();
var flow =
flowRepository.With(w => w.Node)
.With(w => w.Parent)
.With(w => w.AttributeInstances)
.Single(s => s.Id == flowId);
var processInstanceRepository = ServiceLocator.Current.GetInstance <IRepository <ProcessInstance> >();
var processInstance = processInstanceRepository.Get(flow.ProcessInstanceId);
var processDefinitionRepository = ServiceLocator.Current.GetInstance <IRepository <ProcessDefinition> >();
ProcessDefinition processDefinition = processDefinitionRepository.With(w => w.Nodes).Get(processInstance.ProcessDefinitionId);
ExecutionContext executionContext = new ExecutionContext(actor, processDefinition, processInstance, flow);
executionContext.PerformActivity(attributeValues);
scope.Commit();
}
catch
{
throw;
}
}
}
public void Can_attach()
{
var customer = new Customer
{
FirstName = "Jane",
LastName = "Doe"
};
var session = NHTestUtil.OrdersDomainFactory.OpenSession();
ITransaction transaction = session.BeginTransaction();
session.Save(customer);
transaction.Commit();
session.Evict(customer); //Detching from owning session
session.Dispose(); //Auto flush
using (var scope = new UnitOfWorkScope())
{
var repository = new NHRepository<Customer,int>();
repository.Attach(customer);
customer.LastName = "Changed";
scope.Commit(); //Should change since the customer was attached to repository.
}
using (var testData = new NHTestData(NHTestUtil.OrdersDomainFactory.OpenSession()))
{
Customer savedCustomer = null;
testData.Batch(x => savedCustomer = x.GetCustomerById(customer.CustomerID));
Assert.IsNotNull(savedCustomer);
Assert.AreEqual(savedCustomer.LastName, "Changed");
}
}
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();
}
public void Can_eager_fetch_many()
{
using (var testData = new EFTestData(OrdersContextProvider()))
{
Customer customer = null;
Customer savedCustomer = null;
testData.Batch(x =>
{
customer = x.CreateCustomer();
var order = x.CreateOrderForCustomer(customer);
order.OrderItems.Add(x.CreateItem(order, x.CreateProduct()));
order.OrderItems.Add(x.CreateItem(order, x.CreateProduct()));
order.OrderItems.Add(x.CreateItem(order, x.CreateProduct()));
});
using (var scope = new UnitOfWorkScope())
{
savedCustomer = new EFRepository <Customer>()
.FetchMany(x => x.Orders)
.ThenFetchMany(x => x.OrderItems)
.ThenFetch(x => x.Product)
.Where(x => x.CustomerID == customer.CustomerID)
.SingleOrDefault();
scope.Commit();
}
Assert.NotNull(savedCustomer);
Assert.NotNull(savedCustomer.Orders);
savedCustomer.Orders.ForEach(order =>
{
Assert.NotNull(order.OrderItems);
order.OrderItems.ForEach(orderItem => Assert.NotNull(orderItem.Product));
});
}
}
//[CustomAuthorize(AuthorizedRoles = new[] { Roles.MunicipalityAdministrator, Roles.ZelsAdministrator })]
public JsonResult ResetPassword(int userId)
{
User user;
//SendResetPasswordConfirmationViewModel sendResetPasswordConfirmationViewModel;
using (var scope = new UnitOfWorkScope())
{
user = _userRepository.Get(userId);
if (user == null)
{
throw new JsonException("Корисникот не е пронајден во системот.");
}
string password = new PasswordGenerator().Generate();
string passwordEnc = password.Md5String();
user.SetPassword(passwordEnc);
//sendResetPasswordConfirmationViewModel = new SendResetPasswordConfirmationViewModel
//{
// FullName = user.FullName,
// Password = password
//};
_userRepository.Update(user);
scope.Commit();
}
//sendResetPasswordConfirmationViewModel.To = user.UserName;
//MailService.SendResetPasswordConfirmation(sendResetPasswordConfirmationViewModel);
return(Json(true));
}
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 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 ProcessInstanceView StartProcessInstance(Guid actorId, Guid processDefinitionId, IDictionary <string, object> attributeValues = null, string transitionName = null)
{
ProcessInstance processInstance = null;
using (var scope = new UnitOfWorkScope(autoCommit: false))
{
try
{
var processDefinitionRepository = ServiceLocator.Current.GetInstance <IRepository <ProcessDefinition> >();
ProcessDefinition processDefinition = processDefinitionRepository.With(w => w.Nodes).With(w => w.Attributes).Get(processDefinitionId);
var organizationApplication = ServiceLocator.Current.GetInstance <IOrganizationApplication>();
var actor = organizationApplication.FindActor(actorId);
ExecutionContext executionContext = new ExecutionContext(actor, processDefinition);
processInstance = executionContext.StartProcess(attributeValues);
Log.Information("actor '" + actor + "' starts an instance of process '" + processDefinition.Name + "'...");
var processInstanceRepository = ServiceLocator.Current.GetInstance <IRepository <ProcessInstance> >();
processInstanceRepository.Add(processInstance);
scope.Commit();
var config = new MapperConfiguration(cfg => cfg.CreateMap <ProcessInstance, ProcessInstanceView>());
var map = config.CreateMapper();
return(map.Map <ProcessInstanceView>(processInstance));
}
catch
{
throw;
}
}
}
public void can_commit_multiple_db_operations()
{
var customer = new Customer { FirstName = "John", LastName = "Doe" };
var salesPerson = new SalesPerson { FirstName = "Jane", LastName = "Doe", SalesQuota = 2000 };
using (var scope = new UnitOfWorkScope())
{
new EFRepository<Customer>().Add(customer);
new EFRepository<SalesPerson>().Add(salesPerson);
scope.Commit();
}
using (var ordersTestData = new EFTestData(OrdersContextProvider()))
using (var hrTestData = new EFTestData(HRContextProvider()))
{
Customer savedCustomer = null;
SalesPerson savedSalesPerson = null;
ordersTestData.Batch(action => savedCustomer = action.GetCustomerById(customer.CustomerID));
hrTestData.Batch(action => savedSalesPerson = action.GetSalesPersonById(salesPerson.Id));
Assert.That(savedCustomer, Is.Not.Null);
Assert.That(savedSalesPerson, Is.Not.Null);
Assert.That(savedCustomer.CustomerID, Is.EqualTo(customer.CustomerID));
Assert.That(savedSalesPerson.Id, Is.EqualTo(salesPerson.Id));
}
}
/// <summary>
/// Промена на Администратор во Институција во неактивен
/// </summary>
/// <returns></returns>
protected override ActionResult Delete()
{
try
{
using (var scope = new UnitOfWorkScope())
{
BackendUser currentUser = _backendUserRepository.Get(Convert.ToInt32(GridModel.Id));
var user = _userRepository.GetUserByUsername(GridModel.UserName);
if (user != null && currentUser.Id != user.Id)
{
throw new DuplicateKeyException();
}
currentUser.IsActive = false;
_backendUserRepository.Update(currentUser);
scope.Commit();
}
return(Json(GridModel));
}
catch (DuplicateKeyException)
{
ModelState.AddModelError(string.Empty, string.Format("User with username {0} already exists in the system.", GridModel.UserName));
}
throw CreateModelException(GridModel);
}
public Task RemoveFromRoleAsync(AbpUser user, string roleName)
{
return(Task.Factory.StartNew(
() =>
{
using (var uow = new UnitOfWorkScope())
{
var query =
from userRole in _userRoleRepository.GetAll()
join role in _roleRepository.GetAll() on userRole.RoleId equals role.Id
where userRole.UserId == user.Id && role.Name == roleName
select userRole;
var searchedUserRole = query.FirstOrDefault();
if (searchedUserRole == null)
{
return;
}
_userRoleRepository.Delete(searchedUserRole);
uow.Commit();
}
}));
}
public void Can_attach_modified_entity()
{
var customer = new Customer
{
FirstName = "John",
LastName = "Doe"
};
var context = (OrderEntities) OrdersContextProvider();
context.AddToCustomers(customer);
#if EF_1_0
context.SaveChanges(true);
#else
context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
#endif
context.Detach(customer);
context.Dispose();
using (var scope = new UnitOfWorkScope())
{
customer.LastName = "Changed";
var repository = new EFRepository<Customer>();
repository.Attach(customer);
scope.Commit();
}
using (var testData = new EFTestData(OrdersContextProvider()))
{
Customer savedCustomer = null;
testData.Batch(x => savedCustomer = x.GetCustomerById(customer.CustomerID));
Assert.That(savedCustomer, Is.Not.Null);
Assert.That(savedCustomer.LastName, Is.EqualTo("Changed"));
}
}
public virtual void ChangePassword(Guid id, string oldPassword, string newPassword)
{
using (var scope = new UnitOfWorkScope())
{
_userAccountService.ChangePassword(id,oldPassword,newPassword);
scope.Commit();
}
}
public void CancelVerification(string key, out bool accountClosed)
{
using (var scope = new UnitOfWorkScope())
{
_userAccountService.CancelVerification(key,out accountClosed);
scope.Commit();
}
}
public bool ChangePasswordFromResetKey(string key, string newPassword, out NhUserAccount account)
{
bool success;
using (var scope = new UnitOfWorkScope())
{
success=_userAccountService.ChangePasswordFromResetKey(key,newPassword,out account);
scope.Commit();
}
return success;
}
public virtual void AddUsersToRoles(List<Guid> userId, List<string> roleName)
{
if (userId == null || userId.Count == 0 || roleName == null || roleName.Count == 0)
return;
StringBuilder message=new StringBuilder();
var users = _userRepository.Query.Where(x => userId.Contains(x.ID)).ToList();
var roles = _roleRepository.Query.Where(x => roleName.Contains(x.Name)).ToList();
foreach (var userEntity in users)
{
if (userEntity.Roles != null && userEntity.Roles.Any())
{
var newRoles = roles.Except(userEntity.Roles);
foreach (var role in newRoles)
userEntity.Roles.Add(role);
if(newRoles!=null && newRoles.Count()>0)
message.AppendFormat("User {0} is added to role(s) {1}.",userEntity.Username,string.Join(",", newRoles.Select(x => x.Name)));
}
else
{
foreach (var role in roles)
userEntity.Roles.Add(role);
if(roles!=null && roles.Count()>0)
message.AppendFormat("User {0} is added to role(s) {1}.",userEntity.Username,string.Join(",", roles.Select(x => x.Name)));
}
using (var scope = new UnitOfWorkScope())
{
_userRepository.Update(userEntity);
scope.Commit();
}
}
foreach (var uid in userId)
{
if (!users.Any(u => u.ID == uid))
{
var user = _userRepository.Query.Where(x => x.ID == uid).SingleOrDefault();
if (user != null)
{
user.Roles = roles;
using (var scope = new UnitOfWorkScope())
{
_userRepository.Update(user);
scope.Commit();
}
if(roles!=null && roles.Count()>0)
message.AppendFormat("User {0} is added to role(s) {1}.",user.Username,string.Join(",", roles.Select(x => x.Name)));
}
}
}
if (message.Length > 0)
{
ActivityLog item = new ActivityLog(ActivityType.AddUserToRole.ToString(), message.ToString());
_activityLogService.Add(item);
}
}
public JsonResult SetSelectedUserForPos(int posId, List <int> selectedUsers)
{
using (var scope = new UnitOfWorkScope())
{
//Get The User
var pos = _posRepository.Get(posId);
if (pos != null)
{
//Get All Users
var allUsers = _userRepository.GetAll();
var user = pos.Users;
//Find New Elements
var forAdd = (from s in selectedUsers
where !user.Select(x => x.Id)
.Contains(s)
select s)
.ToList();
//Add New
foreach (var selectedU in forAdd)
{
var userNew = allUsers.FirstOrDefault(x => x.Id == selectedU);
try
{
pos.AddUser(userNew);
}
catch (Exception)
{
}
}
//Find For Remove
var forRemove = pos.Users
.Where(ext => !selectedUsers
.Contains(ext.Id))
.ToList();
foreach (var ext in forRemove)
{
pos.RemoveUser(ext);
}
}
else
{
//Remove All Elements
pos.Users.RemoveAll();
}
//Update
_posRepository.Update(pos);
scope.Commit();
}
return(Json(true));
}
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 <NHRepository <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 NHRepository <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 NHRepository <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 NHRepository <Customer>();
var recordCheckResult = queryForCustomer(customerRepository);
Assert.That(recordCheckResult, Is.Null);
}
}
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<NHRepository<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 NHRepository<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 NHRepository<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 NHRepository<Customer>();
var recordCheckResult = queryForCustomer(customerRepository);
Assert.That(recordCheckResult, Is.Null);
}
}
//public virtual bool Exists(string name)
//{
// if (string.IsNullOrEmpty(name))
// throw new ArgumentNullException("name");
// int count = _repository.Query.Where(x => x.Name == name.Trim()).Count();
// return count > 0 ? true : false;
//}
/// <summary>
/// Adds a item
/// </summary>
/// <param name="item">item</param>
public virtual void Add(ActivityLog item)
{
if (item == null)
throw new ArgumentNullException("item");
using (var scope = new UnitOfWorkScope())
{
_repository.Add(item);
scope.Commit();
}
//event notification
_eventPublisher.EntityInserted(item);
}
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 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 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 when_ambient_transaction_is_running_and_a_previous_scope_rollsback_new_scope_still_works()
{
using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
{
testData.Batch(actions => actions.CreateCustomer());
string oldCustomerName;
var newCustomerName = "NewCustomer" + new Random().Next(0, int.MaxValue);
var newCustomer = new Customer
{
FirstName = newCustomerName,
LastName = "Save",
Address = new Address
{
StreetAddress1 = "This record was inserted via a test",
City = "Fictional City",
State = "LA",
ZipCode = "00000"
}
};
using (var ambientScope = new TransactionScope())
{
using (var firstUOW = new UnitOfWorkScope())
{
var customer = new NHRepository <Customer>().First();
oldCustomerName = customer.FirstName;
customer.FirstName = "Changed";
} //Rollback
using (var secondUOW = new UnitOfWorkScope())
{
new NHRepository <Customer>().Add(newCustomer);
secondUOW.Commit();
}
}
using (var scope = new UnitOfWorkScope())
{
var repository = new NHRepository <Customer>();
Assert.That(repository.First().FirstName, Is.EqualTo(oldCustomerName));
Assert.That(repository.Where(x => x.FirstName == newCustomerName).Count(), Is.GreaterThan(0));
repository.Attach(newCustomer);
repository.Delete(newCustomer);
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 DeployProcessArchive(string path)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(path);
using (var scope = new UnitOfWorkScope())
{
ProcessDefinitionCreationContext creationContext = new ProcessDefinitionCreationContext();
ProcessDefinition processDefinition = creationContext.CreateProcessDefinition(xmlDocument);
creationContext.ResolveReferences();
var processBlockRepository = ServiceLocator.Current.GetInstance <IRepository <ProcessBlock> >();
processBlockRepository.Add(processDefinition);
scope.Commit();
}
}
public virtual bool Delete(Guid id)
{
if (id == default(Guid))
throw new ArgumentNullException("id");
ActivityLog item = _repository.Query.FirstOrDefault(x => x.Id == id);
if (item == null)
return false;
using (var scope = new UnitOfWorkScope())
{
_repository.Delete(item);
scope.Commit();
}
//event notification
_eventPublisher.EntityDeleted(item);
return true;
}
/// <summary>
/// Додава нова PublicUser
/// </summary>
/// <returns></returns>
protected override ActionResult Add()
{
try
{
if (ModelState.IsValid)
{
User newUser;
//SendWelcomeEmailToUserViewModel sendWelcomeEmailToUserViewModel;
using (var scope = new UnitOfWorkScope())
{
var user = _userRepository.GetUserByUsername(GridModel.UserName);
if (user != null)
{
throw new DuplicateKeyException();
}
//Generate the Password
string password = new PasswordGenerator().Generate();
string passwordEnc = password.Md5String();
//Create new User
var lang = _langRepository.Get(GridModel.PreferedLanguage);
newUser = new User(GridModel.UserName, passwordEnc, GridModel.FirstName, GridModel.LastName, lang);
newUser.IsActive = GridModel.IsActive;
var role = _roleRepository.GetRoleByName(Roles.PublicUser);
newUser.AddToRole(role);
_userRepository.Save(newUser);
scope.Commit();
}
////Send Welcome email to created administrator
//sendWelcomeEmailToUserViewModel.To = newUser.UserName;
//MailService.SendWelcomeEmailToUser(sendWelcomeEmailToUserViewModel);
return(Json(GridModel));
}
}
catch (DuplicateKeyException)
{
ModelState.AddModelError(string.Empty, string.Format("Корисникот со корисничко име {0} веќе постои во системот.", GridModel.UserName));
}
throw CreateModelException(GridModel);
}
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 <NHRepository <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 NHRepository <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 NHRepository <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 ActionResult Profile(ProfileViewModel model)
{
bool succeed = false;
if (ModelState.IsValid)
{
if (CurrentUser.Password != model.Password.Md5String())
{
ModelState.AddModelError("Password", "Лозинката мора да биде иста со претходната");
}
else
{
using (var scope = new UnitOfWorkScope())
{
var user = _repository.GetUserByUsername(CurrentUser.UserName);
user.SetPassword(model.NewPassword.Md5String());
scope.Commit();
}
succeed = true;
this.ShowMessage(MessageType.Success, "Лозинката е успешно променета.", true);
}
}
model.UserName = CurrentUser.UserName;
model.FirstName = CurrentUser.FirstName;
model.LastName = CurrentUser.LastName;
//var backendUser = CurrentUser as BackendUser;
//if (backendUser != null)
//{
// model.Institution = ResourceManager.GetMultilangValue(backendUser.Institution.Name);
//}
//if (CurrentUser.CertificateRawBytes != null)
//{
// ViewBag.hasCertificate = CurrentUser.CertificateRawBytes.ToString();
// ViewBag.CertificateDateUntil = CurrentUser.CertificateDateUntil;
//}
//else
//{
// ViewBag.hasCertificate = string.Empty;
//}
ViewBag.ChangePass = !succeed;
return(View("Profile", model));
}
/// <summary>
/// Adds a item
/// </summary>
/// <param name="item">item</param>
public virtual void Add(ScheduleTask item)
{
if (item == null)
throw new ArgumentNullException("item");
using (var scope = new UnitOfWorkScope())
{
_repository.Add(item);
scope.Commit();
}
//event notification
_eventPublisher.EntityInserted(item);
TaskManager.Instance.Refresh();
StringBuilder message = new StringBuilder();
message.AppendFormat("Task {0} is created.", item.Name);
ActivityLog activityItem = new ActivityLog(ActivityType.AddTask.ToString(), message.ToString());
_activityLogService.Add(activityItem);
}
public void can_commit()
{
var customer = new Customer
{
FirstName = "John",
LastName = "Doe"
};
using (var scope = new UnitOfWorkScope())
{
new EFRepository<Customer,int>()
.Add(customer);
scope.Commit();
}
var savedCustomer = new EFRepository<Customer, int>().Query
.First(x => x.CustomerID == customer.CustomerID);
Assert.IsNotNull(savedCustomer);
}
public void NHUOW_Issue_6_Replication()
{
var readCustomerFunc = new Func <Customer>(() =>
{
using (var scope = new UnitOfWorkScope())
{
var customer = new NHRepository <Customer>().First();
scope.Commit();
return(customer);
}
});
var updateCustomerFunc = new Func <Customer, Customer>(customer =>
{
using (var scope = new UnitOfWorkScope())
{
var repository = new NHRepository <Customer>();
repository.Attach(customer);
scope.Commit();
return(customer);
}
});
var newCustomerName = "Changed" + new Random().Next(0, int.MaxValue);
using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
{
testData.Batch(actions => actions.CreateCustomer());
using (var masterScope = new UnitOfWorkScope())
{
using (var childScope = new UnitOfWorkScope(UnitOfWorkScopeTransactionOptions.CreateNew))
{
var customer = readCustomerFunc();
customer.FirstName = newCustomerName;
updateCustomerFunc(customer);
childScope.Commit();
}
} //Rollback
var checkCustomer = readCustomerFunc();
Assert.That(checkCustomer.FirstName, Is.EqualTo(newCustomerName));
}
}
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 Should_Call_Uow_Methods()
{
var fakeUow = Substitute.For <IUnitOfWork>();
LocalIocManager.IocContainer.Register(
Component.For <IUnitOfWork>().UsingFactoryMethod(() => fakeUow).LifestyleTransient()
);
using (var unitOfWorkScope = new UnitOfWorkScope(LocalIocManager))
{
fakeUow.Received(1).Initialize(true);
fakeUow.Received(1).Begin();
unitOfWorkScope.Commit();
}
fakeUow.Received(1).End();
fakeUow.Received(1).Dispose();
}
/// <summary>
/// Бришењ на masterUser
/// </summary>
/// <returns></returns>
protected override ActionResult Delete()
{
try
{
using (var scope = new UnitOfWorkScope())
{
var user = _userRepository.Get(Convert.ToInt32(GridModel.Id));
user.IsActive = false;
_userRepository.Update(user);
scope.Commit();
}
return(new EmptyResult());
}
catch (Exception)
{
throw CreateModelException(GridModel);
}
}
/// <summary>
/// Бришењ на POS
/// </summary>
/// <returns></returns>
protected override ActionResult Delete()
{
try
{
using (var scope = new UnitOfWorkScope())
{
var pos = _posRepository.Get(Convert.ToInt32(GridModel.Id));
pos.SetIsActive(GridModel.IsActive);
_posRepository.Update(pos);
scope.Commit();
}
return(new EmptyResult());
}
catch (Exception)
{
throw CreateModelException(GridModel);
}
}
public void NHUOW_Issue_6_Replication()
{
var readCustomerFunc = new Func<Customer>(() =>
{
using (var scope = new UnitOfWorkScope())
{
var customer = new NHRepository<Customer>().First();
scope.Commit();
return customer;
}
});
var updateCustomerFunc = new Func<Customer, Customer>(customer =>
{
using (var scope = new UnitOfWorkScope())
{
var repository = new NHRepository<Customer>();
repository.Attach(customer);
scope.Commit();
return customer;
}
});
var newCustomerName = "Changed" + new Random().Next(0, int.MaxValue);
using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
{
testData.Batch(actions => actions.CreateCustomer());
using (var masterScope = new UnitOfWorkScope())
{
using (var childScope = new UnitOfWorkScope(UnitOfWorkScopeTransactionOptions.CreateNew))
{
var customer = readCustomerFunc();
customer.FirstName = newCustomerName;
updateCustomerFunc(customer);
childScope.Commit();
}
} //Rollback
var checkCustomer = readCustomerFunc();
Assert.That(checkCustomer.FirstName, Is.EqualTo(newCustomerName));
}
}
public void Lazyloading_when_outside_scope_throws()
{
using (var testData = new EFTestData(OrdersContextProvider()))
{
Order order = null;
testData.Batch(x => order = x.CreateOrderForCustomer(x.CreateCustomer()));
Order savedOrder;
using (var scope = new UnitOfWorkScope())
{
savedOrder = new EFRepository <Order>()
.Where(x => x.OrderID == order.OrderID)
.First();
scope.Commit();
}
Assert.That(savedOrder, Is.Not.Null);
Assert.Throws <ObjectDisposedException>(() => { var customer = savedOrder.Customer; });
}
}
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 NHRepository <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 NHRepository <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();
}
}
protected override ActionResult Delete()
{
try
{
using (var scope = new UnitOfWorkScope())
{
Localization entity = _repository.Get(Convert.ToInt32(GridModel.Id));
_repository.Delete(entity);
scope.Commit();
}
return(new EmptyResult());
}
catch (Exception)
{
throw CreateModelException(GridModel);
}
}
/// <summary>
/// Додава нов POS
/// </summary>
/// <returns></returns>
protected override ActionResult Add()
{
try
{
if (ModelState.IsValid)
{
Pos newPos;
using (var scope = new UnitOfWorkScope())
{
var user = _posRepository.GetPosByName(GridModel.PosName);
if (user != null)
{
throw new DuplicateKeyException();
}
//Create new Pos
newPos = new Pos(GridModel.PosName)
{
Phone = GridModel.Phone,
PrimaryContact = GridModel.PrimaryContact,
AdditionalEmailAdresses = GridModel.AdditionalEmailAdresses
};
newPos.SetIsActive(GridModel.IsActive);
//Save It
_posRepository.Save(newPos);
scope.Commit();
}
////Send Welcome email to created administrator
//sendWelcomeEmailToUserViewModel.To = newUser.UserName;
//MailService.SendWelcomeEmailToUser(sendWelcomeEmailToUserViewModel);
return(Json(GridModel));
}
}
catch (DuplicateKeyException)
{
ModelState.AddModelError(string.Empty, string.Format("Pos со име {0} веќе постои во системот.", GridModel.PosName));
}
throw CreateModelException(GridModel);
}
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,int>();
var savedCustomer = repository.Query.First(x => x.CustomerID == customer.CustomerID);
repository.Delete(savedCustomer);
scope.Commit();
}
using (var scope = new UnitOfWorkScope())
{
var repository = new EFRepository<Customer,int>();
Assert.IsNull(repository.Query.FirstOrDefault(x => x.CustomerID == customer.CustomerID));
scope.Commit();
}
}
public void Can_attach()
{
Customer customer = null;
var testData = new EFTestData(Context);
testData.Batch(x => customer = x.CreateCustomer());
testData.Context.Detach(customer);
Context.Dispose();
using (var scope = new UnitOfWorkScope())
{
var repository = new EFRepository<Customer,int>();
repository.Attach(customer);
customer.FirstName = "Changed";
scope.Commit();
}
testData = new EFTestData(Context);
customer = testData.Get<Customer>(x => x.CustomerID == customer.CustomerID);
Assert.AreEqual(customer.FirstName, "Changed");
}
public void changes_are_not_persisted_when_ambient_transaction_rolls_back()
{
using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
{
testData.Batch(actions => actions.CreateCustomer());
using (var ambientScope = new TransactionScope())
{
using (var scope = new UnitOfWorkScope())
{
var customer = new NHRepository<Customer>().First();
customer.FirstName = "Changed";
scope.Commit();
}
} //Auto rollback
using (var scope = new UnitOfWorkScope())
{
var customer = new NHRepository<Customer>().First();
Assert.That(customer.FirstName, Is.Not.EqualTo("Changed"));
}
}
}
public void Can_eager_fetch()
{
var testData = new EFTestData(Context);
Order order = null;
Order savedOrder = null;
testData.Batch(x => order = x.CreateOrderForCustomer(x.CreateCustomer()));
using (var scope = new UnitOfWorkScope())
{
savedOrder = new EFRepository<Order,int>()
.Fetch(o => o.Customer).Query
.Where(x => x.OrderID == order.OrderID)
.SingleOrDefault();
scope.Commit();
}
Assert.IsNotNull(savedOrder);
Assert.IsNotNull(savedOrder.Customer);
var firstName = savedOrder.Customer.FirstName;
}
public void can_commit()
{
var customer = new Customer
{
FirstName = "John",
LastName = "Doe"
};
using (var scope = new UnitOfWorkScope())
{
new EFRepository<Customer>()
.Add(customer);
scope.Commit();
}
using (var testData = new EFTestData(OrdersContextProvider()))
{
Customer savedCustomer = null;
testData.Batch(action => savedCustomer = action.GetCustomerById(customer.CustomerID));
Assert.That(savedCustomer, Is.Not.Null);
Assert.That(savedCustomer.CustomerID, Is.EqualTo(customer.CustomerID));
}
}
public void nested_commit_works()
{
var customer = new Customer { FirstName = "Joe", LastName = "Data" };
var order = new Order { OrderDate = DateTime.Now, ShipDate = DateTime.Now };
using (var scope = new UnitOfWorkScope())
{
new EFRepository<Customer>().Add(customer);
using (var scope2 = new UnitOfWorkScope())
{
new EFRepository<Order>().Add(order);
scope2.Commit();
}
scope.Commit();
}
using (var testData = new EFTestData(OrdersContextProvider()))
{
Customer savedCustomer = null;
Order savedOrder = null;
testData.Batch(actions =>
{
savedCustomer = actions.GetCustomerById(customer.CustomerID);
savedOrder = actions.GetOrderById(order.OrderID);
});
Assert.That(savedCustomer, Is.Not.Null);
Assert.That(savedCustomer.CustomerID, Is.EqualTo(customer.CustomerID));
Assert.That(savedOrder, Is.Not.Null);
Assert.That(savedOrder.OrderID, Is.EqualTo(order.OrderID));
}
}
protected void RemovePermissionsFromRole(List<Permission> permissions, Role role, Func<ICollection<Permission>, Permission, ICollection<Permission>> changePermission)
{
if (permissions == null || permissions.Count == 0 || role == null)
return;
StringBuilder message = new StringBuilder(), items = new StringBuilder(); ;
foreach (var perm in permissions)
{
if (perm != null)
{
if (role.Permissions.Contains<Permission>(perm))
{
changePermission(role.Permissions, perm);
items.AppendFormat("{0},", perm.Name);
}
}
}
using (var scope = new UnitOfWorkScope())
{
_roleRepository.Update(role);
scope.Commit();
}
if (items.Length > 0)
{
items = items.Remove(items.Length - 1, 1);
message.AppendFormat("Permission(s) {0} are removed from role {1}.", items.ToString(), role.Name);
ActivityLog item = new ActivityLog(ActivityType.RemovePermissionFromRole.ToString(), message.ToString());
_activityLogService.Add(item);
}
}
/// <summary>
/// Deletes a item
/// </summary>
/// <param name="item">item</param>
public virtual bool Delete(ActivityLog item)
{
if (item == null)
throw new ArgumentNullException("item");
using (var scope = new UnitOfWorkScope())
{
_repository.Delete(item);
scope.Commit();
}
//event notification
_eventPublisher.EntityDeleted(item);
return true;
}
public void nested_commit_with_seperate_transaction_commits_when_wrapping_scope_rollsback()
{
var customer = new Customer { FirstName = "Joe", LastName = "Data" };
var order = new Order { OrderDate = DateTime.Now, ShipDate = DateTime.Now };
using (var scope = new UnitOfWorkScope())
{
new EFRepository<Customer>().Add(customer);
using (var scope2 = new UnitOfWorkScope(TransactionMode.New))
{
new EFRepository<Order>().Add(order);
scope2.Commit();
}
} //Rollback
using (var testData = new EFTestData(OrdersContextProvider()))
{
Customer savedCustomer = null;
Order savedOrder = null;
testData.Batch(actions =>
{
savedCustomer = actions.GetCustomerById(customer.CustomerID);
savedOrder = actions.GetOrderById(order.OrderID);
});
Assert.That(savedCustomer, Is.Null);
Assert.That(savedOrder, Is.Not.Null);
Assert.That(savedOrder.OrderID, Is.EqualTo(order.OrderID));
}
}
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 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 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 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 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 rollback_does_not_rollback_supressed_scope()
{
var customer = new Customer { FirstName = "Joe", LastName = "Data" };
var order = new Order { OrderDate = DateTime.Now, ShipDate = DateTime.Now };
using (var scope = new UnitOfWorkScope())
{
new EFRepository<Customer>().Add(customer);
using (var scope2 = new UnitOfWorkScope(TransactionMode.Supress))
{
new EFRepository<Order>().Add(order);
scope2.Commit();
}
} //Rollback.
using (var testData = new EFTestData(OrdersContextProvider()))
{
Customer savedCustomer = null;
Order savedOrder = null;
testData.Batch(actions =>
{
savedCustomer = actions.GetCustomerById(customer.CustomerID);
savedOrder = actions.GetOrderById(order.OrderID);
});
Assert.That(savedCustomer, Is.Null);
Assert.That(savedOrder, Is.Not.Null);
}
}
