public async Task UpdateConnectivityResult()
        {
            var request = new UpdateBrowserBasedConnectivityAndResolutionViewModel();

            var result = await controller.UpdateConnectivityAndResolutionAsync(SolutionId, request) as NoContentResult;

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

            mockMediator.Verify(m => m.Send(
                                    It.Is <UpdateSolutionConnectivityAndResolutionCommand>(c => c.Id == SolutionId && c.Data == request),
                                    It.IsAny <CancellationToken>()));
        }
Esempio n. 2
0
        public async Task UpdateConnectivityResult()
        {
            var request = new UpdateBrowserBasedConnectivityAndResolutionViewModel();

            var result =
                (await _controller.UpdateConnectivityAndResolutionAsync(SolutionId, request)
                 .ConfigureAwait(false)) as NoContentResult;

            result.StatusCode.Should().Be((int)HttpStatusCode.NoContent);
            _mockMediator.Verify(
                x => x.Send(
                    It.Is <UpdateSolutionConnectivityAndResolutionCommand>(c =>
                                                                           c.Id == SolutionId &&
                                                                           c.Data == request
                                                                           ),
                    It.IsAny <CancellationToken>()), Times.Once);
        }
Esempio n. 3
0
        public async Task InvalidRequiredResultForCommandReturnsValidationDetails()
        {
            _resultDictionary.Add("minimum-connection-speed", "required");
            var request = new UpdateBrowserBasedConnectivityAndResolutionViewModel();

            var result =
                (await _controller.UpdateConnectivityAndResolutionAsync(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["minimum-connection-speed"].Should().Be("required");

            _mockMediator.Verify(x => x.Send(
                                     It.Is <UpdateSolutionConnectivityAndResolutionCommand>(c =>
                                                                                            c.Data.MinimumConnectionSpeed == null &&
                                                                                            c.Data.MinimumDesktopResolution == null &&
                                                                                            c.Id == SolutionId), It.IsAny <CancellationToken>()),
                                 Times.Once);
        }
        public async Task InvalidRequiredResultForCommandReturnsValidationDetails()
        {
            resultDictionary.Add("minimum-connection-speed", "required");
            var request = new UpdateBrowserBasedConnectivityAndResolutionViewModel();

            var result = await controller.UpdateConnectivityAndResolutionAsync(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["minimum-connection-speed"].Should().Be("required");

            Expression <Func <UpdateSolutionConnectivityAndResolutionCommand, bool> > match = c =>
                                                                                              c.Data.MinimumConnectionSpeed == null &&
                                                                                              c.Data.MinimumDesktopResolution == null &&
                                                                                              c.Id == SolutionId;

            mockMediator.Verify(m => m.Send(It.Is(match), It.IsAny <CancellationToken>()));
        }
 public async Task <ActionResult> UpdateConnectivityAndResolutionAsync(
     [Required] string id,
     UpdateBrowserBasedConnectivityAndResolutionViewModel model) =>
 (await mediator.Send(new UpdateSolutionConnectivityAndResolutionCommand(id, model))).ToActionResult();
Esempio n. 6
0
 public async Task <ActionResult> UpdateConnectivityAndResolutionAsync([FromRoute][Required] string id, [FromBody][Required] UpdateBrowserBasedConnectivityAndResolutionViewModel viewModel) =>
 (await _mediator.Send(new UpdateSolutionConnectivityAndResolutionCommand(id, viewModel)).ConfigureAwait(false)).ToActionResult();