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)); }