public async Task HandleAsync_WhenPollDoesNotExist_ShouldLogInformation()
{
// Arrange
const int pollId = 1;
const string expectedLogMessage = "Cannot retrieve a poll with {@id}";
IPollGateway pollGatewayStub = A.Fake <IPollGateway>();
A.CallTo(() => pollGatewayStub.GetAsync(pollId))
.Returns((Poll)null);
IDeletePollOutputPort OutputPortStub = A.Fake <IDeletePollOutputPort>();
ILoggerService <DeletePollUseCase> loggerServiceMock = A.Fake <ILoggerService <DeletePollUseCase> >();
var useCase = new DeletePollUseCase(loggerServiceMock, pollGatewayStub);
// Act
await useCase.HandleAsync(pollId, OutputPortStub);
// Assert
A.CallTo(
() => loggerServiceMock.LogInformation(
A <string> .That.Contains(expectedLogMessage),
A <int> .That.IsEqualTo(pollId)))
.MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_WhenPollDoesNotExist_ShouldCallNotFound()
{
// Arrange
const int pollId = 1;
const string expectedResultMessage = "Poll not found";
ILoggerService <DeletePollUseCase> loggerServiceStub = A.Fake <ILoggerService <DeletePollUseCase> >();
IPollGateway pollGatewayStub = A.Fake <IPollGateway>();
A.CallTo(() => pollGatewayStub.GetAsync(pollId))
.Returns((Poll)null);
IDeletePollOutputPort OutputPortMock = A.Fake <IDeletePollOutputPort>();
var useCase = new DeletePollUseCase(loggerServiceStub, pollGatewayStub);
// Act
await useCase.HandleAsync(pollId, OutputPortMock);
// Assert
A.CallTo(
() => OutputPortMock.NotFound(
A <string> .That.Contains(expectedResultMessage)))
.MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_WhenPollExists_ShouldCallSuccess()
{
// Arrange
const int pollId = 1;
Poll poll = this.GetFakePoll();
poll.AddOption("test option");
var expectedGetPollOutput = new GetPollOutput(poll.Id, poll.Title, poll.Note, poll.DueDate, poll.SingleOptionLimitation, poll.Options);
IPollGateway pollGatewayStub = A.Fake <IPollGateway>();
A.CallTo(() => pollGatewayStub.GetAsync(pollId))
.Returns(poll);
IGetPollOutputPort getPollOutputPortMock = A.Fake <IGetPollOutputPort>();
var useCase = new GetPollUseCase(null, pollGatewayStub);
// Act
await useCase.HandleAsync(pollId, getPollOutputPortMock);
// Assert
A.CallTo(
() => getPollOutputPortMock.Success(
A <GetPollOutput> .That.Matches(
m => m.Title == poll.Title &&
m.Note == poll.Note &&
m.DueDate == poll.DueDate &&
m.SingleOptionLimitation == poll.SingleOptionLimitation)))
.MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_WithValidPoll_ShouldCallSuccess()
{
// Arrange
IEmailSender emailSenderStub = A.Fake <IEmailSender>();
IPollGateway pollGatewayStub = A.Fake <IPollGateway>();
ICreatePollOutputPort OutputPortMock = A.Fake <ICreatePollOutputPort>();
var useCase = new CreatePollUseCase(null, emailSenderStub, pollGatewayStub);
CreatePollInput input = GetValidCreatePollInput();
// Act
await useCase.HandleAsync(input, OutputPortMock);
// Assert
A.CallTo(() => OutputPortMock.Success(
A <CreatePollOutput> .That.Matches(
p => p.Id == 0)))
.MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_WhenPollExists_ShouldDeleteIt()
{
// Arrange
const int pollId = 1;
Poll poll = this.GetFakePoll();
IPollGateway pollGatewayMock = A.Fake <IPollGateway>();
A.CallTo(() => pollGatewayMock.GetAsync(pollId))
.Returns(poll);
IDeletePollOutputPort OutputPortStub = A.Fake <IDeletePollOutputPort>();
var useCase = new DeletePollUseCase(null, pollGatewayMock);
// Act
await useCase.HandleAsync(pollId, OutputPortStub);
// Assert
A.CallTo(() => pollGatewayMock.DeleteAsync(poll)).MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_WithValidPoll_ShouldSendEmail()
{
// Arrange
IPollGateway pollGatewayStub = A.Fake <IPollGateway>();
ICreatePollOutputPort OutputPortStub = A.Fake <ICreatePollOutputPort>();
IEmailSender emailSenderMock = A.Fake <IEmailSender>();
var useCase = new CreatePollUseCase(null, emailSenderMock, pollGatewayStub);
CreatePollInput input = GetValidCreatePollInput();
// Act
await useCase.HandleAsync(input, OutputPortStub);
// Assert
A.CallTo(() => emailSenderMock.SendAsync(
A <string> .That.Contains("SUBJECT"),
A <string> .That.Contains("PLAIN_TEXT_CONTENT"),
//A<List<string>>.Ignored))
A <List <string> > .That.IsSameSequenceAs(input.ParticipantEmailAddresses)))
.MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_WithValidPoll_ShouldCreateNewPoll()
{
// Arrange
IEmailSender emailSenderStub = A.Fake <IEmailSender>();
ICreatePollOutputPort OutputPortStub = A.Fake <ICreatePollOutputPort>();
IPollGateway pollGatewayMock = A.Fake <IPollGateway>();
var useCase = new CreatePollUseCase(null, emailSenderStub, pollGatewayMock);
CreatePollInput input = GetValidCreatePollInput();
// Act
await useCase.HandleAsync(input, OutputPortStub);
// Assert
A.CallTo(() => pollGatewayMock.CreateAsync(
A <Poll> .That.Matches(
p => p.Title == input.Title &&
p.Note == input.Note &&
p.SingleOptionLimitation == input.SingleOptionLimitation &&
p.DueDate == input.DueDate &&
p.Options.Count == input.Options.Count)))
.MustHaveHappenedOnceExactly();
}
public DeletePollUseCase(ILoggerService <DeletePollUseCase> loggerService, IPollGateway pollGateway)
{
this.loggerService = loggerService;
this.pollGateway = pollGateway;
}
public CreatePollUseCase(ILoggerService <CreatePollUseCase> loggerService, IEmailSender emailSender, IPollGateway pollGateway)
{
this.loggerService = loggerService;
this.emailSender = emailSender;
this.pollGateway = pollGateway;
}
public VoteUseCase(ILoggerService <VoteUseCase> loggerService, IPollGateway pollGateway, IDateTime dateTime)
{
this.loggerService = loggerService;
this.pollGateway = pollGateway;
this.dateTime = dateTime;
}
public GetVotesUseCase(ILoggerService <GetVotesUseCase> loggerService, IPollGateway pollGateway)
{
this.loggerService = loggerService;
this.pollGateway = pollGateway;
}
