public async Task ShouldUpdateValidationInvalid()
        {
            resultDictionary.Add("supported-browsers", "required");
            resultDictionary.Add("mobile-responsive", "required");
            var request = new UpdateBrowserBasedBrowsersSupportedViewModel();

            var result = await browserSupportedController.UpdateBrowsersSupportedAsync(
                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(2);
            validationResult["supported-browsers"].Should().Be("required");
            validationResult["mobile-responsive"].Should().Be("required");

            Expression <Func <UpdateSolutionBrowsersSupportedCommand, bool> > match = c =>
                                                                                      !c.Data.BrowsersSupported.Any() &&
                                                                                      c.Data.MobileResponsive == null &&
                                                                                      c.SolutionId == SolutionId;

            mockMediator.Verify(m => m.Send(It.Is(match), It.IsAny <CancellationToken>()));
        }
Exemple #2
0
        public async Task ShouldUpdateValidationInvalid()
        {
            _resultDictionary.Add("supported-browsers", "required");
            _resultDictionary.Add("mobile-responsive", "required");
            var request = new UpdateBrowserBasedBrowsersSupportedViewModel();

            var result =
                (await _browserSupportedController.UpdateBrowsersSupportedAsync(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(2);
            validationResult["supported-browsers"].Should().Be("required");
            validationResult["mobile-responsive"].Should().Be("required");

            _mockMediator.Verify(x => x.Send(
                                     It.Is <UpdateSolutionBrowsersSupportedCommand>(c =>
                                                                                    !c.Data.BrowsersSupported.Any() &&
                                                                                    c.Data.MobileResponsive == null &&
                                                                                    c.SolutionId == SolutionId), It.IsAny <CancellationToken>()),
                                 Times.Once);
        }
Exemple #3
0
        public async Task ShouldUpdateValidationValid()
        {
            var request = new UpdateBrowserBasedBrowsersSupportedViewModel()
            {
                BrowsersSupported = new HashSet <string>()
                {
                    "Edge"
                },
                MobileResponsive = "yes"
            };

            var result =
                (await _browserSupportedController.UpdateBrowsersSupportedAsync(SolutionId, request)
                 .ConfigureAwait(false)) as NoContentResult;

            result.StatusCode.Should().Be((int)HttpStatusCode.NoContent);
            _mockMediator.Verify(
                x => x.Send(
                    It.Is <UpdateSolutionBrowsersSupportedCommand>(c =>
                                                                   c.SolutionId == SolutionId &&
                                                                   !c.Data.BrowsersSupported.Any(x => x != "Edge") &&
                                                                   c.Data.MobileResponsive == "yes"),
                    It.IsAny <CancellationToken>()), Times.Once);
        }
        public async Task ShouldUpdateValidationValid()
        {
            var request = new UpdateBrowserBasedBrowsersSupportedViewModel
            {
                BrowsersSupported = new HashSet <string> {
                    "Edge"
                },
                MobileResponsive = "yes",
            };

            var result = await browserSupportedController.UpdateBrowsersSupportedAsync(
                SolutionId,
                request) as NoContentResult;

            Expression <Func <UpdateSolutionBrowsersSupportedCommand, bool> > match = c =>
                                                                                      c.SolutionId == SolutionId &&
                                                                                      c.Data.BrowsersSupported.All(s => s == "Edge") &&
                                                                                      c.Data.MobileResponsive == "yes";

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

            mockMediator.Verify(m => m.Send(It.Is(match), It.IsAny <CancellationToken>()));
        }
Exemple #5
0
 public async Task <ActionResult> UpdateBrowsersSupportedAsync([FromRoute][Required] string id,
                                                               [FromBody][Required] UpdateBrowserBasedBrowsersSupportedViewModel viewModel) =>
 (await _mediator.Send(new UpdateSolutionBrowsersSupportedCommand(id, viewModel)).ConfigureAwait(false))
 .ToActionResult();
 public async Task <ActionResult> UpdateBrowsersSupportedAsync(
     [Required] string id,
     UpdateBrowserBasedBrowsersSupportedViewModel model) =>
 (await mediator.Send(new UpdateSolutionBrowsersSupportedCommand(id, model))).ToActionResult();