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 Refresh_token_succeeds_for_existing_user()
{
// Arrange
var user = new User()
{
Id = "userId",
Email = "email",
Username = "******",
PasswordHash = "password"
};
var signInManager = new SignInManagerMock();
signInManager.SetupForUser(user);
var tokenService = new TokenServiceMock();
tokenService.SetupTokenBuild(u => u.Id + "_token");
var logger = new ConsoleLoggerMock <Services.AuthenticationService>();
var userManager = new UserManagerMock();
userManager.SetupExistingUser(user);
var eventBus = new EventPublisherMock();
var confirmationSender = new EmailConfirmationSenderMock();
var service = new Services.AuthenticationService(
userManager.Object, signInManager.Object, tokenService.Object, eventBus.Object, logger.Object,
confirmationSender.Object);
// Act
OperationResult <JwtToken> result = service.RefreshToken("userId").Result;
// Assert
Assert.True(result.IsValid);
Assert.AreEqual("userId_token", result.Result.Token);
}
public async Task should_send_update_event_for_each_hearing_person_is_a_participant_in()
{
var personId = Guid.NewGuid();
var payload = new UpdatePersonDetailsRequest()
{
Username = "******",
FirstName = "New",
LastName = "Me"
};
var hearings = CreateListOfVideoHearings(personId, payload.FirstName, payload.LastName, payload.Username);
QueryHandlerMock
.Setup(x =>
x.Handle <GetHearingsByUsernameQuery, List <VideoHearing> >(It.IsAny <GetHearingsByUsernameQuery>()))
.ReturnsAsync(hearings);
var result = await Controller.UpdatePersonDetails(personId, payload);
result.Result.Should().BeOfType <AcceptedResult>();
EventPublisherMock.Verify(x => x.PublishAsync(It.IsAny <ParticipantUpdatedIntegrationEvent>()), Times.Once);
}
public void Register_creates_user_publishes_event_and_sends_email()
{
// Arrange
ISignInManager signInManager = Mock.Of <ISignInManager>();
ITokenService tokenService = Mock.Of <ITokenService>();
var logger = new ConsoleLoggerMock <Services.AuthenticationService>();
var userManager = new UserManagerMock();
var eventBus = new EventPublisherMock();
var confirmationSender = new EmailConfirmationSenderMock();
var service = new Services.AuthenticationService(
userManager.Object, signInManager, tokenService, eventBus.Object, logger.Object, confirmationSender.Object);
// Act
OperationResult result = service.RegisterUser("username", "email", "password").Result;
// Assert
Assert.True(result.IsValid);
userManager.VerifyUserCreated("username", "email", "password");
eventBus.VerifyEventPublished <UserRegisteredEvent, UserInfo>(u => u.Username == "username" && u.Email == "email");
confirmationSender.VerifyEmailSent("username", "email");
}
public SubsidiariesLinkageSteps()
{
_eventPublisherMock = new EventPublisherMock <IDomainEvent>();
}
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 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));
}
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));
}
