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