public async Task <Result <CommandResult> > Handle(CreateBoardCommand request, CancellationToken cancellationToken) { if (!request.IsValid()) { await PublishValidationErrorsAsync(request); return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed)); } var board = _mapper.Map <Board>(request); var exist = await _boardRepository.ExistByNameAsync(board.Id, board.Name); if (exist) { await _mediator.Publish(new DomainNotification("", ApplicationMessages.Name_Already_Exist)); return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed)); } await _boardRepository.CreateAsync(board); return(Result.Success(new CommandResult(board.Id, ApplicationMessages.Create_Success))); }
public async Task <IActionResult> Create(string name) { var command = new CreateBoardCommand(name); var id = await _memstateClient.Execute(command); return(RedirectToAction("Index")); }
public async void GivenABoardWhenSlugAlreadyExistsThenThrowException() { // Arrange SetupCommandHandler(new List <BoardEntity> { new BoardEntity { Id = 1, Name = "test", Slug = "test" } }); var command = new CreateBoardCommand { Board = new Board { Slug = "test" } }; mockMappingService.Setup(x => x.Map <BoardEntity>(It.IsAny <Board>())).Returns(new BoardEntity { Name = "test", Slug = "test" }); mockSlugService.Setup(x => x.Slugify(It.IsAny <string>())).Returns("test"); // Act & Assert await Assert.ThrowsAsync <CreateBoardCommandSlugExistsException>(() => handler.Handle(command, CancellationToken.None)); }
public void ExecuteAllFourMethodsOnce_WhenValidParametersArePassed() { //Arrange var validBoarName = "Valid"; var validTeamname = "ValidTeam"; var boardMock = new Mock <IBoard>(); var teamMock = new Mock <ITeam>(); var historyEventWriterMock = new Mock <IHistoryEventWriter>(); var componentsFactoryMock = new Mock <IComponentsFactory>(); componentsFactoryMock.Setup(x => x.CreateBoard(validBoarName, teamMock.Object)).Returns(boardMock.Object); var gettersMock = new Mock <IGetters>(); gettersMock.Setup(x => x.GetTeam(validTeamname)).Returns(teamMock.Object); var sut = new CreateBoardCommand(historyEventWriterMock.Object, componentsFactoryMock.Object, gettersMock.Object); var parameters = new List <string>() { validBoarName, validTeamname }; //Act sut.Execute(parameters); //Assert gettersMock.Verify(x => x.GetTeam(validTeamname), Times.Once); componentsFactoryMock.Verify(x => x.CreateBoard(validBoarName, teamMock.Object), Times.Once); teamMock.Verify(x => x.AddBoardToTeam(It.IsAny <IBoard>()), Times.Once); historyEventWriterMock.Verify(x => x.AddHistoryEvent(It.IsAny <string>(), null, boardMock.Object, teamMock.Object, null), Times.Once); }
public void CorrectMessage_WhenValidParametersArePassed() { //Arrange var validBoarName = "Valid"; var validTeamname = "ValidTeam"; var boardMock = new Mock <IBoard>(); var teamMock = new Mock <ITeam>(); // teamMock.Setup(x => x.AddBoardToTeam(It.IsAny<IBoard>())); var historyEventWriterMock = new Mock <IHistoryEventWriter>(); var componentsFactoryMock = new Mock <IComponentsFactory>(); componentsFactoryMock.Setup(x => x.CreateBoard(validBoarName, teamMock.Object)).Returns(boardMock.Object); var gettersMock = new Mock <IGetters>(); gettersMock.Setup(x => x.GetTeam(validTeamname)).Returns(teamMock.Object); var sut = new CreateBoardCommand(historyEventWriterMock.Object, componentsFactoryMock.Object, gettersMock.Object); var parameters = new List <string>() { validBoarName, validTeamname }; var expectedReturn = string.Format(CommandsConsts.ObjectCreated, nameof(Board), validBoarName); //Act var actualReturn = sut.Execute(parameters); //Assert Assert.AreEqual(expectedReturn, actualReturn); }
public void ThrowArgumentException_WhenNullBoardIsReturned() { //Arrange var validBoarName = "Valid"; var validTeamname = "ValidTeam"; var boardMock = new Mock <IBoard>(); var teamMock = new Mock <ITeam>(); var historyEventWriterMock = new Mock <IHistoryEventWriter>(); var componentsFactoryMock = new Mock <IComponentsFactory>(); var gettersMock = new Mock <IGetters>(); gettersMock.Setup(x => x.GetTeam(validTeamname)).Returns(teamMock.Object); var sut = new CreateBoardCommand(historyEventWriterMock.Object, componentsFactoryMock.Object, gettersMock.Object); var parameters = new List <string>() { validBoarName, validTeamname }; //Act, Assert Assert.ThrowsException <ArgumentException>(() => sut.Execute(parameters)); }
public ActionResult <BoardAddOutput> Add(BoardAddInput input) { CreateBoardCommand command = _mapper.Map <BoardAddInput, CreateBoardCommand>(input); command.BoardId = Guid.NewGuid().ToString(); Task <CreateBoardCommandResult> result = _boardService.Add(command); BoardAddOutput returnValue = _mapper.Map <CreateBoardCommandResultItem, BoardAddOutput>(result.Result.ResultObject.Data); foreach (var item in result.Result.ResultObject.GetErrorMessageList()) { returnValue.MessageList.Add(item.UserFriendlyText); } if (result.Result.ResultObject.Success) { returnValue.IsSuccess = true; return(Ok(returnValue)); } else { returnValue.IsSuccess = false; return(BadRequest(returnValue)); } }
public async Task CreateBoardCommandHandler_ValidRequest_Successful() { //mocking var mediator = new Mock <IMediator>(); var automapper = new Mock <IMapper>(); var gameRepository = new Mock <IGameRepository>(); var game = new Game() { Id = new Guid(), Players = new List <Player>() }; var cancellationToken = new CancellationToken(); gameRepository.Setup(r => r.Add(game)).Returns(Task.FromResult(game)); automapper.Setup(a => a.Map <GameDto>(It.IsAny <Game>())).Returns(new GameDto() { Id = game.Id, Players = new List <PlayerDto>() }); gameRepository.Setup(r => r.UnitOfWork.SaveChangesAsync(cancellationToken)).Returns(Task.FromResult(1)); //call var acceptJobCommand = new CreateBoardCommand() { }; var acceptJobCommandHandler = new CreateBoardCommandHandler(gameRepository.Object, automapper.Object); var gameDto = await acceptJobCommandHandler.Handle(acceptJobCommand, cancellationToken); //assertions gameRepository.Verify(mock => mock.UnitOfWork.SaveChangesAsync(cancellationToken), Times.Once()); Assert.AreEqual(game.Id, gameDto.Id); Assert.AreEqual(game.Players.Count, 0); }
public Task <CreateBoardCommandResult> Add(CreateBoardCommand command) { Task <CreateBoardCommandResult> result; result = _mediator.Send(command); return(result); }
public void CreateBoard() { var command = new CreateBoardCommand("A board"); var id = command.Execute(_model); var board = _model.Boards.Values.Single(); Assert.AreEqual(id, board.Id); Assert.AreEqual(command.BoardName, board.Name); }
public void CreateBoard_CreatedSuccesfully() { var factory = new Mock <IFactory>(); var result = new CreateBoardCommand(new List <string>() { "Board15", "Team1" }, database, factory.Object).Execute(); Assert.AreEqual("Created board: 'Board15' in team: 'Team1'", result); }
public bool BoardIsUnique(CreateBoardCommand command) { var board = _userRepository.GetBoard(command.UserId).FirstOrDefault(x => x.Title.ToLower() == command.Title.ToLower()); if (board == null) { return(true); } return(false); }
public void BoardCreation_Execute_Less_Params_ThrowEx() { //Arrange var list = new List <string>(); var fakeBoardProvider = new FakeBoardProvider(); var sut = new CreateBoardCommand(list, fakeBoardProvider); //Act & Assert Assert.ThrowsException <ArgumentException>(() => sut.Execute(), "Parameters count is not valid!"); }
public async Task <ActionResult <GameDto> > CreateBoard([FromBody] CreateBoardCommand createBoardCommand) { var commandResponse = await _mediator.Send(createBoardCommand); if (commandResponse != null) { return(Ok(commandResponse)); } else { return(BadRequest()); } }
public async Task Add_StateUnderTest_ExpectedBehavior() { // Arrange var service = this.CreateService(); CreateBoardCommand command = null; // Act var result = await service.Add( command); // Assert Assert.True(false); this.mockRepository.VerifyAll(); }
public void ThrowExeptionWhenCommandParametersAreLessThanItShoul() { string name = "BoardName"; IBoard board = new Board(name); database.Boards.Add(board); List <string> parameters = new List <string> { }; CreateBoardCommand command = new CreateBoardCommand(parameters); command.Execute(); Assert.IsTrue(database.Boards.Any(x => x.Name == name)); }
public void CreateBoardCommand() { string name = "BoardName"; IBoard board = new Board(name); database.Boards.Add(board); List <string> parameters = new List <string> { name }; CreateBoardCommand command = new CreateBoardCommand(parameters); command.Execute(); Assert.IsTrue(database.Boards.Any(x => x.Name == name)); }
public async void GivenABoardWhenOkThenSaveChangedCalled() { // Arrange SetupCommandHandler(new List <BoardEntity>()); var command = new CreateBoardCommand { Board = new Board() }; mockMappingService.Setup(x => x.Map <BoardEntity>(It.IsAny <Board>())).Returns(new BoardEntity()); // Act await handler.Handle(command, CancellationToken.None); // Assert mockDataContext.Verify(x => x.SaveChangesAsync(), Times.Once); }
public async Task <IActionResult> PostBoard([Bind("Title")] CreateBoardCommand command) { var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value; ModelState.SetModelValue("UserId", new ValueProviderResult(userId)); command.UserId = int.Parse(userId); if (ModelState.IsValid) { var dto = await _mediator.Send(command); return(Ok(dto)); } return(BadRequest(ModelState)); }
public void CreateBoardSuccess() { //Arrange Commons.currentTeam = new Team("FakeTeamName"); var list = new List <string>() { "BoardName" }; var fakeBoardProvider = new FakeBoardProvider(); var sut = new CreateBoardCommand(list, fakeBoardProvider); //Act var result = sut.Execute(); //Assert Assert.IsTrue(result.StartsWith("Created Board")); }
public async void GivenABoardWhenOkThenBoardNameSlugified() { // Arrange SetupCommandHandler(new List <BoardEntity>()); var command = new CreateBoardCommand { Board = new Board() }; mockMappingService.Setup(x => x.Map <BoardEntity>(It.IsAny <Board>())).Returns(new BoardEntity()); // Act await handler.Handle(command, CancellationToken.None); // Assert mockSlugService.Verify(x => x.Slugify(It.IsAny <string>()), Times.Once); }
public void BoardCreation_Execute_BoardWithSameNameAlreadyExists_ThrowEx() { //Arrange Commons.currentTeam = new Team("FakeTeamName"); var list = new List <string>() { "BoardName" }; var fakeBoardProvider = new FakeBoardProvider(); fakeBoardProvider.Add(new Board("BoardName")); var sut = new CreateBoardCommand(list, fakeBoardProvider); Assert.ThrowsException <ArgumentException>(() => sut.Execute(), "Board with name BoardName already exists." + Environment.NewLine + $"You can see all available boards with command listboards."); }
public async void GivenABoardWhenOkThenBoardNameSlugified() { // Arrange SetupCommandHandler(new List<BoardEntity>()); var command = new CreateBoardCommand { Board = new Board() }; mockMappingService.Setup(x => x.Map<BoardEntity>(It.IsAny<Board>())).Returns(new BoardEntity()); // Act await handler.HandleAsync(command); // Assert mockSlugService.Verify(x => x.Slugify(It.IsAny<string>()), Times.Once); }
public async void GivenABoardWhenOkThenSaveChangedCalled() { // Arrange SetupCommandHandler(new List<BoardEntity>()); var command = new CreateBoardCommand { Board = new Board() }; mockMappingService.Setup(x => x.Map<BoardEntity>(It.IsAny<Board>())).Returns(new BoardEntity()); // Act await handler.HandleAsync(command); // Assert mockDataContext.Verify(x => x.SaveChangesAsync(), Times.Once); }
public async void GivenABoardWhenOkThenMappingBackToDto() { // Arrange SetupCommandHandler(new List <BoardEntity>()); var command = new CreateBoardCommand { Board = new Board() }; mockMappingService.Setup(x => x.Map <BoardEntity>(It.IsAny <Board>())).Returns(new BoardEntity()); // Act await handler.HandleAsync(command); // Assert mockMappingService.Verify(x => x.Map <Board>(It.IsAny <BoardEntity>()), Times.Once); }
public async Task Handle_CreatesBoard() { var dbName = $"{nameof(CreateBoardCommandHandlerTests)}_{nameof(Handle_CreatesBoard)}"; using var context = TestApplicationDbContext.Create(dbName); var handler = new CreateBoardCommandHandler(context, _currentUser.Object, new BoardFactory(), new BoardUserFactory()); var request = new CreateBoardCommand { Title = "test-title" }; var cancellationToken = new CancellationToken(); await handler.Handle(request, cancellationToken); var board = await context.Boards.FirstOrDefaultAsync(cancellationToken); Assert.NotNull(board); Assert.Equal(1, board.Id); }
public IActionResult Create([FromBody] CreateBoardCommand command) { if (_context.Boards.Any(b => b.Name == command.Board)) { return(BadRequest()); } var board = new Board { Name = command.Board, Key = command.Key, Created = DateTime.UtcNow }; _context.Boards.Add(board); _context.SaveChanges(); return(Ok()); }
public async Task <BoardCreatedDto> CreateBoard(CreateBoardCommand command) => await _mediator.Send(command);
public WebApiResult <BoardListItem> Post([FromBody] CreateBoardCommand command) { var result = _repository.ExecuteCommand(command); return(AutoMapper.Mapper.Map <CommandResult <Board>, WebApiResult <BoardListItem> >(result)); }
public async Task <IActionResult> Create(CreateBoardCommand command) { return(Ok(await _mediator.Send(command))); }
public async void GivenABoardWhenSlugAlreadyExistsThenThrowException() { // Arrange SetupCommandHandler(new List<BoardEntity> { new BoardEntity { Id = 1, Name = "test", Slug = "test" } }); var command = new CreateBoardCommand { Board = new Board { Slug = "test" } }; mockMappingService.Setup(x => x.Map<BoardEntity>(It.IsAny<Board>())).Returns(new BoardEntity { Name = "test", Slug = "test" }); mockSlugService.Setup(x => x.Slugify(It.IsAny<string>())).Returns("test"); // Act & Assert await Assert.ThrowsAsync<CreateBoardCommandSlugExistsException>(() => handler.HandleAsync(command)); }
public Task CreateBoard(int playerId, CancellationToken cancellationToken) { var command = new CreateBoardCommand(playerId); return(_mediator.Send(command, cancellationToken)); }
static async Task Main(string[] args) { await Task.Delay(20000); var client = new HttpClient(); client.BaseAddress = new Uri("https://localhost:5001/api/board/"); Console.WriteLine("Hello World!"); var body = new CreateBoardCommand { Board = "myapp", Key = "myappkey" }; var json = JsonSerializer.Serialize(body); var payload = new StringContent(json, Encoding.UTF8, "application/json"); var response = await client.PostAsync("create", payload); response.EnsureSuccessStatusCode(); var body2 = new ConnectToBoardCommand { Board = "myapp", Key = "myappkey", Name = "1234" }; var json2 = JsonSerializer.Serialize(body2); var reqMessage = new HttpRequestMessage(HttpMethod.Get, client.BaseAddress + "connect"); reqMessage.Content = new StringContent(json2, Encoding.UTF8, "application/json"); var response2 = await client.SendAsync(reqMessage); response2.EnsureSuccessStatusCode(); var str = await response2.Content.ReadAsStringAsync(); var token = JsonSerializer.Deserialize <TokenModel>(str, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true }).Token; client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token); var connection = new HubConnectionBuilder() .WithUrl("https://localhost:5001/hub", options => { options.AccessTokenProvider = () => Task.FromResult(token); }).Build(); await connection.StartAsync(); connection.On <object>("pushNotifications", (res) => { var json = JsonSerializer.Serialize(res, new JsonSerializerOptions { WriteIndented = true }); Console.WriteLine(json); }); var subcommand = new SubscribeTopicCommand { Topic = "pushNotifications", Route = "myapp.push.user.1234" }; await connection.InvokeAsync("subscribe", subcommand); var rand = new Random(); while (true) { await Task.Delay(rand.Next(1000, 10000)); if (new Random().Next(1, 10) % 2 == 0) { var pubcmd = new PublishMessageCommand { Route = "myapp.push.user.1234", Payload = new { Test = "test string", NestObj = subcommand } }; await connection.InvokeAsync("publish", pubcmd); } else { var pubcmd = new PublishMessageCommand { Route = "myapp.push.user.1234", Payload = "striiiing." }; await connection.InvokeAsync("publish", pubcmd); } } }