public void CanApplySortedQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var allFishes = unitOfWork.Repository.Query<Fish>().OrderBy(x => x.Color).ToList();
var queryFishes = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSortedSpecification("Na", "Color", true)).ToList();
queryFishes.Count.Should().Be.EqualTo(allFishes.Count);
for (var i = 0; i < queryFishes.Count; i++)
{
var fish = allFishes.ElementAt(i);
var queryFish = queryFishes.ElementAt(i);
fish.Name.Should().Be.EqualTo(queryFish.Name);
fish.Color.Should().Be.EqualTo(queryFish.Color);
fish.Should().Be.EqualTo(queryFish);
}
allFishes = unitOfWork.Repository.Query<Fish>().OrderByDescending(x => x.Color).ToList();
queryFishes = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSortedSpecification("Na", "Color", false)).ToList();
queryFishes.Count.Should().Be.EqualTo(allFishes.Count);
for (var i = 0; i < queryFishes.Count; i++)
{
var fish = allFishes.ElementAt(i);
var queryFish = queryFishes.ElementAt(i);
fish.Name.Should().Be.EqualTo(queryFish.Name);
fish.Color.Should().Be.EqualTo(queryFish.Color);
fish.Should().Be.EqualTo(queryFish);
}
}
}
public async Task CanApplySortedQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var allFishes = (await unitOfWork.Repository.QueryAsync <Fish>()).OrderBy(x => x.Color).ToList();
var queryFishes = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSortedSpecification("Na", "Color", true))).ToList();
queryFishes.Count.Should().Be.EqualTo(allFishes.Count);
for (var i = 0; i < queryFishes.Count; i++)
{
var fish = allFishes.ElementAt(i);
var queryFish = queryFishes.ElementAt(i);
fish.Name.Should().Be.EqualTo(queryFish.Name);
fish.Color.Should().Be.EqualTo(queryFish.Color);
fish.Should().Be.EqualTo(queryFish);
}
allFishes = (await unitOfWork.Repository.QueryAsync <Fish>()).OrderByDescending(x => x.Color).ToList();
queryFishes = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSortedSpecification("Na", "Color", false))).ToList();
queryFishes.Count.Should().Be.EqualTo(allFishes.Count);
for (var i = 0; i < queryFishes.Count; i++)
{
var fish = allFishes.ElementAt(i);
var queryFish = queryFishes.ElementAt(i);
fish.Name.Should().Be.EqualTo(queryFish.Name);
fish.Color.Should().Be.EqualTo(queryFish.Color);
fish.Should().Be.EqualTo(queryFish);
}
}
}
public void CommitSingleRepositoryTest()
{
var mockRepo = new Mock <IUnitOfWorkRepository>();
var domainUser = new FakeDomainUser {
Id = Guid.NewGuid(),
Name = "test"
};
var uow = new InMemoryUnitOfWork();
uow.RegisterInsertion(domainUser, mockRepo.Object);
domainUser.Name = "test";
uow.RegisterUpdate(domainUser, mockRepo.Object);
uow.RegisterDeletion(domainUser, mockRepo.Object);
uow.Commit();
mockRepo.Verify(w => w.PersistInsertion(domainUser), Times.Once);
mockRepo.Verify(w => w.PersistUpdate(domainUser), Times.Once);
mockRepo.Verify(w => w.PersistDeletion(domainUser), Times.Once);
}
public void CanApplySortedQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var allFishes = unitOfWork.Repository.Query <Fish>().OrderBy(x => x.Color).ToList();
var queryFishes = unitOfWork.Repository.ApplyQuery(new SearchFishSortedQuery("Na", "Color", true)).ToList();
queryFishes.Count.Should().Be.EqualTo(allFishes.Count);
for (var i = 0; i < queryFishes.Count; i++)
{
var fish = allFishes.ElementAt(i);
var queryFish = queryFishes.ElementAt(i);
fish.Name.Should().Be.EqualTo(queryFish.Name);
fish.Color.Should().Be.EqualTo(queryFish.Color);
fish.Should().Be.EqualTo(queryFish);
}
allFishes = unitOfWork.Repository.Query <Fish>().OrderByDescending(x => x.Color).ToList();
queryFishes = unitOfWork.Repository.ApplyQuery(new SearchFishSortedQuery("Na", "Color", false)).ToList();
queryFishes.Count.Should().Be.EqualTo(allFishes.Count);
for (var i = 0; i < queryFishes.Count; i++)
{
var fish = allFishes.ElementAt(i);
var queryFish = queryFishes.ElementAt(i);
fish.Name.Should().Be.EqualTo(queryFish.Name);
fish.Color.Should().Be.EqualTo(queryFish.Color);
fish.Should().Be.EqualTo(queryFish);
}
}
}
public void ConfigureServices(IServiceCollection services)
{
IUnitOfWork unitOfWork = new InMemoryUnitOfWork();
services.AddSingleton <IUnitOfWork>(unitOfWork);
services.AddTransient <BudgetLoader>();
}
private static void FindEmployee(InMemoryUnitOfWork inMemoryUnitOfWork)
{
var employee = inMemoryUnitOfWork.Employees.Single(e => e.Name == "Lenny");
Console.WriteLine(employee.ToString());
inMemoryUnitOfWork.Commit();
}
public static LibraryApi InitLibraryApi()
{
var data = new DataBaseManager("D:\\1_Sof\\BookStore\\Src\\BookStore.Presentation");
var unitOfWork = new InMemoryUnitOfWork(data);
return(new LibraryApi(unitOfWork));
}
public EmployeeControllerTestBase()
{
_employeeData = EmployeeObjectMother.CreateEmployees()
.ToList();
_repository = new InMemoryObjectSet <Employee>(_employeeData);
_unitOfWork = new InMemoryUnitOfWork();
_unitOfWork.Employees = _repository;
_controller = new EmployeeController(_unitOfWork);
}
public static IPublishCommands GetCommandPublisher()
{
var commandPublisher = new LocalCommandPublisher();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
commandPublisher.Subscribe(new ClientService(unitOfWork, Logger));
return(commandPublisher);
}
public static IPublishCommands GetCommandPublisher()
{
var commandPublisher = new LocalCommandPublisher();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
commandPublisher.Subscribe(new ClientService(unitOfWork, Logger));
return commandPublisher;
}
private static void RemoveEmployee(InMemoryUnitOfWork inMemoryUnitOfWork)
{
var employee = inMemoryUnitOfWork.Employees.Single(e => e.Name == "Lenny");
inMemoryUnitOfWork.Employees.DeleteObject(employee);
Console.WriteLine("Removed {0}", employee);
inMemoryUnitOfWork.Commit();
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository <Client>()
.Add(new Client("Adrian Freemantle", "0845140900"));
unitOfWork.Commit();
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository<Client>()
.Add(new Client("Adrian Freemantle", "0845140900"));
unitOfWork.Commit();
}
public void CanQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = unitOfWork.Repository.Query <Fish>().Count();
var countCat = unitOfWork.Repository.Query <Cat>().Count();
countFish.Should().Be.EqualTo(5);
countCat.Should().Be.EqualTo(10);
}
}
private static void UpdateEmployee(InMemoryUnitOfWork inMemoryUnitOfWork)
{
var employee = inMemoryUnitOfWork.Employees.Single(e => e.Name == "Mr Burns");
employee.Name = "Waylon Smithers";
Console.WriteLine("Updated {0}", employee);
inMemoryUnitOfWork.Commit();
}
public async Task CanQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count();
var countCat = (await unitOfWork.Repository.QueryAsync <Cat>()).Count();
countFish.Should().Be.EqualTo(5);
countCat.Should().Be.EqualTo(10);
}
}
public void CanAdd()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = unitOfWork.Repository.Query<Fish>().Count();
unitOfWork.Repository.Add(new Fish());
unitOfWork.Commit();
var newCountFish = unitOfWork.Repository.Query<Fish>().Count();
newCountFish.Should().Be.EqualTo(countFish + 1);
}
}
public void CanAdd()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = unitOfWork.Repository.Query <Fish>().Count();
unitOfWork.Repository.Add(new Fish());
unitOfWork.Commit();
var newCountFish = unitOfWork.Repository.Query <Fish>().Count();
newCountFish.Should().Be.EqualTo(countFish + 1);
}
}
private static void AddEmployee(InMemoryUnitOfWork inMemoryUnitOfWork)
{
var employee = new Employee {
Name = "Bart Simpson"
};
inMemoryUnitOfWork.Employees.AddObject(employee);
Console.WriteLine("Added {0}", employee);
inMemoryUnitOfWork.Commit();
}
public async Task CanApplyQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count();
var queryFish = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSpecification("Na"))).ToList();
queryFish.Count.Should().Be.EqualTo(countFish);
queryFish = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSpecification(string.Empty))).ToList();
queryFish.Count.Should().Be.EqualTo(countFish);
queryFish = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSpecification("notexistingname"))).ToList();
queryFish.Count.Should().Be.EqualTo(0);
}
}
public async Task CanAdd()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count();
await unitOfWork.Repository.AddAsync(new Fish());
await unitOfWork.CommitAsync();
var newCountFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count();
newCountFish.Should().Be.EqualTo(countFish + 1);
}
}
public void CanApplyQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = unitOfWork.Repository.Query<Fish>().Count();
var queryFish = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSpecification("Na")).ToList();
queryFish.Count.Should().Be.EqualTo(countFish);
queryFish = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSpecification("")).ToList();
queryFish.Count.Should().Be.EqualTo(countFish);
queryFish = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSpecification("notexistingname")).ToList();
queryFish.Count.Should().Be.EqualTo(0);
}
}
public void CanUpdate()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var fish = unitOfWork.Repository.Query <Fish>().First();
fish.Name.Should().Not.Be.EqualTo("NewName");
fish.Name = "NewName";
unitOfWork.Repository.Update(fish);
unitOfWork.Commit();
var updatedFish = unitOfWork.Repository.Query <Fish>().First(x => x.Id == fish.Id);
updatedFish.Name.Should().Be.EqualTo("NewName");
}
}
public void CanApplyQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = unitOfWork.Repository.Query <Fish>().Count();
var queryFish = unitOfWork.Repository.ApplyQuery(new SearchFishQuery("Na")).ToList();
queryFish.Count.Should().Be.EqualTo(countFish);
queryFish = unitOfWork.Repository.ApplyQuery(new SearchFishQuery("")).ToList();
queryFish.Count.Should().Be.EqualTo(countFish);
queryFish = unitOfWork.Repository.ApplyQuery(new SearchFishQuery("notexistingname")).ToList();
queryFish.Count.Should().Be.EqualTo(0);
}
}
public void Commit()
{
var uow = new InMemoryUnitOfWork();
var employees = uow.Employees;
employees.First().Name = "Bob";
employees.Last().Name = "Kim";
Assert.False(uow.Committed);
uow.Commit();
Assert.True(uow.Committed);
}
private void AcquirerDependencies()
{
if (Mapper == null)
{
Mapper = new EntierBuiltinMapper();
}
if (UnitOfWork == null)
{
UnitOfWork = new InMemoryUnitOfWork();
}
Service = AcquirerCrudService();
}
public async Task CanUpdate()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var fish = (await unitOfWork.Repository.QueryAsync <Fish>()).First();
fish.Name.Should().Not.Be.EqualTo("NewName");
fish.Name = "NewName";
await unitOfWork.Repository.UpdateAsync(fish);
await unitOfWork.CommitAsync();
var updatedFish = (await unitOfWork.Repository.QueryAsync <Fish>()).First(x => x.Id == fish.Id);
updatedFish.Name.Should().Be.EqualTo("NewName");
}
}
public static void Main(string[] args)
{
var employees = GenerateEmployeeList();
InMemoryObjectSet <Employee> employeeObjectSet = new InMemoryObjectSet <Employee>(employees);
InMemoryUnitOfWork inMemoryUnitOfWork = new InMemoryUnitOfWork();
inMemoryUnitOfWork.Employees = employeeObjectSet;
FindEmployee(inMemoryUnitOfWork);
AddEmployee(inMemoryUnitOfWork);
RemoveEmployee(inMemoryUnitOfWork);
UpdateEmployee(inMemoryUnitOfWork);
Console.ReadLine();
}
public void DisposeWorksCorrectly()
{
//Arrange
var cluster = Cluster.Builder().AddContactPoint("127.0.0.1").Build();
var unitOfWork = new InMemoryUnitOfWork();
var repository = new BaseRepository <Foo>(this._unitOfWork);
//Act
repository.Insert(new Foo {
Id = Guid.NewGuid()
});
unitOfWork.SaveChanges();
unitOfWork.Dispose();
//Assert
}
public void CommitEmptyTest()
{
var mockRepo = new Mock <IUnitOfWorkRepository>();
var domainUser = new FakeDomainUser {
Id = Guid.NewGuid(),
Name = "test"
};
var uow = new InMemoryUnitOfWork();
uow.Commit();
mockRepo.Verify(w => w.PersistInsertion(domainUser), Times.Never);
mockRepo.Verify(w => w.PersistUpdate(domainUser), Times.Never);
mockRepo.Verify(w => w.PersistDeletion(domainUser), Times.Never);
}
public void ResetUnitOfWork()
{
_unitOfWork = new InMemoryUnitOfWork()
{
Assets = _repositoryAsset,
AssetSettings = _repositoryAssetSetting,
AssetTransactions = _repositoryAssetTransaction,
AssetTypes = _repositoryAssetType,
//AssetTypesRelationshipTypes = _repositoryAssetTypeRelationshipType,
//AssetTypesSettingTypes = _repositoryAssetTypeSettingType,
//ParentChildRelationshipTypes = _repositoryParentChildRelationshipType,
//RelationshipTypes = _repositoryRelationshipType,
//SettingTypes = _repositorySettingType,
TransactionCategories = _repositoryTransactionCategory,
//TransactionDescriptions = _repositoryTransactionDescription,
TransactionTypes = _repositoryTransactionType
};
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository <Client>()
.Add(new Client
{
ClientName = "Adrian Freemantle",
Email = "*****@*****.**",
PhoneNumber = "0125551111",
Street = "Alon road",
City = "Sandton",
StreetNumber = "9",
PostalCode = "0001",
});
unitOfWork.Commit();
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository<Client>()
.Add(new Client
{
ClientName = "Adrian Freemantle",
Email = "*****@*****.**",
PhoneNumber = "0125551111",
Street = "Alon road",
City = "Sandton",
StreetNumber = "9",
PostalCode = "0001",
});
unitOfWork.Commit();
}
public static IPublishCommands GetCommandPublisher(bool useDatabase)
{
var commandPublisher = new LocalCommandPublisher();
IUnitOfWork unitOfWork;
if (useDatabase)
{
DbContext dbContext = new AbsaContext("AbsaBank_Dev", OnContextCreationEnum.CreateIfDoesntExist);
unitOfWork = new UnitOfWork(dbContext);
}
else
{
unitOfWork = new InMemoryUnitOfWork(DataStore);
}
commandPublisher.Subscribe(new ClientService(unitOfWork, Logger));
return commandPublisher;
}
public void CanCreateEmployee()
{
var uniqueId = "15102013";
var firstName = "Employee";
var lastName = "Sweat";
var middleName = "Super";
var gender = "Male";
var dateOfBirth = "02/02/1990";
var email = "*****@*****.**";
var contactNo = "0922222222222";
using (var unitOfWork = new InMemoryUnitOfWork())
{
var employeeRepository = new InMemoryEmployeeRepository(unitOfWork);
var employeeService = new EmployeeWebService(employeeRepository);
var employeeWebData = new EmployeeWebData
{
UniqueId = uniqueId,
FirstName = firstName,
LastName = lastName,
MiddleName = middleName,
Gender = gender,
DateOfBirth = dateOfBirth,
Email = email,
ContactNo = contactNo
};
employeeService.CreateEmployee(employeeWebData);
var retrieveWebData = (EmployeeWebData)employeeService.RetrieveAll().First();
Assert.Equal(firstName, retrieveWebData.FirstName);
Assert.Equal(lastName, retrieveWebData.LastName);
Assert.Equal(middleName, retrieveWebData.MiddleName);
Assert.Equal(gender, retrieveWebData.Gender);
Assert.Equal(dateOfBirth, retrieveWebData.DateOfBirth);
Assert.Equal(email, retrieveWebData.Email);
Assert.Equal(contactNo, retrieveWebData.ContactNo);
}
}
public void ProvidesSuitableMetadataOnEvents()
{
var timeForFirstEvent = new DateTime(1979, 3, 19, 19, 0, 0, DateTimeKind.Utc);
var timeForNextEvent = timeForFirstEvent.AddMilliseconds(2);
var aggregateRootRepository = CreateAggregateRootRepository();
var eventCollector = new InMemoryUnitOfWork(aggregateRootRepository, _defaultDomainTypeNameMapper);
var someAggregate = new SomeAggregate
{
UnitOfWork = eventCollector,
};
someAggregate.Initialize("root_id");
TimeMachine.FixCurrentTimeTo(timeForFirstEvent);
someAggregate.DoSomething();
TimeMachine.FixCurrentTimeTo(timeForNextEvent);
someAggregate.DoSomething();
var events = eventCollector.Cast <SomeEvent>().ToList();
var firstEvent = events[0];
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.TimeUtc], Is.EqualTo(timeForFirstEvent.ToString("u")));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.Owner], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeAggregate, d60.Cirqus.Tests"));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.Type], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeEvent, d60.Cirqus.Tests"));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.SequenceNumber], Is.EqualTo("0"));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.AggregateRootId], Is.EqualTo("root_id"));
var nextEvent = events[1];
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.TimeUtc], Is.EqualTo(timeForNextEvent.ToString("u")));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.Owner], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeAggregate, d60.Cirqus.Tests"));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.Type], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeEvent, d60.Cirqus.Tests"));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.SequenceNumber], Is.EqualTo("1"));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.AggregateRootId], Is.EqualTo("root_id"));
}
public static void AuthenticateUser(User user)
{
var userProvider = new Mock <IUserProvider>();
userProvider.Setup(provider => provider.GetCurrentUserEmail(It.IsAny <HttpContextBase>()))
.Returns(user.EMail);
Container.Instance.RegisterInstance <IUserProvider>(userProvider.Object);
var unitOfWork = new InMemoryUnitOfWork();
unitOfWork.Users.Add(user);
Container.Instance.RegisterInstance <IUnitOfWork>(unitOfWork);
var membershipProvider = new Mock <IMembershipProvider>();
membershipProvider.Setup(provider => provider.Validate(user.EMail, user.Password)).Returns(true);
Container.Instance.RegisterInstance <IMembershipProvider>(membershipProvider.Object);
var webSecurity = new Mock <IWebSecurity>();
Container.Instance.RegisterInstance <IWebSecurity>(webSecurity.Object);
}
private void InitSeedData()
{
DataStore = new InMemoryDataStore();
var unitOfWork = new InMemoryUnitOfWork(DataStore);
unitOfWork.GetRepository<Client>()
.Add(new Client
{
ClientName = "Adrian Freemantle",
Email = "*****@*****.**",
PhoneNumber = "0125551111",
Street = "Alon road",
City = "Sandton",
StreetNumber = "9",
PostalCode = "0001"
});
unitOfWork.GetRepository<Account>()
.Add(new Account
{
AccountNumber = "1048163555",
Balance = 1000,
Closed = false,
ClientId = 1
});
unitOfWork.GetRepository<BankCard>()
.Add(new BankCard
{
AccountId = 1,
ClientId = 1,
Disabled = false
});
unitOfWork.Commit();
}
public void CanQuery()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var countFish = unitOfWork.Repository.Query<Fish>().Count();
var countCat = unitOfWork.Repository.Query<Cat>().Count();
countFish.Should().Be.EqualTo(5);
countCat.Should().Be.EqualTo(10);
}
}
public void CanUpdate()
{
using (var unitOfWork = new InMemoryUnitOfWork(_arrayList))
{
var fish = unitOfWork.Repository.Query<Fish>().First();
fish.Name.Should().Not.Be.EqualTo("NewName");
fish.Name = "NewName";
unitOfWork.Repository.Update(fish);
unitOfWork.Commit();
var updatedFish = unitOfWork.Repository.Query<Fish>().First(x => x.Id == fish.Id);
updatedFish.Name.Should().Be.EqualTo("NewName");
}
}
