public void AddingEventsWithProperExpectedVersionToExistingEventDescriptorsPopulatesDatabase()
{
var aggregateId = Guid.NewGuid();
var databaseMock = new DatabaseMock<EventDescriptors>();
var existingEvents = new EventDescriptors{ Id = aggregateId };
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 0));
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 1));
databaseMock.Put(existingEvents);
var initialCount = existingEvents.Count();
var expectedVersion = existingEvents.Count() - 1;
IConcurrencyConflictResolver conflictResolver = null;
var newEvents = new List<Event>
{
new Event(),
new Event()
};
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
eventStore.SaveEvents(
aggregateId,
newEvents,
expectedVersion,
conflictResolver);
var actual = databaseMock.Get(aggregateId.ToString());
Assert.NotNull(actual);
Assert.Equal(newEvents.Count + initialCount, actual.Count());
publisherMock.AssertPublishCount<Event>(newEvents.Count());
}
public void AddingEventsToEmptyDatabaseCreatesProperEventsInDatabase()
{
var aggregateId = Guid.NewGuid();
var expectedVersion = -1;
IConcurrencyConflictResolver conflictResolver = null;
var events = new List<Event>
{
new Event(),
new Event()
};
var databaseMock = new DatabaseMock<EventDescriptors>();
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
eventStore.SaveEvents(
aggregateId,
events,
expectedVersion,
conflictResolver);
var actual = databaseMock.Get(aggregateId.ToString());
Assert.NotNull(actual);
Assert.Equal(events.Count, actual.Count());
publisherMock.AssertPublishCount<Event>(events.Count());
}
public void CalculateDeposits_Tests()
{
var dbMock = new DatabaseMock(5000, 1200, 5);
var service = new DepositService2(dbMock);
service.CalculateDeposits();
Assert.AreEqual(5, dbMock.IncreasingAmount);
}
public void SetUp()
{
_mapper = MapperFactory.Create();
_databaseMock = new DatabaseMock <SessionDao>();
_sessionRepoMock = new SessionRepositoryMock();
_timeEntryRepoMock = new TimeEntryRepositoryMock();
_sessionSvc = new SessionService(
_mapper,
_sessionRepoMock.Object,
_timeEntryRepoMock.Object
);
}
public async Task DeleteAll_Ok()
{
var testResultEntities = TestEntitiesData.TestResultEntities;
var testTableMock = DatabaseTableDeleteTest.GetTestDatabaseTable(testResultEntities);
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
testConverter);
var resultEntity = await testService.Delete();
Assert.True(resultEntity.OkStatus);
}
public async Task Put_Ok()
{
var testDomainPut = TestData.TestDomains.First();
var testTableMock = DatabaseTablePutMock.GetTestDatabaseTable();
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var validateService = TestValidateServicePutMock.GetDatabaseValidateService();
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
validateService.Object, testConverter);
var result = await testService.Put(testDomainPut);
Assert.True(result.OkStatus);
}
public async Task GetId_Error()
{
var errorInitial = ErrorData.DatabaseError;
var testResultEntities = new ResultCollection <TestEntity>(errorInitial);
var testTableMock = DatabaseTableGetMock.GetTestDatabaseTable(testResultEntities);
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
testConverter);
var testResult = await testService.Get(It.IsAny <TestEnum>());
Assert.True(testResult.HasErrors);
Assert.Equal(errorInitial.ErrorResultType, testResult.Errors.First().ErrorResultType);
}
public async Task GetId_NotFound()
{
var testResultEntities = TestEntitiesData.TestResultEntities;
var testTableMock = DatabaseTableGetMock.GetTestDatabaseTable(testResultEntities,
DatabaseTableGetMock.FirstNotFoundFunc(testResultEntities));
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
testConverter);
var testResult = await testService.Get(It.IsAny <TestEnum>());
Assert.True(testResult.HasErrors);
Assert.Equal(ErrorResultType.ValueNotFound, testResult.Errors.First().ErrorResultType);
}
public async Task Put_UpdateError()
{
var testDomainPut = TestData.TestDomains.First();
var testTableMock = DatabaseTablePutMock.GetTestDatabaseTable(DatabaseTablePutMock.UpdateError());
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var validateService = TestValidateServicePutMock.GetDatabaseValidateService();
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
validateService.Object, testConverter);
var result = await testService.Put(testDomainPut);
Assert.True(result.HasErrors);
Assert.Equal(ErrorResultType.DatabaseTableAccess, result.Errors.First().ErrorResultType);
}
public async Task Post_Collection_Error()
{
var testDomains = TestData.TestDomains;
var testTableMock = DatabaseTablePostMock.GetTestDatabaseTable();
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var validateService = TestValidateServicePostMock.GetDatabaseValidateService(TestValidateServicePostMock.DuplicateCollectionFunc());
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
validateService.Object, testConverter);
var resultIds = await testService.Post(testDomains);
Assert.True(resultIds.HasErrors);
Assert.Equal(ErrorResultType.DatabaseValueDuplicate, resultIds.Errors.First().ErrorResultType);
}
public void FindAllApplications_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var applicationsAccessor = accessorFactory.CreateAccessor <IApplicationsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
// Act
var result = applicationsAccessor.FindAllApplications();
// Assert
Assert.NotEmpty(result);
}
public async Task Post_Value_OK()
{
var testDomain = TestData.TestDomains.First();
var testTableMock = DatabaseTablePostMock.GetTestDatabaseTable();
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var validateService = TestValidateServicePostMock.GetDatabaseValidateService();
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
validateService.Object, testConverter);
var resultId = await testService.Post(testDomain);
Assert.True(resultId.OkStatus);
Assert.True(resultId.Value.Equals(testDomain.Id));
}
public async Task Post_Value_SavingError()
{
var testDomain = TestData.TestDomains.First();
var testTableMock = DatabaseTablePostMock.GetTestDatabaseTable(DatabaseTablePostMock.AddIdError());
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var validateService = TestValidateServicePostMock.GetDatabaseValidateService();
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
validateService.Object, testConverter);
var resultId = await testService.Post(testDomain);
Assert.True(resultId.HasErrors);
Assert.Equal(ErrorResultType.DatabaseTableAccess, resultId.Errors.First().ErrorResultType);
}
public async Task Post_Collection_OK()
{
var testDomains = TestData.TestDomains;
var testTableMock = DatabaseTablePostMock.GetTestDatabaseTable();
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var validateService = TestValidateServicePostMock.GetDatabaseValidateService();
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
validateService.Object, testConverter);
var resultIds = await testService.Post(testDomains);
Assert.True(resultIds.OkStatus);
Assert.True(resultIds.Value.SequenceEqual(TestData.GetTestIds(testDomains)));
}
public void FindAllUserClaims_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var userClaimsAccessor = accessorFactory.CreateAccessor <IUserClaimsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var userId = DatabaseMock.GetId("userId");
// Act
var result = userClaimsAccessor.FindAllUserClaims(userId);
// Assert
Assert.NotEmpty(result);
}
public async Task Get_OK()
{
var testEntities = TestEntitiesData.TestEntities;
var testTableMock = DatabaseTableGetMock.GetTestDatabaseTable(testEntities);
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock);
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock,
testConverter);
var testResult = await testService.Get();
var testEntitiesGet = testConverter.FromEntities(testEntities);
Assert.True(testResult.OkStatus);
Assert.True(testResult.Value.SequenceEqual(testEntitiesGet.Value));
}
public void DeleteClaim_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var claimsAccessor = accessorFactory.CreateAccessor <IClaimsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var claimId = DatabaseMock.GetId("claimId");
// Act
claimsAccessor.DeleteClaim(claimId);
// Assert
Assert.Null(claimsAccessor.Find(claimId));
}
public void GetApplicationUsers_StateUnderTest_ExpectedBehavior()
{
// Arrange
var managerFactory = new ManagerFactory();
var manager = managerFactory.CreateManager <IApplicationManager>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
string applicationName = DatabaseMock.GetValue("applicationName");
// Act
var result = manager.GetApplicationUsers(applicationName);
// Assert
Assert.NotEmpty(result);
}
public async Task Delete_DeleteError()
{
var testDelete = TestData.TestDomains.Last();
var testResultEntities = TestEntitiesData.TestResultEntities;
var testTableMock = DatabaseTableDeleteTest.GetTestDatabaseTable(testResultEntities,
DatabaseTableDeleteTest.DeleteErrorFunc());
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
testConverter);
var resultEntity = await testService.Delete(testDelete.Id);
Assert.True(resultEntity.HasErrors);
Assert.Equal(ErrorResultType.DatabaseTableAccess, resultEntity.Errors.First().ErrorResultType);
}
public void GetUser_StateUnderTest_ExpectedBehavior()
{
// Arrange
var managerFactory = new ManagerFactory();
var manager = managerFactory.CreateManager <IApplicationManager>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var userId = DatabaseMock.GetId("userId");
// Act
var result = manager.GetUser(userId);
// Assert
Assert.NotEmpty(result.Applications);
}
public void FindAllUsersForApplication_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var applicationsAccessor = accessorFactory.CreateAccessor <IApplicationsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
string applicationName = DatabaseMock.GetValue("applicationName");
// Act
var result = applicationsAccessor.FindAllUsersForApplication(applicationName);
// Assert
Assert.NotEmpty(result);
}
public void DeleteApplication_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var applicationsAccessor = accessorFactory.CreateAccessor <IApplicationsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var applicationId = DatabaseMock.GetId("applicationId");
// Act
applicationsAccessor.DeleteApplication(applicationId);
// Assert
Assert.Null(applicationsAccessor.Find(applicationId));
}
public async Task DeleteAll_DeleteError()
{
var errorInitial = ErrorData.DatabaseError;
var resultDelete = new ResultError(errorInitial);
var testResultEntities = TestEntitiesData.TestResultEntities;
var testTableMock = DatabaseTableDeleteTest.GetTestDatabaseTable(testResultEntities, resultDelete);
var testDatabaseMock = DatabaseMock.GetTestDatabase(testTableMock.Object);
var testConverter = TestEntityConverterMock.TestEntityConverter;
var testService = DatabaseServiceMock.GetTestDatabaseService(testDatabaseMock.Object, testTableMock.Object,
testConverter);
var resultEntity = await testService.Delete();
Assert.True(resultEntity.HasErrors);
Assert.True(errorInitial.Equals(resultEntity.Errors.First()));
}
public void Find_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var applicationsAccessor = accessorFactory.CreateAccessor <IApplicationsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var applicationId = DatabaseMock.GetId("applicationId");
// Act
var result = applicationsAccessor.Find(applicationId);
// Assert
Assert.Equal(expected: applicationId, actual: result.Id);
}
public void RemoveApplication_StateUnderTest_ExpectedBehavior()
{
// Arrange
var managerFactory = new ManagerFactory();
var manager = managerFactory.CreateManager <IApplicationManager>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var applicationId = DatabaseMock.GetId("applicationId");
string applicationName = DatabaseMock.GetValue("applicationName");
// Act
manager.RemoveApplication(applicationId);
// Assert
Assert.Null(manager.GetApplicationUsers(applicationName));
}
public void GetUser_StateUnderTest_ExpectedBehavior()
{
// Arrange
ActorSystem actorSystem = ActorSystem.Create("TestActorSystem");
Props actorRouter = Props.Create <ApplicationsActor>().WithRouter(new RoundRobinPool(5));
IActorRef actorPool = actorSystem.ActorOf(actorRouter, "Test");
var applicationsController = new ApplicationsController(actorPool);
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var userId = DatabaseMock.GetId("userId");
// Act
var result = applicationsController.GetUser(userId).Result;
// Assert
Assert.NotNull(result.Value.Applications);
}
public void RemoveApplication_StateUnderTest_ExpectedBehavior()
{
// Arrange
ActorSystem actorSystem = ActorSystem.Create("TestActorSystem");
Props actorRouter = Props.Create <ApplicationsActor>().WithRouter(new RoundRobinPool(5));
IActorRef actorPool = actorSystem.ActorOf(actorRouter, "Test");
var applicationsController = new ApplicationsController(actorPool);
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var applicationId = DatabaseMock.GetId("applicationId");
// Act
var result = applicationsController.RemoveApplication(applicationId).Result;
// Assert
Assert.IsType <AcceptedResult>(result);
}
public void DeleteMembership_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var membershipsAccessor = accessorFactory.CreateAccessor <IMembershipsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var membershipId = DatabaseMock.GetId("membershipId");
var userId = DatabaseMock.GetId("userId");
// Act
membershipsAccessor.DeleteMembership(membershipId);
var result = membershipsAccessor.FindAllUserApplications(userId).Where(membership => membership.Id == membershipId);
// Assert
Assert.Empty(result);
}
public void AddApplication_StateUnderTest_ExpectedBehavior()
{
// Arrange
ActorSystem actorSystem = ActorSystem.Create("TestActorSystem");
Props actorRouter = Props.Create <ApplicationsActor>().WithRouter(new RoundRobinPool(5));
IActorRef actorPool = actorSystem.ActorOf(actorRouter, "Test");
var applicationsController = new ApplicationsController(actorPool);
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
string applicationName = DatabaseMock.GetValue("applicationName");
// Act
var result = applicationsController.AddApplication(applicationName).Result;
// Assert
Assert.NotNull(result.Value);
}
public async Task ConfigureMongoDbIndexesService_Executes_Task()
{
var target = CreateTarget();
var task = target.StartAsync(CancellationToken.None);
await task;
await Task.Delay(1000);
Assert.IsTrue(task.IsCompleted);
await target.StopAsync(CancellationToken.None);
VerifyInformationWasLogged(LoggerMock);
ClientMock.Verify(s => s.GetDatabase(It.IsAny <string>(), null), Times.Once);
DatabaseMock.Verify(
s => s.GetCollection <User>(nameof(User), null), Times.Once);
CollectionMock.VerifyGet(s => s.Indexes, Times.Once);
IndexManagerMock.Verify(
s => s.CreateOneAsync(It.IsAny <CreateIndexModel <User> >(), null, CancellationToken.None),
Times.Once);
}
public void SaveClaim_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var claimsAccessor = accessorFactory.CreateAccessor <IClaimsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var id = DatabaseMock.GetId("Applications");
var claim = new Claim
{
Id = Guid.NewGuid(),
ApplicationId = id,
ClaimType = Guid.NewGuid().ToString(),
ClaimValue = Guid.NewGuid().ToString()
};
// Act
var result = claimsAccessor.SaveClaim(claim);
// Assert
Assert.NotNull(result);
}
public void SaveUserClaim_StateUnderTest_ExpectedBehavior()
{
// Arrange
var accessorFactory = new AccessorFactory();
var userClaimsAccessor = accessorFactory.CreateAccessor <IUserClaimsAccessor>();
var DatabaseMock = new DatabaseMock();
DatabaseMock.SeedDatabase();
var claimId = DatabaseMock.GetId("claimId");
var userId = DatabaseMock.GetId("userId");
var userClaim = new UserClaim
{
Id = Guid.NewGuid(),
ClaimId = claimId,
UserId = userId
};
// Act
var result = userClaimsAccessor.SaveUserClaim(userClaim);
// Assert
Assert.NotNull(result);
}
public void AddingEventsWithImproperExpectedVersionAndNullConflictResolverExpectException()
{
var aggregateId = Guid.NewGuid();
var databaseMock = new DatabaseMock<EventDescriptors>();
var existingEvents = new EventDescriptors { Id = aggregateId };
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 0));
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 1));
databaseMock.Put(existingEvents);
var expectedVersion = existingEvents.Count() - 2;
IConcurrencyConflictResolver conflictResolver = null;
var newEvents = new List<Event>
{
new Event(),
new Event()
};
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
Assert.Throws<EventStoreConcurrencyException>(() =>
eventStore.SaveEvents(
aggregateId,
newEvents,
expectedVersion,
conflictResolver));
}
public void FetchingAggregateRootWhenExistsGetsProperListOfEvents()
{
var aggregateId = Guid.NewGuid();
var databaseMock = new DatabaseMock<EventDescriptors>();
var expected = new EventDescriptors { Id = aggregateId };
expected.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 0));
expected.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 1));
databaseMock.Put(expected);
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
var actual = eventStore.GetEventsForAggregate(aggregateId);
Assert.NotNull(actual);
Assert.Equal(expected.Count(), actual.Count());
Assert.Null(publisherMock.GetLastPublishedObject<Event>());
}
public void FetchingAggregateRootWhenDoesntExistInDatabaseExpectException()
{
var aggregateId = Guid.NewGuid();
var databaseMock = new DatabaseMock<EventDescriptors>();
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
Assert.Throws<AggregateNotFoundException>(() => eventStore.GetEventsForAggregate(aggregateId));
}
public async void AddingImproperlyVersionedEventsConcurrentlyWithConflictResolutionPopulatesDatabase()
{
var aggregateId = Guid.NewGuid();
var databaseMock = new DatabaseMock<EventDescriptors>();
var existingEvents = new EventDescriptors {Id = aggregateId};
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 0));
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event(), 1));
databaseMock.Put(existingEvents);
var initialCount = existingEvents.Count();
var expectedVersion = 0;
IConcurrencyConflictResolver conflictResolver = new ConcurrencyConflictResolver();
conflictResolver.RegisterConflictList(typeof (Event2<EventConstraint1>), new List<Type>());
conflictResolver.RegisterConflictList(typeof (Event2<EventConstraintAnother1>), new List<Type>());
var newEventsSource1 = new List<Event>
{
new Event2<EventConstraint1>()
};
var newEventsSource2 = new List<Event>
{
new Event2<EventConstraintAnother1>()
};
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
var task1 = Task.Run(() =>
eventStore.SaveEvents(
aggregateId,
newEventsSource1,
expectedVersion,
conflictResolver));
var task2 = Task.Run(()=>
eventStore.SaveEvents(
aggregateId,
newEventsSource2,
expectedVersion,
conflictResolver));
await Task.WhenAll(task1, task2).ConfigureAwait(false);
var actual = databaseMock.Get(aggregateId.ToString());
Assert.NotNull(actual);
Assert.Equal(newEventsSource1.Count + newEventsSource2.Count + initialCount, actual.Count());
publisherMock.AssertPublishCount<Event>(newEventsSource1.Count + newEventsSource2.Count);
}
public void AddingImproperlyVersionedEventsWithNoConflictResolutionExpectException()
{
var aggregateId = Guid.NewGuid();
var databaseMock = new DatabaseMock<EventDescriptors>();
var existingEvents = new EventDescriptors { Id = aggregateId };
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event1(), 0));
existingEvents.Add(new EventDescriptor(Guid.NewGuid(), new Event1(), 1));
databaseMock.Put(existingEvents);
var expectedVersion = existingEvents.Count() - 2;
IConcurrencyConflictResolver conflictResolver = new ConcurrencyConflictResolver();
conflictResolver.RegisterConflictList(typeof(Event1), new List<Type> {typeof(Event1)});
var newEvents = new List<Event>
{
new Event1(),
new Event1()
};
var publisherMock = new EventPublisherMock();
var eventStore = new EventStore(publisherMock, databaseMock);
Assert.Throws<EventStoreConcurrencyException>(() =>
eventStore.SaveEvents(
aggregateId,
newEvents,
expectedVersion,
conflictResolver));
}
