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