public static CreateManyTransactionsCommand CreateFrom(CreateStatementCommand createStatementCommand)
{
return(new()
{
Transactions = createStatementCommand.Transactions
});
}
public async void ShouldReturnVoidedStatement()
{
// Arrange
var mediatorMock = new Mock <IMediator>();
var authorityMock = new Mock <IClientContext>();
var createStatementHandler = new CreateStatementCommandHandler(_context, mediatorMock.Object, _mapper, authorityMock.Object);
var voidStatementQueryHandler = new VoidedStatemetQueryHandler(_context, _mapper);
var voidedStatementId = Guid.Parse("637E9E80-4B8D-4640-AC13-615C3E413568");
var statement = new Statement("{\"actor\":{\"objectType\":\"Agent\",\"name\":\"xAPI mbox\",\"mbox\":\"mailto:[email protected]\"},\"verb\":{\"id\":\"http://adlnet.gov/expapi/verbs/attended\",\"display\":{\"en-GB\":\"attended\",\"en-US\":\"attended\"}},\"object\":{\"objectType\":\"Activity\",\"id\":\"http://www.example.com/meetings/occurances/34534\"}}");
statement.Id = voidedStatementId;
var voidingStatement = new Statement()
{
Actor = new Agent()
{
Mbox = new Mbox("mailto:[email protected]")
},
Verb = new Verb()
{
Id = new Iri("http://adlnet.gov/expapi/verbs/voided")
},
Object = new StatementRef()
{
Id = voidedStatementId
},
};
voidingStatement.Object.As <StatementRef>().Id = statement.Id.Value;
// Act
Guid statementId = await createStatementHandler.Handle(
CreateStatementCommand.Create(statement),
CancellationToken.None
);
// Create voiding statement
Guid voidingStatementId = await createStatementHandler.Handle(
CreateStatementCommand.Create(voidingStatement),
CancellationToken.None
);
// Query voided statement
StatementEntity voidedStatement = await voidStatementQueryHandler.Handle(
VoidedStatemetQuery.Create(voidedStatementId),
CancellationToken.None
);
// Assert
mediatorMock.Verify(m => m.Publish(It.IsAny <StatementCreated>(), It.IsAny <CancellationToken>()), Times.AtLeast(2));
voidedStatement.ShouldNotBe(null);
voidedStatement.VoidingStatementId.ShouldBe(voidingStatementId);
}
private CreateStatementCommand GetValidCommand()
{
var command = new CreateStatementCommand();
command.Date = DateTime.UtcNow;
command.Notes.RandomString(500);
command.Amount = 123;
command.InvoiceId = Guid.NewGuid();
return(command);
}
public void IsValid_InvoiceId_Empty()
{
// Arrange
_command = GetValidCommand();
_command.InvoiceId = Guid.Empty;
// Act
var result = _command.IsValid();
// Assert
Assert.False(result);
}
public void IsValid_Amount_MinValue()
{
// Arrange
_command = GetValidCommand();
_command.Amount = -1;
// Act
var result = _command.IsValid();
// Assert
Assert.False(result);
}
public void IsValid_Notes_Null()
{
// Arrange
_command = GetValidCommand();
_command.Notes = null;
// Act
var result = _command.IsValid();
// Assert
Assert.True(result);
}
public void IsValid_Notes_MaxValue()
{
// Arrange
_command = GetValidCommand();
_command.Notes = _command.Notes.RandomString(501);
// Act
var result = _command.IsValid();
// Assert
Assert.False(result);
}
public void IsValid_Date_MinValue()
{
// Arrange
_command = GetValidCommand();
_command.Date = DateTime.MinValue;
// Act
var result = _command.IsValid();
// Assert
Assert.False(result);
}
public async Task <ICollection <Guid> > Handle(CreateStatementsCommand request, CancellationToken cancellationToken)
{
var tasks = new List <Task <Guid> >();
foreach (var statement in request.Statements)
{
tasks.Add(_mediator.Send(CreateStatementCommand.Create(statement), cancellationToken));
}
var ids = await Task.WhenAll(tasks);
await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(new StatementsSaved());
return(ids);
}
public async void ShouldRaiseStatementCreatingNotification()
{
// Arrange
var mediatorMock = new Mock <IMediator>();
var authorityMock = new Mock <IClientContext>();
var sut = new CreateStatementCommandHandler(_context, mediatorMock.Object, _mapper, authorityMock.Object);
Statement statement = GetStatement(Guid.NewGuid());
// Act
var result = await sut.Handle(CreateStatementCommand.Create(statement), CancellationToken.None);
// Assert
mediatorMock.Verify(m => m.Publish(
It.IsAny <StatementCreating>(),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async void Handle_GivenValidRequest_ShouldRaiseStatementCreatedNotification()
{
// Arrange
var mediatorMock = new Mock <IMediator>();
var authorityMock = new Mock <IClientContext>();
var createStatement = new CreateStatementCommandHandler(_context, mediatorMock.Object, _mapper, authorityMock.Object);
Guid newStatementId = Guid.NewGuid();
Statement statement = GetStatement(newStatementId);
// Act
var result = await createStatement.Handle(CreateStatementCommand.Create(statement), CancellationToken.None);
// Assert
mediatorMock.Verify(m => m.Publish(
It.Is <StatementCreated>(cc => cc.Created.StatementId == newStatementId),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task Handle_CreateStatementCommand_Return_True()
{
//arrange
Guid INVOICE_ID = Guid.NewGuid();
var command = new CreateStatementCommand()
{
Amount = 123.45,
Date = DateTime.UtcNow,
Notes = "NOTES",
InvoiceId = INVOICE_ID
};
_mocker.GetMock<IInvoiceRepository>()
.Setup(m => m.GetById(It.Is<Guid>(id => id == INVOICE_ID)))
.Returns(value: new Invoice())
.Verifiable("IInvoiceRepository.GetById should have been called");
_mocker.GetMock<IStatementRepository>()
.Setup(m => m.Create(It.IsAny<Statement>()))
.Verifiable("IStatementRepository.Create should have been called");
_mocker.GetMock<IStatementRepository>()
.Setup(m => m.GetByDate(It.IsAny<Guid>(), It.IsAny<DateTime>()))
.Returns(value: null)
.Verifiable("IStatementRepository.GetByName should have been called");
_mocker.GetMock<IMediatorHandler>()
.Setup(m => m.RaiseEvent(It.IsAny<StatementCreatedEvent>()))
.Verifiable("An event StatementCreatedEvent should have been raised");
//act
var result = await _statementCommandHandler.Handle(command, CancellationToken.None);
//assert
_mocker.GetMock<IStatementRepository>().Verify();
_mocker.GetMock<IInvoiceRepository>().Verify();
_mocker.GetMock<IMediatorHandler>().Verify();
Assert.True(result);
}
public CreateStatementCommandTests()
{
_command = new CreateStatementCommand();
}
public async Task <IActionResult> Create([FromBody] CreateStatementCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
