public async Task <ActionResult <Object> > Post([FromBody] CreateFriendCommand Friend)
        {
            var createResult = await _createFriendCommandHandler.HandleAsync(Friend);

            var result = new List <Object>();

            result.Add(new { Success = createResult });


            return(result);
        }
        public void ShouldValidateWhenCreateCommandIsValid()
        {
            var command = new CreateFriendCommand()
            {
                Email     = "*****@*****.**",
                FirstName = "Raphael",
                LastName  = "Teste 001",
                Phone     = "4499845466",
                UserId    = Guid.NewGuid()
            };

            Assert.True(command.Valid());
        }
Beispiel #3
0
        public async Task ShouldCreateFriend()
        {
            var cmd = new CreateFriendCommand("Unit Test", "test", "*****@*****.**");

            await SendAsync(cmd);

            var entity = await FindAsync <IFriendRepository, Friend>(cmd.Id);

            entity.Should().NotBeNull();
            entity.Id.Should().Be(cmd.Id);
            entity.Name.Should().Be("Unit Test");
            entity.NickName.Should().Be("test");
            entity.Email.Should().Be("*****@*****.**");
        }
        public void ShouldRegisterFriendWhenCommandIsValid()
        {
            var command = new CreateFriendCommand()
            {
                FirstName = "Armando",
                LastName  = "Fagundes",
                Email     = "*****@*****.**",
                Phone     = "11888774545",
                UserId    = Guid.NewGuid()
            };

            var result = _handler.Handle(command);

            Assert.NotEqual(null, result);
            Assert.True(_handler.Valid);
        }
Beispiel #5
0
        public async Task ShouldCreateANewFriend()
        {
            GenerateMock();

            _friendRepositoryMock.Setup(x => x.Add(It.IsAny <Friend>()));

            _friendRepositoryMock.Setup(x => x.UnitOfWork.SaveAsync(It.IsAny <CancellationToken>()));

            var handler = GetHandler();

            var command = new CreateFriendCommand("name", "nickname", "*****@*****.**");

            await handler.Handle(command, default);

            _friendRepositoryMock.Verify(x => x.Add(It.IsAny <Friend>()));

            _friendRepositoryMock.Verify(x => x.UnitOfWork.SaveAsync(It.IsAny <CancellationToken>()));
        }
 public async Task <ActionResult <Response> > Post([FromBody] CreateFriendCommand command)
 {
     return(await CreateResponse(command, HttpStatusCode.Created));
 }
Beispiel #7
0
        public async Task <ICommandResult> Post([FromBody] CreateFriendCommand command)
        {
            var result = _handler.Handle(command);

            return(await Response(result));
        }
        public async Task <IActionResult> Post([FromBody] CreateFriendCommand command)
        {
            await _mediator.Send(command);

            return(Created(nameof(Get), command.Id));
        }
Beispiel #9
0
 public async Task <IActionResult> CreateFriend([FromForm] CreateFriendCommand command)
 {
     return(Ok(await Mediator.Send(command)));
 }