Exemplo n.º 1
0
        public async Task HandleAsync_Should_Update_RoomForRentAnnouncement()
        {
            var cityDistrictToRemove    = Guid.NewGuid();
            var roomTypeToRemove        = RoomTypeEnumeration.MultiPerson;
            var roomForRentAnnouncement = RoomForRentAnnouncement.Builder()
                                          .SetId(Guid.NewGuid())
                                          .SetTitle("Title")
                                          .SetSourceUrl("http://source")
                                          .SetCityId(Guid.NewGuid())
                                          .SetCreated(DateTimeOffset.UtcNow)
                                          .SetDescription("Description")
                                          .SetPrice(1000)
                                          .SetCityDistricts(new List <Guid> {
                cityDistrictToRemove
            })
                                          .SetRoomTypes(new List <RoomTypeEnumeration> {
                roomTypeToRemove
            })
                                          .Build();
            var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement);

            var          cityVerificationResult          = VerificationResult.Ok();
            var          cityDistrictsVerificationResult = VerificationResult.Ok();
            const string newTitle          = "NewTitle";
            var          cityDistrictToAdd = Guid.NewGuid();
            var          roomTypeToAdd     = RoomTypeEnumeration.Single;
            var          updateRoomForRentAnnouncementCommand = new UpdateRoomForRentAnnouncementCommand(
                roomForRentAnnouncement.Id, newTitle, roomForRentAnnouncement.SourceUrl,
                roomForRentAnnouncement.CityId, roomForRentAnnouncement.Description, roomForRentAnnouncement.Price,
                new List <RoomTypeEnumeration> {
                roomTypeToAdd
            }, new List <Guid> {
                cityDistrictToAdd
            });

            _roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
            .ReturnsAsync(getRoomForRentAnnouncementResult);
            _cityVerificationServiceMock.Setup(x => x.VerifyCityExistsAsync(It.IsAny <Guid>()))
            .ReturnsAsync(cityVerificationResult);
            _cityDistrictVerificationServiceMock
            .Setup(x => x.VerifyCityDistrictsExistAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >()))
            .ReturnsAsync(cityDistrictsVerificationResult);
            _roomForRentAnnouncementRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <RoomForRentAnnouncement>()))
            .Returns(Task.CompletedTask);

            Func <Task> result = async() => await _commandHandler.HandleAsync(updateRoomForRentAnnouncementCommand);

            await result.Should().NotThrowAsync <Exception>();

            roomForRentAnnouncement.Title.Should().Be(newTitle);
            roomForRentAnnouncement.CityDistricts.Should().NotContain(cityDistrictToRemove);
            roomForRentAnnouncement.CityDistricts.Should().Contain(cityDistrictToAdd);
            roomForRentAnnouncement.RoomTypes.Should().NotContain(roomTypeToRemove);
            roomForRentAnnouncement.RoomTypes.Should().Contain(roomTypeToAdd);
        }
Exemplo n.º 2
0
        public async Task HandleAsync_Should_Throw_ValidationException_When_Any_Of_CityDistricts_Is_Not_Found()
        {
            var roomForRentAnnouncement = RoomForRentAnnouncement.Builder()
                                          .SetId(Guid.NewGuid())
                                          .SetTitle("Title")
                                          .SetSourceUrl("http://source")
                                          .SetCityId(Guid.NewGuid())
                                          .SetCreated(DateTimeOffset.UtcNow)
                                          .SetDescription("Description")
                                          .SetPrice(1000)
                                          .SetCityDistricts(new List <Guid> {
                Guid.NewGuid()
            })
                                          .Build();
            var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement);

            var cityVerificationResult = VerificationResult.Ok();
            var errors = new Collection <IError>
            {
                new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound)
            };
            var cityDistrictsVerificationResult      = VerificationResult.Fail(errors);
            var updateRoomForRentAnnouncementCommand = new UpdateRoomForRentAnnouncementCommand(
                roomForRentAnnouncement.Id, roomForRentAnnouncement.Title, roomForRentAnnouncement.SourceUrl,
                roomForRentAnnouncement.CityId, roomForRentAnnouncement.Description, roomForRentAnnouncement.Price,
                roomForRentAnnouncement.RoomTypes, roomForRentAnnouncement.CityDistricts);

            _roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
            .ReturnsAsync(getRoomForRentAnnouncementResult);
            _cityVerificationServiceMock.Setup(x => x.VerifyCityExistsAsync(It.IsAny <Guid>()))
            .ReturnsAsync(cityVerificationResult);
            _cityDistrictVerificationServiceMock
            .Setup(x => x.VerifyCityDistrictsExistAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >()))
            .ReturnsAsync(cityDistrictsVerificationResult);

            Func <Task> result = async() => await _commandHandler.HandleAsync(updateRoomForRentAnnouncementCommand);

            var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();

            exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
        }
Exemplo n.º 3
0
        public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_RoomForRentAnnouncement_Is_Not_Found()
        {
            var errors = new Collection <IError>
            {
                new Error(RoomForRentAnnouncementErrorCodeEnumeration.NotFound, RoomForRentAnnouncementErrorMessage.NotFound)
            };
            var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Fail(errors);

            var updateRoomForRentAnnouncementCommand = new UpdateRoomForRentAnnouncementCommand(Guid.NewGuid(), "Title",
                                                                                                "http://sourceUrl", Guid.NewGuid(), "Description", null,
                                                                                                new List <RoomTypeEnumeration>(), new List <Guid>());

            _roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
            .ReturnsAsync(getRoomForRentAnnouncementResult);

            Func <Task> result = async() => await _commandHandler.HandleAsync(updateRoomForRentAnnouncementCommand);

            var exceptionResult = await result.Should().ThrowExactlyAsync <ResourceNotFoundException>();

            exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
        }
Exemplo n.º 4
0
        public async Task UpdateRoomForRentAnnouncementAsync_Should_Return_OkObjectResult_With_RoomForRentAnnouncementResponse()
        {
            var roomForRentAnnouncementId            = Guid.NewGuid();
            var updateRoomForRentAnnouncementRequest = new UpdateRoomForRentAnnouncementRequest
            {
                Id          = roomForRentAnnouncementId,
                Title       = "NewTitle",
                SourceUrl   = "http://sourceUrl",
                CityId      = Guid.NewGuid(),
                Description = "Description",
                Price       = 100,
                RoomTypes   = new List <RoomType> {
                    RoomType.Single
                },
                CityDistricts = new List <Guid> {
                    Guid.NewGuid()
                }
            };
            var updateRoomForRentAnnouncementCommand = new UpdateRoomForRentAnnouncementCommand(
                roomForRentAnnouncementId,
                updateRoomForRentAnnouncementRequest.Title,
                updateRoomForRentAnnouncementRequest.SourceUrl,
                updateRoomForRentAnnouncementRequest.CityId,
                updateRoomForRentAnnouncementRequest.Description,
                updateRoomForRentAnnouncementRequest.Price,
                updateRoomForRentAnnouncementRequest.RoomTypes.Select(RoomForRentAnnouncementProfile.ConvertToRoomTypeEnumeration),
                updateRoomForRentAnnouncementRequest.CityDistricts);
            var roomForRentAnnouncementOutputQuery = new RoomForRentAnnouncementOutputQuery(
                updateRoomForRentAnnouncementCommand.RoomForRentAnnouncementId,
                updateRoomForRentAnnouncementCommand.Title,
                updateRoomForRentAnnouncementCommand.SourceUrl,
                updateRoomForRentAnnouncementCommand.CityId,
                DateTimeOffset.UtcNow,
                updateRoomForRentAnnouncementCommand.Description,
                updateRoomForRentAnnouncementCommand.Price,
                updateRoomForRentAnnouncementCommand.RoomTypes,
                updateRoomForRentAnnouncementCommand.CityDistricts);
            var roomForRentAnnouncementResponse = new RoomForRentAnnouncementResponse(
                roomForRentAnnouncementOutputQuery.Id,
                roomForRentAnnouncementOutputQuery.Title,
                roomForRentAnnouncementOutputQuery.SourceUrl,
                roomForRentAnnouncementOutputQuery.CityId,
                roomForRentAnnouncementOutputQuery.Created,
                roomForRentAnnouncementOutputQuery.Description,
                roomForRentAnnouncementOutputQuery.Price,
                roomForRentAnnouncementOutputQuery.RoomTypes.Select(RoomForRentAnnouncementProfile.ConvertToRoomTypeEnum),
                roomForRentAnnouncementOutputQuery.CityDistricts);

            _mapperMock
            .Setup(x => x.Map <UpdateRoomForRentAnnouncementRequest, UpdateRoomForRentAnnouncementCommand>(It.IsAny <UpdateRoomForRentAnnouncementRequest>()))
            .Returns(updateRoomForRentAnnouncementCommand);
            _communicationBusMock
            .Setup(x => x.SendCommandAsync(It.IsAny <UpdateRoomForRentAnnouncementCommand>(), It.IsAny <CancellationToken>()))
            .Returns(Task.CompletedTask);
            _getRoomForRentAnnouncementQueryHandlerMock
            .Setup(x => x.HandleAsync(It.IsAny <GetRoomForRentAnnouncementInputQuery>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(roomForRentAnnouncementOutputQuery);
            _mapperMock
            .Setup(x => x.Map <RoomForRentAnnouncementOutputQuery, RoomForRentAnnouncementResponse>(It.IsAny <RoomForRentAnnouncementOutputQuery>()))
            .Returns(roomForRentAnnouncementResponse);

            var result = await _controller.UpdateRoomForRentAnnouncementAsync(roomForRentAnnouncementId, updateRoomForRentAnnouncementRequest);

            var okObjectResult = result.As <OkObjectResult>();

            okObjectResult.Value.Should().BeEquivalentTo(roomForRentAnnouncementResponse);
        }