예제 #1
0
        public async Task CreateMembership_ShouldReturnNotFoundResult_WhenUserDoesNotExist()
        {
            // Arrange
            CreateMembershipBody body = new CreateMembershipBody {
                GroupId = 1, UserId = 751, IsAdmin = false
            };

            Mock <IMediator> mediatorMock = new Mock <IMediator>();

            mediatorMock
            .Setup(m => m.Send(It.IsAny <GroupExistsQuery>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(true);

            mediatorMock
            .Setup(m => m.Send(It.IsAny <UserExistsQuery>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(false);

            GroupMembershipController controller = new GroupMembershipController(mediatorMock.Object, null);

            // Act
            ActionResult <GroupMembershipResource> response = await controller.CreateMembership(body);

            // Assert
            NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result);

            ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

            Assert.NotNull(error);
            Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
        }
        public async Task GetFundingStructure_GivenNoSpecificationFoundForPublishedProviderVersion_ReturnsNotFound()
        {
            string publishedProviderVersionId = NewRandomString();
            string specificationId            = NewRandomString();
            string fundingPeriodId            = NewRandomString();
            string providerId      = NewRandomString();
            string fundingStreamId = NewRandomString();
            int    templateVersion = NewRandomNumber();

            PublishedProviderVersion publishedProviderVersion = NewPublishedProviderVersion(_ => _
                                                                                            .WithFundingStreamId(fundingStreamId)
                                                                                            .WithFundingPeriodId(fundingPeriodId)
                                                                                            .WithProviderId(providerId)
                                                                                            .WithSpecificationId(specificationId));

            _publishedFundingRepository.GetPublishedProviderVersionById(publishedProviderVersionId)
            .Returns(publishedProviderVersion);
            _specificationService.GetSpecificationSummaryById(specificationId)
            .Returns((SpecificationSummary)null);

            var result = await _service.GetPublishedProviderFundingStructure(publishedProviderVersionId);

            NotFoundObjectResult notFoundObjectResult = result.Should()
                                                        .BeAssignableTo <NotFoundObjectResult>()
                                                        .Which
                                                        .As <NotFoundObjectResult>();

            notFoundObjectResult.Value
            .Should()
            .Be($"Specification not found for SpecificationId - {specificationId}");
        }
예제 #3
0
        public IActionResult NotFoundObjectResult()
        {
            //This is a test
            var result = new NotFoundObjectResult(new { message = "404 Not Found", currentDate = DateTime.Now });

            return(result);
        }
        public static NotFoundObjectResult NotFound(string message = "Not found.")
        {
            var res = new Response(HttpStatusCode.NotFound, message, null);
            var obj = new NotFoundObjectResult(res);

            return(obj);
        }
예제 #5
0
        public void OnException(ExceptionContext context)
        {
            if (context.Exception is AcmeException acmeException)
            {
                _logger.LogDebug($"Detected {acmeException.GetType()}. Converting to BadRequest.");
#if DEBUG
                _logger.LogError(context.Exception, "AcmeException detected.");
#endif

                ObjectResult result;
                if (acmeException is ConflictRequestException)
                {
                    result = new ConflictObjectResult(acmeException.GetHttpError());
                }
                else if (acmeException is NotAllowedException)
                {
                    result = new UnauthorizedObjectResult(acmeException.GetHttpError());
                }
                else if (acmeException is NotFoundException)
                {
                    result = new NotFoundObjectResult(acmeException.GetHttpError());
                }
                else
                {
                    result = new BadRequestObjectResult(acmeException.GetHttpError());
                }

                result.ContentTypes.Add("application/problem+json");
                context.Result = result;
            }
        }
예제 #6
0
        public void TestPutNotFoundObject()
        {
            TouristSpot touristSpotToUpdate = new TouristSpot()
            {
                Name = "Virgen del verdún",
                Id   = 3
            };
            TouristSpot newData = new TouristSpot()
            {
                Name = "The Green Roofs",
            };
            TouristSpotModelIn touristSpotModelToUpdate = new TouristSpotModelIn(touristSpotToUpdate);
            TouristSpotModelIn newDataModel             = new TouristSpotModelIn(newData);
            var mock = new Mock <ITouristSpotLogic>(MockBehavior.Strict);

            mock.Setup(ts => ts.Update(touristSpotModelToUpdate.Id, newData));
            mock.Setup(ts => ts.Get(touristSpotToUpdate.Id)).Throws(new ObjectNotFoundInDatabaseException());
            var controller = new TouristSpotController(mock.Object);

            var result         = controller.Put(touristSpotModelToUpdate.Id, newDataModel) as NotFoundObjectResult;
            var expectedResult = new NotFoundObjectResult("There is no tourist spot with such id.");

            mock.VerifyAll();
            Assert.AreEqual(expectedResult.Value, result.Value);
        }
    public async Task UpdateGroup_ShouldReturnNotFoundResult_WhenGroupDoesNotExist()
    {
        // Arrange
        const int groupId = 15453;

        UpdateGroupBody model = new UpdateGroupBody
        {
            Name        = "Some updated name",
            Description = "Some updated description"
        };

        Mock <IMediator> mediatorMock = new Mock <IMediator>();

        mediatorMock
        .Setup(m => m.Send(It.IsAny <GroupExistsQuery>(), It.IsAny <CancellationToken>()))
        .ReturnsAsync(false);

        GroupController controller = new GroupController(mediatorMock.Object, null);

        // Act
        ActionResult response = await controller.UpdateGroup(groupId, model);

        // Assert
        NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response);

        ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

        Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
    }
        public async Task GetProviderDataForReleaseAsCsv_ShouldReturnNotFoundResultWhenNoDataFoundForGivenPublishedProviderIds()
        {
            IEnumerable <string> publishedProviderIds = new[] { NewRandomString(), NewRandomString() };
            string specificationId = NewRandomString();

            _validator.Validate(Arg.Is(specificationId))
            .Returns(new ValidationResult());

            PublishedProviderStatus[] statuses = new[] { PublishedProviderStatus.Approved };

            GivenTheFundingDataForCsv(Enumerable.Empty <PublishedProviderFundingCsvData>(), publishedProviderIds, specificationId, statuses);

            NotFoundObjectResult result = await WhenTheGetProviderDataForBatchReleaseAsCsvExecuted(publishedProviderIds, specificationId) as NotFoundObjectResult;

            result
            .Should()
            .NotBeNull();

            result.Value
            .Should()
            .BeOfType <string>()
            .Which
            .Should()
            .Be("No data found for given specification and published provider ids.");
        }
예제 #9
0
        public async Task GetTranslationsByLangauge_ShouldReturnNotFoundResult_WhenLanguageDoesNotExist()
        {
            // Arrange
            const int languageId = 8941;
            GetTranslationsByLanguageQueryParams model = new GetTranslationsByLanguageQueryParams();

            Mock <IMediator> mediatorMock = new Mock <IMediator>();

            mediatorMock
            .Setup(m => m.Send(It.IsAny <LanguageExistsQuery>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(false);

            LanguageController controller = new LanguageController(mediatorMock.Object);

            // Act
            ActionResult <IDictionary <string, string> > response =
                await controller.GetTranslationsByLanguage(languageId, model);

            // Assert
            NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result);

            ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

            Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
        }
예제 #10
0
        public override void OnException(ExceptionContext context)
        {
            Exception ex            = context.Exception;
            string    correlationId = context.HttpContext.GetCorrelationId();

            IActionResult     result;
            ExceptionContract errorData;

            if (ex is BusinessLogicException businessLogicException)
            {
                errorData = new ExceptionContract(businessLogicException, correlationId);
                if (ex is EntityNotFoundException)
                {
                    result = new NotFoundObjectResult(errorData);
                }
                else
                {
                    result = new BadRequestObjectResult(errorData);
                }
            }
            else
            {
                errorData = new ExceptionContract(DEFAULT_ERROR_MESSAGE, DEFAULT_ERROR_CODE, correlationId);
                result    = new ObjectResult(errorData)
                {
                    StatusCode = StatusCodes.Status500InternalServerError
                };
            }

            context.Result = result;
        }
예제 #11
0
        /// <summary>
        /// Forges an API error response based on a given dictionary and returns it.
        /// Make sure you check if the dictionary contains an error first.
        /// </summary>
        private IActionResult ForgeErrorResponse(Dictionary <ServiceDictionaryKey, object> dictionary)
        {
            IActionResult actionResult = new BadRequestObjectResult(dictionary[ServiceDictionaryKey.ERROR]);

            // HttpStatusCode provided, so we handle that too
            if (dictionary.ContainsKey(ServiceDictionaryKey.HTTPSTATUSCODE))
            {
                switch (dictionary[ServiceDictionaryKey.HTTPSTATUSCODE])
                {
                case HttpStatusCode.NotFound:
                    actionResult = new NotFoundObjectResult(dictionary[ServiceDictionaryKey.ERROR]);
                    break;

                case HttpStatusCode.Forbidden:
                    actionResult = new BadRequestObjectResult("(403) Forbidden: " + dictionary[ServiceDictionaryKey.ERROR]);
                    break;

                default:
                    actionResult = new BadRequestObjectResult(dictionary[ServiceDictionaryKey.ERROR]);
                    break;
                }
            }

            return(actionResult);
        }
예제 #12
0
        private IActionResult CreateErrorResult(Result result)
        {
            ActionResult         actionResult;
            ModelStateDictionary modelState = GetErrors(result);

            ValidationResult res = result.Notifications.FirstOrDefault(x => !x.IsValid);

            if (res == null || res.Errors.Count == 0)
            {
                return(new BadRequestObjectResult(modelState));
            }

            switch (res.Errors.First().ErrorCode)
            {
            case nameof(ErrorType.NotFound):
                actionResult = new NotFoundObjectResult(modelState);
                break;

            case nameof(ErrorType.BadRequest):
                actionResult = new UnprocessableEntityObjectResult(modelState);
                break;

            case nameof(ErrorType.Unauthorized):
                actionResult = new UnauthorizedResult();
                break;

            default:
                actionResult = new BadRequestObjectResult(modelState);
                break;
            }

            return(actionResult);
        }
예제 #13
0
        public async Task <ObjectResult> UpdateCurrentAsync(CancellationToken cancellationToken = default)
        {
            var userFromIdentity = GetUserFromIdentity();

            try
            {
                var user = await _userService.UpdateAsync(userFromIdentity, cancellationToken);

                var userViewModel = _mapper.Map <UserInfoViewModel>(user);

                var result = new OkObjectResult(userViewModel);
                return(result);
            }
            catch (UserEmailNotVerifiedException)
            {
                var modelState = new ModelStateDictionary();
                modelState.AddModelError(nameof(UserInfo.IsEmailVerified), "Email is not verified");

                var badResult = new BadRequestObjectResult(modelState);
                return(badResult);
            }
            catch (UserNotFoundException)
            {
                var badResult = new NotFoundObjectResult(null);
                return(badResult);
            }
        }
예제 #14
0
        public async Task ListDatasetSchemasModel_OnGet_WhenSpecificationNotFoundThenStatusCodeNotFoundReturned()
        {
            // Arrange
            IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();

            ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();

            IMapper mapper = MappingHelper.CreateFrontEndMapper();

            ILogger logger = Substitute.For <ILogger>();

            string expectedSpecificationId = "1";

            Specification expectedSpecification = null;

            specsClient
            .GetSpecification(Arg.Any <string>())
            .Returns(new ApiResponse <Specification>(HttpStatusCode.NotFound, expectedSpecification));

            ListDatasetSchemasModel listDatasetSchemasPageModel = new ListDatasetSchemasModel(specsClient, datasetClient, mapper);

            // Act
            IActionResult result = await listDatasetSchemasPageModel.OnGet(expectedSpecificationId);

            // Assert
            result.Should().NotBeNull();
            result.Should().BeOfType <NotFoundObjectResult>();
            NotFoundObjectResult typeResult = result as NotFoundObjectResult;

            typeResult.Value.Should().Be("Specification not found");
        }
예제 #15
0
        public void PostTestWrongExtensionReturnsErrorMessage()
        {
            //Arrange
            var             txtFileName    = "Data.txt";
            TestFileHelper  tstHelper      = new TestFileHelper(txtFileName, "");
            FilesController fileController = new FilesController(tstHelper.config.Object,
                                                                 new CsvFileHandler(new ValidationService(),
                                                                                    new FileService(tstHelper.config.Object),
                                                                                    new ParsingService()));

            // Expected result
            var expectedResult = new NotFoundObjectResult(new
            {
                message =
                    $"Selected file, {txtFileName}, does not have supported format CSV"
            });

            //Act
            var actualResult = fileController.Post(new List <IFormFile>()
            {
                tstHelper.fileMock.Object
            }, true);

            //Assert
            Assert.IsNotNull(actualResult);
            Assert.IsNotNull(actualResult.Result);
            Assert.AreEqual(expectedResult.StatusCode,
                            ((NotFoundObjectResult)actualResult.Result).StatusCode);
            Assert.AreEqual(expectedResult.Value.ToString(),
                            ((NotFoundObjectResult)actualResult.Result).Value.ToString());
        }
예제 #16
0
        public void GetAccountBalanceNotFound()
        {
            IActionResult        account      = controller.Get("500");
            NotFoundObjectResult actionresult = account as NotFoundObjectResult;

            Assert.Equal(404, actionresult.StatusCode);
        }
예제 #17
0
        public static NotFoundObjectResult NotFoundObjectResult(ResponseType responseType)
        {
            NotFoundObjectResult notFoundResult = new NotFoundObjectResult(Constants.ResponseDictionary[responseType]);

            notFoundResult.StatusCode = StatusCodes.Status404NotFound;
            return(notFoundResult);
        }
        public ActionResult <Environment> Delete(int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            Environment env = _envService.FindById(id);

            if (env != null)
            {
                _context.Environments.Remove(env);
                var retorno = _envService.SaveOrUpdate(env);

                return(Ok(retorno));
            }
            else
            {
                object res = null;
                NotFoundObjectResult notfound = new NotFoundObjectResult(res);
                notfound.StatusCode = 404;

                notfound.Value = "O Environment " + id + " não foi encontrado!";
                return(NotFound(notfound));
            }
        }
예제 #19
0
        public void GetCustomerByIdNotFound()
        {
            IActionResult        customers    = controller.Get(100);
            NotFoundObjectResult actionresult = customers as NotFoundObjectResult;

            Assert.Equal(404, actionresult.StatusCode);
        }
예제 #20
0
        protected async Task <ObjectResult> CreateInfoObjectResult <T>(Func <string, Task <ResultViewModel> > fillResultModelFunc, string email)
        {
            ObjectResult result;

            ResultViewModel resultViewModel = await fillResultModelFunc.Invoke(email);

            switch (resultViewModel.Flag)
            {
            case (int)HttpStatusCode.NotFound:
                result = new NotFoundObjectResult(resultViewModel.Information);
                break;

            case (int)HttpStatusCode.BadRequest:
                result = new BadRequestObjectResult(resultViewModel.Information);
                break;

            case (int)HttpStatusCode.OK:
                result = new OkObjectResult(resultViewModel.Information);
                break;

            default:
                result = new BadRequestObjectResult(UNKNOWN_ERROR_MESSAGE);
                break;
            }

            return(result);
        }
        public void CreateCommentByNoExistingUser()
        {
            //Arrange.
            ControllerContext fakeContext = GetFakeControllerContext();

            controller.ControllerContext = fakeContext;
            CommentModelIn input = new CommentModelIn()
            {
                Text = "this is a comment"
            };
            Exception internalEx = new UserNotFoundException();
            Exception toThrow    = new ServiceException(internalEx.Message, ErrorType.ENTITY_NOT_FOUND);

            matchService.Setup(ms => ms.CommentOnEncounter(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>())).Throws(toThrow);

            //Act.
            IActionResult        result     = controller.CommentOnMatch(3, input);
            NotFoundObjectResult badRequest = result as NotFoundObjectResult;
            ErrorModelOut        error      = badRequest.Value as ErrorModelOut;

            //Assert.
            matchService.Verify(ms => ms.CommentOnEncounter(3, "username", input.Text), Times.Once);
            Assert.IsNotNull(result);
            Assert.IsNotNull(badRequest);
            Assert.AreEqual(404, badRequest.StatusCode);
            Assert.IsNotNull(error);
            Assert.AreEqual(error.ErrorMessage, toThrow.Message);
        }
예제 #22
0
    public async Task EditMessage_ShouldReturnNotFoundResult_WhenMessageDoesNotExist()
    {
        // Arrange
        const int       messageId = 1;
        EditMessageBody body      = new EditMessageBody {
            HtmlContent = "<p>hello world</p>"
        };

        _mediatorMock
        .Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>()))
        .ReturnsAsync(false);

        MessageController controller = new MessageController(null, _mediatorMock.Object);

        // Act
        ActionResult response = await controller.EditMessage(messageId, body);

        // Assert
        NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response);

        ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

        Assert.NotNull(error);
        Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
    }
        public async Task PasswordResetEmail_PasswordResetLinkNotSent_ReturnsNotFound()
        {
            string email     = "fake_email";
            string resetCode = Guid.NewGuid().ToString();

            var registration = new Mock <IRegistration>();
            var httpContext  = new DefaultHttpContext();

            var uriBuilder = new UriBuilder
            {
                Scheme = httpContext.Request.Scheme,
                Host   = httpContext.Request.Host.ToString(),
                Path   = $"/user/ResetPassword/{resetCode}"
            };

            var link = uriBuilder.ToString();

            registration.Setup(register => register.SendPasswordResetLinkEmail(email, link)).ReturnsAsync("User not found...");

            var controllerContext = new ControllerContext()
            {
                HttpContext = httpContext,
            };

            var forgotPasswordController = new ForgotPasswordController(registration.Object)
            {
                ControllerContext = controllerContext,
            };

            var result = await forgotPasswordController.PasswordResetEmail(email);

            var notFoundResult = new NotFoundObjectResult(result);

            Assert.AreEqual(404, notFoundResult.StatusCode);
        }
예제 #24
0
    public async Task SendMessage_ShouldReturnNotFoundResult_WhenRecipientDoesNotExist()
    {
        // Arrange
        SendMessageBody body = new SendMessageBody
        {
            RecipientId = 4314, HtmlContent = "hello world"
        };

        _mediatorMock
        .Setup(m => m.Send(It.IsAny <RecipientExistsQuery>(), It.IsAny <CancellationToken>()))
        .ReturnsAsync(false);

        MessageController controller = new MessageController(null, _mediatorMock.Object);

        // Act
        ActionResult <ChatMessageResource> response = await controller.SendMessage(body);

        // Assert
        NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result);

        ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

        Assert.NotNull(error);
        Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
    }
예제 #25
0
        public async Task UpdateFriendshipStatus_ShouldReturnNotFound_WhenFriendshipDoesNotExist()
        {
            // Arrange
            const int friendshipId = 87921;

            UpdateFriendshipStatusBody model = new UpdateFriendshipStatusBody
            {
                FriendshipStatusId = FriendshipStatusId.Accepted
            };

            Mock <IMediator> mediatorMock = new Mock <IMediator>();

            mediatorMock
            .Setup(m => m.Send(It.IsAny <FriendshipExistsQuery>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(false);

            FriendshipController controller = new FriendshipController(mediatorMock.Object, null);

            // Act
            ActionResult response = await controller.UpdateFriendshipStatus(friendshipId, model);

            // Assert
            NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response);

            ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

            Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
        }
예제 #26
0
        public async Task UpdateMembership_ShouldReturnNotFoundResult_WhenMembershipDoesNotExist()
        {
            // Arrange
            const int            membershipId = 56431;
            UpdateMembershipBody body         = new UpdateMembershipBody {
                IsAdmin = true
            };

            Mock <IMediator> mediatorMock = new Mock <IMediator>();

            mediatorMock
            .Setup(m => m.Send(It.IsAny <MembershipExistsQuery>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(false);

            GroupMembershipController controller = new GroupMembershipController(mediatorMock.Object, null);

            // Act
            ActionResult response = await controller.UpdateMembership(membershipId, body);

            // Assert
            NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response);

            ErrorResource error = Assert.IsType <ErrorResource>(result.Value);

            Assert.NotNull(error);
            Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
        }
        public async Task LinkActorWithMovie_NonExistingMovie_ReturnsNotFound(int actorId, int movieId)
        {
            //Arrange
            var actorList = new List <Actor>()
            {
                new Actor()
                {
                    Id = actorId
                }
            };
            Mock <IQueryable <Actor> > mockActors = actorList.AsQueryable().BuildMock();

            _mockActorRepository.Setup(x => x.GetAll()).Returns(mockActors.Object);

            Mock <IQueryable <Movie> > mockMovies = new List <Movie>().AsQueryable().BuildMock();

            _mockMovieRepository.Setup(x => x.GetAll()).Returns(mockMovies.Object);

            //ACT
            IActionResult result = await _controller.LinkActorWithMovie(actorId, movieId);

            //ASSERT
            NotFoundObjectResult notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);

            Assert.Equal(nameof(movieId), notFoundObjectResult.Value);
        }
예제 #28
0
        public async Task <IActionResult> Index()
        {
            // If root role already exists in the system, return 404
            if (await _roleManager.RoleExistsAsync("root"))
            {
                var notFoundObject = new NotFoundObjectResult(this.NotFound());
                return(NotFound());
            }
            // Create root and admin roles and assign them to the current user
            List <string>  rolesList  = new List <string>();
            IdentityResult rootResult = await _roleManager.CreateAsync(new IdentityRole("root"));

            if (rootResult.Succeeded == true)
            {
                rolesList.Add("root");
                IdentityResult adminResult = await _roleManager.CreateAsync(new IdentityRole("admin"));

                if (adminResult.Succeeded == true)
                {
                    rolesList.Add("admin");
                    var currentUser = await _userManager.GetUserAsync(User);

                    await _userManager.AddToRolesAsync(currentUser, rolesList);
                }
            }
            return(RedirectToAction("Index", "Home"));
        }
예제 #29
0
        public static string GetNotFoundError(IActionResult actual)
        {
            Assert.IsInstanceOf <NotFoundObjectResult>(actual);
            NotFoundObjectResult result = actual as NotFoundObjectResult;

            return(result.Value?.ToString());
        }
예제 #30
0
        public void GetByNonExistantIdReturnsNotFound()
        {
            IActionResult        result       = _controller.Get(99);
            NotFoundObjectResult objectResult = result as NotFoundObjectResult;

            Assert.IsNotNull(objectResult);
        }
예제 #31
0
        public void HttpNotFoundObjectResult_InitializesStatusCode()
        {
            // Arrange & act
            var notFound = new NotFoundObjectResult(null);

            // Assert
            Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode);
        }
예제 #32
0
        public void HttpNotFoundObjectResult_InitializesStatusCodeAndResponseContent()
        {
            // Arrange & act
            var notFound = new NotFoundObjectResult("Test Content");

            // Assert
            Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode);
            Assert.Equal("Test Content", notFound.Value);
        }
예제 #33
0
        public async Task HttpNotFoundObjectResult_ExecuteSuccessful()
        {
            // Arrange
            var httpContext = GetHttpContext();
            var actionContext = new ActionContext()
            {
                HttpContext = httpContext,
            };

            var result = new NotFoundObjectResult("Test Content");

            // Act
            await result.ExecuteResultAsync(actionContext);

            // Assert
            Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode);
        }