public void TestStatusCodeResult_should_work_as_expected_with_method_without_arguments()
        {
            ApiControllerHttpActionResultActionTester actionTester = _controllerTester.Action(x => x.HttpActionResultActionWithoutArguments);

            _controller.HttpActionResult = new StatusCodeResult(HttpStatusCode.OK, _controller);

            StatusCodeResult result            = null;
            StatusCodeResult validatedResult   = null;
            bool             validateWasCalled = false;

            Action action = () =>
            {
                result = actionTester.TestStatusCodeResult(r =>
                {
                    validatedResult   = r;
                    validateWasCalled = true;
                });
            };

            action.Should().NotThrow();
            result.Should().Be(_controller.HttpActionResult);
            validateWasCalled.Should().BeTrue();
            validatedResult.Should().Be(_controller.HttpActionResult);

            _controller.HttpActionResult = _okResult;
            action.Should().Throw <ControllerTestException>().WithMessage(
                "Expected IHttpActionResult type System.Web.Http.Results.StatusCodeResult. Actual: System.Web.Http.Results.OkResult.");
        }
        public async Task AssignProfilePatternKeyReturnsNotModifiedIfMatchingProfilePatternKeyExists()
        {
            string fundingLineCode = NewRandomString();
            string key             = NewRandomString();

            GivenTheFundingConfiguration(true);
            ProfilePatternKey profilePatternKey = NewProfilePatternKey(_ => _.WithFundingLineCode(fundingLineCode).WithKey(key));

            PublishedProvider publishedProvider = NewPublishedProvider(_ => _.WithCurrent(
                                                                           NewPublishedProviderVersion(ppv => ppv.WithProfilePatternKeys(
                                                                                                           NewProfilePatternKey(ppk => ppk.WithFundingLineCode(fundingLineCode).WithKey(key))))));

            GivenThePublishedProvider(publishedProvider);

            StatusCodeResult result = await WhenProfilePatternKeyIsAssigned(_fundingStreamId, _fundingPeriodId, _providerId, profilePatternKey) as StatusCodeResult;

            result
            .Should()
            .NotBeNull();

            result
            .StatusCode
            .Should()
            .Be((int)HttpStatusCode.NotModified);
        }
        public void WithStatusCode_GivenExpectedValue_ShouldPass()
        {
            int statusCode = 200;

            ActionResult result = new StatusCodeResult(statusCode);

            result.Should().BeStatusCodeResult().WithStatusCode(statusCode);
        }
        public void WithStatusCode_GivenUnexpectedValue_ShouldFail()
        {
            int actualStatusCode   = 200;
            int expectedStatusCode = 400;

            var          failureMessage = FailureMessageHelper.ExpectedContextToBeXButY("StatusCodeResult.StatusCode", expectedStatusCode, actualStatusCode);
            ActionResult result         = new StatusCodeResult(actualStatusCode);

            Action action = () => result.Should().BeStatusCodeResult().WithStatusCode(expectedStatusCode, Reason, ReasonArgs);

            action.Should().Throw <Exception>()
            .WithMessage(failureMessage);
        }
        public async Task AssignProfilePatternKeyReturnsNotFoundIfPublishedProviderDoesNotExist()
        {
            GivenThePublishedProvider(null);
            GivenTheFundingConfiguration(true);

            ProfilePatternKey profilePatternKey = NewProfilePatternKey();
            StatusCodeResult  result            = await WhenProfilePatternKeyIsAssigned(_fundingStreamId, _fundingPeriodId, _providerId, profilePatternKey) as StatusCodeResult;

            result
            .Should()
            .NotBeNull();

            result
            .StatusCode
            .Should()
            .Be((int)HttpStatusCode.NotFound);
        }
        public void CanCheckHealth()
        {
            Response <HealthcheckResponse> response = A.Fake <Response <HealthcheckResponse> >();

            A.CallTo(() => response.Message).Returns(new HealthcheckResponse {
                Result = "success"
            });
            IRequestClient <HealthcheckCommand> client = A.Fake <IRequestClient <HealthcheckCommand> >();

            A.CallTo(() => client.GetResponse <HealthcheckResponse>(
                         A <HealthcheckCommand> ._,
                         A <CancellationToken> ._,
                         A <RequestTimeout> ._))
            .Returns(response);

            HealthController sut    = new HealthController(client);
            StatusCodeResult result = sut.Get().GetAwaiter().GetResult() as StatusCodeResult;

            result.Should().NotBe(null);
            result.StatusCode.Should().Be((int)HttpStatusCode.OK);
        }
Esempio n. 7
0
        public void BeStatusCodeResult_GivenStatusCodeResult_ShouldPass()
        {
            ActionResult result = new StatusCodeResult(200);

            result.Should().BeStatusCodeResult();
        }