public async Task GivenAMessageWhenEditMessageIsCalledThenTheMessageIsEdited()
        {
            // Arrange
            var messageToAdd = MessageAddEditViewModelBuilder.ABuilder().Build();
            var addedMessage = await this.AddMessage(messageToAdd).ConfigureAwait(false);

            var uri           = new Uri($"{this.uri}/{addedMessage.Id}");
            var messageToEdit = MessageAddEditViewModelBuilder
                                .ABuilder()
                                .WithContent("Edited")
                                .Build();

            using var stringContent = GetStringContent(messageToEdit);

            // Act
            var response = await this.client.PutAsync(uri, stringContent).ConfigureAwait(false);

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);
            var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

            var message     = Deserialize <MessageViewModel>(content);
            var allMessages = await this.GetMessages().ConfigureAwait(false);

            allMessages.Should().BeEquivalentTo(new List <MessageViewModel> {
                message
            });
        }
Пример #2
0
        public void GivenAMessageWhenEditMessageIsCalledThenTheMessageIsEdited()
        {
            // Arrange.
            var message = MessageBuilder.ABuilder().Build();
            var messageAddEditViewModel = MessageAddEditViewModelBuilder.ABuilder().Build();
            var messageViewModel        = MessageViewModelBuilder.ABuilder().Build();

            this.messageComponentTestDouble
            .Setup(component => component.GetMessage(It.IsAny <Guid>()))
            .Returns(message);
            this.mapperTestDouble
            .Setup(mapper => mapper.Map <MessageViewModel>(It.IsAny <Message>()))
            .Returns(messageViewModel);

            // Act.
            var result = this.systemUnderTest.EditMessage(message.ExternalId, messageAddEditViewModel);

            // Assert.
            result.Should().BeOfType <OkObjectResult>();
            var okObjectResult = (OkObjectResult)result;

            okObjectResult.Value.Should().BeEquivalentTo(messageViewModel);
            this.messageComponentTestDouble
            .Verify(component => component.GetMessage(message.ExternalId), Times.Once);
            this.mapperTestDouble
            .Verify(mapper => mapper.Map(messageAddEditViewModel, message), Times.Once);
            this.messageComponentTestDouble
            .Verify(component => component.EditMessage(message), Times.Once);
            this.mapperTestDouble
            .Verify(mapper => mapper.Map <MessageViewModel>(message), Times.Once);
        }
Пример #3
0
        public void GivenAMessageWhenAddMessageIsCalledThenTheMessageIsAdded()
        {
            // Arrange.
            var message = MessageBuilder.ABuilder().Build();
            var messageAddEditViewModel = MessageAddEditViewModelBuilder.ABuilder().Build();
            var messageViewModel        = MessageViewModelBuilder.ABuilder().Build();

            this.mapperTestDouble
            .Setup(mapper => mapper.Map <Message>(It.IsAny <MessageAddEditViewModel>()))
            .Returns(message);
            this.mapperTestDouble
            .Setup(mapper => mapper.Map <MessageViewModel>(It.IsAny <Message>()))
            .Returns(messageViewModel);

            // Act.
            var result = this.systemUnderTest.AddMessage(messageAddEditViewModel);

            // Assert.
            result.Should().BeOfType <CreatedResult>();
            var createdresult = (CreatedResult)result;

            createdresult.Value.Should().BeEquivalentTo(messageViewModel);
            createdresult.Location.Should().Be($"/api/v1/Messages/{messageViewModel.Id}");
            this.mapperTestDouble
            .Verify(mapper => mapper.Map <Message>(messageAddEditViewModel), Times.Once);
            this.messageComponentTestDouble
            .Verify(component => component.AddMessage(message), Times.Once);
            this.mapperTestDouble
            .Verify(mapper => mapper.Map <MessageViewModel>(message), Times.Once);
        }
        public void GivenAValidMessageWhenValidateIsCalledThenTheMessageIsFoundToBeValid()
        {
            // Arrange.
            var messageAddEditViewModel = MessageAddEditViewModelBuilder.ABuilder().Build();

            // Act.
            var result = this.systemUnderTest.Validate(messageAddEditViewModel);

            // Assert.
            result.IsValid.Should().BeTrue();
            result.Errors.Should().BeEmpty();
        }
Пример #5
0
        public void GivenANonExistentIdWhenEditMessageIsCalledThenTheMessageIsNotFound()
        {
            // Arrange.
            var id = Guid.NewGuid();
            var messageAddEditViewModel = MessageAddEditViewModelBuilder.ABuilder().Build();

            // Act.
            var result = this.systemUnderTest.EditMessage(id, messageAddEditViewModel);

            // Assert.
            result.Should().BeOfType <NotFoundResult>();
            this.messageComponentTestDouble
            .Verify(component => component.GetMessage(id), Times.Once);
        }
        public void GivenAMessageWithContentTooLongWhenValidateIsCalledThenTheMessageIsFoundToBeInvalid()
        {
            // Arrange.
            var messageAddEditViewModel = MessageAddEditViewModelBuilder
                                          .ABuilder()
                                          .WithContent(new string('x', 257))
                                          .Build();

            // Act.
            var result = this.systemUnderTest.Validate(messageAddEditViewModel);

            // Assert.
            result.IsValid.Should().BeFalse();
            result.Errors.Should().HaveCount(1);
        }
        public async Task GivenAMessageWhenRemoveMessageIsCalledThenTheMessageIsRemoved()
        {
            // Arrange
            var messageToAdd = MessageAddEditViewModelBuilder.ABuilder().Build();
            var addedMessage = await this.AddMessage(messageToAdd).ConfigureAwait(false);

            var uri = new Uri($"{this.uri}/{addedMessage.Id}");

            // Act
            var response = await this.client.DeleteAsync(uri).ConfigureAwait(false);

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.NoContent);
            var allMessages = await this.GetMessages().ConfigureAwait(false);

            allMessages.Should().BeEmpty();
        }
        public async Task GivenANonExistentIdWhenEditMessageIsCalledThenTheMessageIsNotFound()
        {
            // Arrange
            var uri = new Uri($"{this.uri}/{Guid.NewGuid()}");
            var messageAddEditViewModel = MessageAddEditViewModelBuilder.ABuilder().Build();

            using var stringContent = GetStringContent(messageAddEditViewModel);

            // Act
            var response = await this.client.PutAsync(uri, stringContent).ConfigureAwait(false);

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.NotFound);
            var allMessages = await this.GetMessages().ConfigureAwait(false);

            allMessages.Should().BeEmpty();
        }
        public async Task GivenAnInvalidMessageWhenAddMessageIsCalledThenTheMessageIsNotAdded()
        {
            // Arrange
            var messageToAdd = MessageAddEditViewModelBuilder
                               .ABuilder()
                               .WithContent(string.Empty)
                               .Build();

            using var stringContent = GetStringContent(messageToAdd);

            // Act
            var response = await this.client.PostAsync(this.uri, stringContent).ConfigureAwait(false);

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
            var allMessages = await this.GetMessages().ConfigureAwait(false);

            allMessages.Should().BeEmpty();
        }
        public async Task GivenAMessageWhenGetMessagesIsCalledThenTheMessageIsReturned()
        {
            // Arrange
            var messageToAdd = MessageAddEditViewModelBuilder.ABuilder().Build();
            var addedMessage = await this.AddMessage(messageToAdd).ConfigureAwait(false);

            // Act
            var response = await this.client.GetAsync(this.uri).ConfigureAwait(false);

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);
            var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

            var messages = Deserialize <List <MessageViewModel> >(content);

            messages.Should().BeEquivalentTo(new List <MessageViewModel> {
                addedMessage
            });
        }
        public async Task GivenAMessageWhenAddMessageIsCalledThenTheMessageIsAdded()
        {
            // Arrange
            var messageToAdd = MessageAddEditViewModelBuilder.ABuilder().Build();

            using var stringContent = GetStringContent(messageToAdd);

            // Act
            var response = await this.client.PostAsync(this.uri, stringContent).ConfigureAwait(false);

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.Created);
            var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

            var message     = Deserialize <MessageViewModel>(content);
            var allMessages = await this.GetMessages().ConfigureAwait(false);

            allMessages.Should().BeEquivalentTo(new List <MessageViewModel> {
                message
            });
        }
Пример #12
0
        public void GivenAMessageWhenMapIsCalledThenTheMessageIsCorrectlyEdited()
        {
            // Arrange.
            var message = MessageBuilder.ABuilder().Build();
            var messageAddEditViewModel = MessageAddEditViewModelBuilder
                                          .ABuilder()
                                          .WithContent("Edited")
                                          .Build();
            var editedMessage = MessageBuilder
                                .ABuilder()
                                .WithId(message.Id)
                                .WithExternalId(message.ExternalId)
                                .WithAddedOn(message.AddedOn)
                                .WithEditedOn(message.EditedOn)
                                .WithContent(messageAddEditViewModel.Content)
                                .Build();

            // Act.
            this.systemUnderTest.Map(messageAddEditViewModel, message);

            // Assert.
            message.Should().BeEquivalentTo(editedMessage);
        }