public void InvalidStatusCode()
 {
     var _ = new MockedResponse
     {
         Body       = "valid body",
         StatusCode = (HttpStatusCode)100000,
         Method     = HttpMethod.Get,
         Route      = "/route"
     };
 }
 public void InvalidRoute(string route)
 {
     var _ = new MockedResponse
     {
         Body       = "valid body",
         StatusCode = HttpStatusCode.OK,
         Method     = HttpMethod.Get,
         Route      = route
     };
 }
Example #3
0
        public async Task RegisterResponse(MockedResponse response)
        {
            var searchedResponse =
                _responses.Find(r => r.Route == response.Route && r.Method == response.Method);

            if (searchedResponse != null)
            {
                throw new InvalidOperationException($"Route {response.Route} already exists");
            }

            _responses.Add(response);
        }
        private MockedResponse CreateResponse(string route, HttpMethod method)
        {
            var response = new MockedResponse
            {
                Method     = method,
                Route      = route,
                StatusCode = HttpStatusCode.OK,
                Body       = "default",
            };

            return(response);
        }
        public async Task RegisterResponses_Multiple_Success()
        {
            const string   route1 = "/route1", route2 = "/route2";
            HttpMethod     method1 = HttpMethod.Get, method2 = HttpMethod.Post;
            MockedResponse resp1 = CreateResponse(route1, method1), resp2 = CreateResponse(route2, method2);

            await _repository.RegisterResponse(resp1);

            await _repository.RegisterResponse(resp2);

            var savedResp1 = await _repository.GetMockedResponse(method1, route1);

            var savedResp2 = await _repository.GetMockedResponse(method2, route2);

            savedResp1.Route.Should().Be(route1);
            savedResp1.Method.Should().Be(method1);
            savedResp2.Route.Should().Be(route2);
            savedResp2.Route.Should().Be(route2);
            savedResp2.Method.Should().Be(method2);
        }
Example #6
0
        public async Task GenericEndpoint_EmptyBody()
        {
            var response = new MockedResponse
            {
                Method     = new HttpMethod("GET"),
                Route      = "/route",
                Body       = null,
                StatusCode = HttpStatusCode.OK
            };
            var repository = new InMemoryMockedResponseRepository();
            await repository.RegisterResponse(response);

            var context = new DefaultHttpContext();

            context.Request.Path   = "/route";
            context.Request.Method = "GET";
            var controller = BuildController(context, repository);

            var result = await controller.GenericResult() as ObjectResult;

            result.Should().NotBeNull();
            result.StatusCode.Should().Be(200);
            result.Value.Should().Be(null);
        }
 /// <summary>
 /// Register a set of mocked responses.
 /// </summary>
 /// <param name="response">Enumerable of responses to register</param>
 public async Task RegisterMockedResponse(MockedResponse response)
 {
     await _repository.RegisterResponse(response);
 }