public void Given_PlayerAlreadyExists_When_CreatePlayer_Then_ExceptionIsThrown()
{
// Arrange
var teams = new List <Domain.Player.Player>
{
new Domain.Player.Player
{
FirstName = "John",
LastName = "Doe"
}
};
var contextMock = MockDbContext(teams.AsQueryable());
var handler = new CreatePlayerCommandHandler(contextMock.Object, Mapper.CreateMapper());
//Act
var command = new CreatePlayerCommand
{
FirstName = "John",
LastName = "Doe"
};
Func <Task> func = async() => await handler.Handle(command, CancellationToken.None);
//Assert
func.Should().Throw <PlayerAlreadyExistsException>();
}
private static async Task <Guid> CreatePlayer()
{
using var conn = EventStoreConnection.Create(new Uri("tcp://*****:*****@localhost:1113"));
await conn.ConnectAsync();
var service = new ServiceCollection()
.AddMediatR(Assembly.GetAssembly(typeof(Program)))
.BuildServiceProvider();
var bus = new MediatR.Mediator(type => service.GetService(type));
var dispatcher = new EventDispatcher(conn, bus);
var repo = new AggregateRepository(conn);
var handler = new CreatePlayerCommandHandler(repo, dispatcher);
var id = Guid.NewGuid();
var streamId = $@"Player-{id}";
var cmd = new CreatePlayerCommand(streamId, id);
await handler.Handle(cmd);
var player = await repo.Fetch <PlayerAggregate>(streamId);
await dispatcher.RaiseEvent(player,
new NicknameAddedEvent { Nickname = "Chr", StreamId = player.StreamId },
new AddressAddedEvent { HomeAddress = new Address {
HomeAddress = "Sandøgade 4, 8200 Aarhus N"
}, StreamId = player.StreamId });
return(player.Id);
}
[HttpPost] // para criar é necessário receber um command e um handler
public GenericCommandResult Create(
[FromBody] CreatePlayerCommand command,
[FromServices] PlayerHandler handler)
{
command.Name = "bidaij";
return((GenericCommandResult)handler.Handle(command));
}
public void Dado_um_comando_válido()
{
var command = new CreatePlayerCommand("Ronaldo", 10, 25);
command.Validate();
Assert.AreEqual(command.Valid, true);
}
public void Dado_um_comando_inválido()
{
var command = new CreatePlayerCommand("", 1220, 25007);
command.Validate();
Assert.AreEqual(command.Valid, false);
}
public int CreatePlayer(CreatePlayerCommand cmd)
{
var player = cmd.ToPlayer();
_context.Add(player);
_context.SaveChanges();
return(player.Id);
}
public async Task <PlayerModel> CreatePlayer([FromBody] CreatePlayerCommand command)
{
if (command == null)
{
throw new ArgumentException(nameof(command));
}
return(await playerService.CreatePlayer(command));
}
public void ExecuteShouldThrowArgumentNullExceptionWhenParametersIsNull()
{
var factoryStub = new Mock <IBattleShipFactory>().Object;
var engineStub = new Mock <IEngine>().Object;
var cmd = new CreatePlayerCommand(factoryStub, engineStub);
Assert.ThrowsException <ArgumentNullException>(() => cmd.Execute(null));
}
public async Task <PlayerModel> CreatePlayer(CreatePlayerCommand command)
{
var rating = await ratingApiClient.GetDefaultPlayerRating();
CreatePlayerRequest createPlayerRequest = new CreatePlayerRequest(command.Name, rating.Rating, rating.Deviation, rating.Volatility);
Player createdPlayer = await playersApiClient.CreatePlayer(createPlayerRequest);
return(PlayerMapper.Map(createdPlayer));
}
private void CreatePlayerMessageHandler(CreatePlayerCommand command)
{
DisplayHelper.ShowInfo("Received message to create", command.PlayerName);
Persist(new PlayerCreatedEvent(command.PlayerName, DefaultHealth), @event =>
{
DisplayHelper.ShowInfo("Saving create player command for", @event.PlayerName);
Context.ActorOf(Props.Create(() => new PlayerActor(@event.PlayerName, @event.Health)), @event.PlayerName);
});
}
public async Task <ActionResult> Post([FromBody] CreatePlayerCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
PlayerDTO player = await _mediator.Send(command);
return(CreatedAtRoute("Get", new { id = player.PlayerId }, player));
}
public void When_FirstNameIsEmpty_Then_ValidationError()
{
var command = new CreatePlayerCommand
{
FirstName = ""
};
var validator = new CreatePlayerCommandValidator();
validator.ShouldHaveValidationErrorFor(x => x.FirstName, command);
}
public void ExecuteShouldThrowArgumentExceptionWhenParametersIsEmpty()
{
var factoryStub = new Mock <IBattleShipFactory>().Object;
var engineStub = new Mock <IEngine>().Object;
var parameters = new List <string>();
var cmd = new CreatePlayerCommand(factoryStub, engineStub);
Assert.ThrowsException <ArgumentException>(() => cmd.Execute(parameters));
}
public async Task <IActionResult> Post(CreatePlayerCommand request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _mediator.Send(request);
return(Ok(result));
}
public void When_FirstAndLastNameAreSet_Then_NoValidationError()
{
var command = new CreatePlayerCommand
{
FirstName = "John",
LastName = "Doe"
};
var validator = new CreatePlayerCommandValidator();
validator.ShouldNotHaveValidationErrorFor(x => x.FirstName, command);
validator.ShouldNotHaveValidationErrorFor(x => x.LastName, command);
}
public ActionResult Create(Player model)
{
try
{
var command = new CreatePlayerCommand(model.FirstName, model.LastName);
_commandDispatcher.Execute(command);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> CreatePlayer([FromBody] CreatePlayerCommand command)
{
try
{
var player = await mediator.Send(command);
return(Created($"/player/{player.FullName}", new { player }));
}
catch (LeagueManagerException ex)
{
return(BadRequest(ex.Message));
}
catch
{
return(BadRequest("Something went wrong!"));
}
}
public CreatePlayer(string playerArchetype,
EntityConfig nodeConfig,
string name,
string colourHex = "ffffff"
)
{
Action = (ecs, config) =>
{
var createPlayerCommand = new CreatePlayerCommand()
{
PlayerConfig = new PlayerConfig()
{
Archetype = playerArchetype,
Colour = colourHex,
StartingLocation = nodeConfig.Id,
Name = name,
Glyph = "star"
}
};
ecs.EnqueueCommand(createPlayerCommand);
};
}
public async Task <IActionResult> Create([FromBody] CreatePlayerCommand command)
{
var id = await Mediator.Send(command);
return(Ok(id));
}
public IHttpActionResult Post([FromBody] CreatePlayerCommand command)
{
return(this.createCommandHandler.CreatePlayer(command)
.OnBoth(result => result.IsSuccess ? this.Ok(result.Value) : (IHttpActionResult)this.InternalServerError(new Exception(result.Error))));
}
public async Task <IActionResult> Post(CreatePlayerCommand command)
{
return(Ok(await bus.Send(command)));
}
public async Task <IActionResult> Post([FromBody] CreatePlayerCommand command)
{
var createdPlayerId = await _mediator.Send(command);
return(CreatedAtAction("Get", new { Id = createdPlayerId }, createdPlayerId));
}
public async Task <IActionResult> CreatePlayer([FromBody] CreatePlayerCommand command)
{
await _playerService.CreatePlayer(command);
return(Ok());
}
public async Task <ActionResult <int> > Create(CreatePlayerCommand command)
{
return(await Mediator.Send(command));
}
