public async Task ShouldNotUpdateAsValidationInValid()
        {
            resultDictionary.Add("mobile-first-design", "required");
            var request = new UpdateBrowserBasedMobileFirstViewModel {
                MobileFirstDesign = null
            };
            var result = await browserMobileFirstController.UpdateMobileFirstAsync(
                SolutionId,
                request) as BadRequestObjectResult;

            Assert.NotNull(result);
            result.StatusCode.Should().Be(StatusCodes.Status400BadRequest);

            var validationResult = result.Value as Dictionary <string, string>;

            Assert.NotNull(validationResult);
            validationResult.Count.Should().Be(1);
            validationResult["mobile-first-design"].Should().Be("required");

            Expression <Func <UpdateSolutionBrowserMobileFirstCommand, bool> > match = c =>
                                                                                       c.MobileFirstDesign == null &&
                                                                                       c.SolutionId == SolutionId;

            mockMediator.Verify(m => m.Send(It.Is(match), It.IsAny <CancellationToken>()));
        }
        public async Task ShouldUpdateValidationValid()
        {
            var request = new UpdateBrowserBasedMobileFirstViewModel {
                MobileFirstDesign = "Yes"
            };
            var result = (await _browserMobileFirstController.UpdateMobileFirstAsync(SolutionId, request).ConfigureAwait(false))
                         as NoContentResult;

            result.StatusCode.Should().Be((int)HttpStatusCode.NoContent);
            _mockMediator.Verify(x => x.Send(
                                     It.Is <UpdateSolutionBrowserMobileFirstCommand>(c =>
                                                                                     c.MobileFirstDesign == "Yes" &&
                                                                                     c.SolutionId == SolutionId), It.IsAny <CancellationToken>()),
                                 Times.Once);
        }
        public async Task ShouldUpdateValidationValid()
        {
            var request = new UpdateBrowserBasedMobileFirstViewModel {
                MobileFirstDesign = "Yes"
            };
            var result = await browserMobileFirstController.UpdateMobileFirstAsync(SolutionId, request) as NoContentResult;

            Expression <Func <UpdateSolutionBrowserMobileFirstCommand, bool> > match = c =>
                                                                                       c.MobileFirstDesign == "Yes" &&
                                                                                       c.SolutionId == SolutionId;

            Assert.NotNull(result);
            result.StatusCode.Should().Be(StatusCodes.Status204NoContent);

            mockMediator.Verify(m => m.Send(It.Is(match), It.IsAny <CancellationToken>()));
        }
        public async Task ShouldNotUpdateAsValidationInValid()
        {
            _resultDictionary.Add("mobile-first-design", "required");
            var request = new UpdateBrowserBasedMobileFirstViewModel {
                MobileFirstDesign = null
            };
            var result =
                (await _browserMobileFirstController.UpdateMobileFirstAsync(SolutionId, request)
                 .ConfigureAwait(false)) as BadRequestObjectResult;

            result.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
            var validationResult = result.Value as Dictionary <string, string>;

            validationResult.Count.Should().Be(1);
            validationResult["mobile-first-design"].Should().Be("required");

            _mockMediator.Verify(x => x.Send(
                                     It.Is <UpdateSolutionBrowserMobileFirstCommand>(c =>
                                                                                     c.MobileFirstDesign == null &&
                                                                                     c.SolutionId == SolutionId), It.IsAny <CancellationToken>()),
                                 Times.Once);
        }
 public async Task <ActionResult> UpdateMobileFirstAsync([FromRoute][Required] string id,
                                                         [FromBody][Required] UpdateBrowserBasedMobileFirstViewModel viewModel) =>
 (await _mediator.Send(new UpdateSolutionBrowserMobileFirstCommand(id, viewModel?.MobileFirstDesign)).ConfigureAwait(false)).ToActionResult();
 public async Task <ActionResult> UpdateMobileFirstAsync(
     [Required] string id,
     UpdateBrowserBasedMobileFirstViewModel model) =>
 (await mediator.Send(new UpdateSolutionBrowserMobileFirstCommand(id, model?.MobileFirstDesign))).ToActionResult();