Exemple #1
0
        private async Task AssertCall(bool isGet, string path, string query, string body, string expectedResult)
        {
            var ctrlDiscoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.RestfulController));
            var ctrls          = ctrlDiscoverer.GetControllers(null);

            var pathResolver = new PathResolver(ctrls);
            var httpCtx      = new Fakes.FakeHttpContext();

            if (isGet)
            {
                (httpCtx.Request as Fakes.FakeHttpRequest).WithPath(path);
            }
            else
            {
                (httpCtx.Request as Fakes.FakeHttpRequest).Method = "POST";
                (httpCtx.Request as Fakes.FakeHttpRequest).WithPath(path);
                (httpCtx.Request as Fakes.FakeHttpRequest).WriteBody(body);
            }
            foreach (var q in query.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
            {
                var parts = q.Split(":".ToCharArray());
                (httpCtx.Request as Fakes.FakeHttpRequest).AddQuery(parts[0], parts[1]);
            }

            var action        = pathResolver.ResolveAction(httpCtx.Request);
            var actionInvoker = new ActionInvoker(new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object), new ModelBinderCollection(new JsonSerializer(), new Moq.Mock <IServiceProvider>().Object), new JsonSerializer());
            await actionInvoker.Invoke(httpCtx, action);

            string result = httpCtx.Response.ReadBody();

            Assert.Equal(expectedResult, result);
        }
Exemple #2
0
        private HttpResponse InvokeAndGetResponse()
        {
            var ctrl = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.RawController))
                       .GetControllers(null)[0];
            var action          = ctrl.Actions[0];
            var serviceProvider = Fakes.FakeServiceProvider.GetServiceProvider();
            var ctrlBuilder     = new ControllerBuilder(serviceProvider);
            var actionInvoker   = new ActionInvoker(ctrlBuilder, new ModelBinderCollection(new JsonSerializer(), serviceProvider, new Fakes.FakeDefaultLiteApiOptionsRetriever()), new JsonSerializer());
            var httpCtx         = new Fakes.FakeHttpContext();

            actionInvoker.Invoke(httpCtx, action).Wait();
            return(httpCtx.Response);
        }
        private async Task AssertCanInvokeActionWithRouteParamOfType <T>(bool dateOnly = false)
        {
            Type type = typeof(T);

            object value = "";

            if (typeof(T) == typeof(DateTimeOffset))
            {
                value = "2017-10-28T09:51:17+07:00";
            }
            if (typeof(T) != typeof(string) && typeof(T) != typeof(DateTimeOffset))
            {
                value = Activator.CreateInstance(type);
            }
            if (typeof(T) == typeof(DateTime))
            {
                value = default(DateTime).ToString("yyyy-MM-dd HH:mm:ss");
                if (dateOnly)
                {
                    value = default(DateTime).ToString("yyyy-MM-dd");
                }
            }

            string actionName = "Action_" + type.Name;

            var discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.RouteSupportedParametersController));
            var ctrl       = discoverer.GetControllers(null).Single();
            var action     = ctrl.Actions.Single(x => x.Name == actionName.ToLower());
            var serializer = new JsonSerializer();
            var invoker    = new ActionInvoker(new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object),
                                               new Services.ModelBinders.ModelBinderCollection(
                                                   serializer, Fakes.FakeServiceProvider.GetServiceProvider(), new Fakes.FakeDefaultLiteApiOptionsRetriever()), new JsonSerializer());
            var httpCtx = new Fakes.FakeHttpContext();

            httpCtx.SetActionContext(action);
            httpCtx.Request.Path = "/api/RouteSupportedParameters/" + actionName + "/" + value;
            await invoker.Invoke(httpCtx, action);

            string jsonResult = httpCtx.Response.ReadBody();
            object result     = serializer.Deserialize(jsonResult, type);

            if (typeof(T) == typeof(DateTime))
            {
                value = default(DateTime);
            }
            if (typeof(T) == typeof(DateTimeOffset))
            {
                value = DateTimeOffset.Parse(value as string);
            }
            Assert.Equal(value, result);
        }
Exemple #4
0
        private async Task AssertDownloadAction(string actionName)
        {
            var httpCtx    = new Fakes.FakeHttpContext();
            var discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.FileDownloadController));
            var ctrlCtx    = discoverer.GetControllers(null).Single();
            var builder    = new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object);
            var invoker    = new ActionInvoker(builder, new Services.ModelBinders.ModelBinderCollection(new JsonSerializer(), new Moq.Mock <IServiceProvider>().Object), new JsonSerializer());
            var action     = ctrlCtx.Actions.First(x => x.Name == actionName);
            await invoker.Invoke(httpCtx, action);

            string response = httpCtx.Response.ReadBody();

            Assert.Equal(actionName, response);
        }
Exemple #5
0
        private HttpContext GetHttpCtx(bool notEmpty = true)
        {
            var httpCtx = new Fakes.FakeHttpContext();
            var request = (httpCtx.Request as Fakes.FakeHttpRequest);

            request.Method = "POST";
            var fileCollection = (request.Form.Files as Fakes.FakeFormFileCollection);

            if (notEmpty)
            {
                fileCollection.Data.Add("1", new Fakes.FakeFormFile());
                fileCollection.Data.Add("2", new Fakes.FakeFormFile());
            }
            return(httpCtx);
        }
Exemple #6
0
        private void AssertCanParseSimpleParam <T>()
        {
            Type type;
            Type nullableArg;
            bool isNullable = false;

            if (typeof(T).GetTypeInfo().IsNullable(out nullableArg))
            {
                type       = nullableArg;
                isNullable = true;
            }
            else
            {
                type = typeof(T);
            }

            object value = "";

            if (typeof(T) == typeof(TestEnum))
            {
                value = TestEnum.TestValueTest;
            }
            else if (typeof(T) != typeof(string))
            {
                value = Activator.CreateInstance(type);
            }

            string      actionName = "Action_" + type.Name + (isNullable ? "_Nullable" : "");
            string      url        = "/ParameterParsing/" + actionName;
            HttpContext ctx        = new Fakes.FakeHttpContext();

            ctx.SetLiteApiOptions(LiteApiOptions.Default);
            var request = ctx.Request as Fakes.FakeHttpRequest;

            request.Path = url;
            request.AddQuery("p", value.ToString());
            var discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.ParameterParsingController));
            var ctrl       = discoverer.GetControllers(null).Single();
            var action     = ctrl.Actions.Single(x => x.Name == actionName.ToLower());

            ctx.SetActionContext(action);

            ModelBinderCollection mb = new ModelBinderCollection(new JsonSerializer(), Fakes.FakeServiceProvider.GetServiceProvider(), new Fakes.FakeDefaultLiteApiOptionsRetriever());

            object[] parameters = mb.GetParameterValues(request, action);
            Assert.Equal(value, parameters.Single());
        }
        private async Task AssertResponseHttpStatusCode(Contracts.Models.SupportedHttpMethods actionMethod, int expectedCode)
        {
            IControllerDiscoverer discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.DifferentHttpMethodsController));
            var            controller        = discoverer.GetControllers(null).Single();
            IActionInvoker invoker           = new ActionInvoker(
                new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object),
                new ModelBinderCollection(new JsonSerializer(), new Moq.Mock <IServiceProvider>().Object)
                , new JsonSerializer()
                );
            var ctx = new Fakes.FakeHttpContext();

            ctx.Request.Method = actionMethod.ToString().ToLower();
            (ctx.Request as Fakes.FakeHttpRequest).AddQuery("a", "2").AddQuery("b", "3").AddQuery("c", "4").AddQuery("d", "5");
            await invoker.Invoke(ctx, controller.Actions.First(x => x.HttpMethod == actionMethod), null);

            Assert.Equal(expectedCode, ctx.Response.StatusCode);
        }
Exemple #8
0
        public async Task Action_WithRouteParametersWithCapitalLetters_CanBeInvoked()
        {
            var discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.RouteParamsController));
            var ctrl       = discoverer.GetControllers(null).Single();
            var action     = ctrl.Actions.Single(x => x.Name == "plus3");
            var serializer = new JsonSerializer();
            var invoker    = new ActionInvoker(new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object), new Services.ModelBinders.ModelBinderCollection(serializer, new Moq.Mock <IServiceProvider>().Object), new JsonSerializer());
            var httpCtx    = new Fakes.FakeHttpContext();

            httpCtx.Request.Path = "/api/v2/route/2/Plus3/4";
            await invoker.Invoke(httpCtx, action);

            string jsonResult = httpCtx.Response.ReadBody();
            object result     = serializer.Deserialize(jsonResult, typeof(int));

            Assert.Equal(6, result);
        }
        private async Task AssertResponseBody(Contracts.Models.SupportedHttpMethods actionMethod, string expectedResult)
        {
            IControllerDiscoverer discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.DifferentHttpMethodsController));
            var            controller        = discoverer.GetControllers(null).Single();
            IActionInvoker invoker           = new ActionInvoker(
                new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object),
                new ModelBinderCollection(new JsonSerializer(), Fakes.FakeServiceProvider.GetServiceProvider(), new Fakes.FakeDefaultLiteApiOptionsRetriever())
                , new JsonSerializer());
            var ctx = new Fakes.FakeHttpContext();

            (ctx.Request as Fakes.FakeHttpRequest).AddQuery("a", "2").AddQuery("b", "3").AddQuery("c", "4").AddQuery("d", "5");
            await invoker.Invoke(ctx, controller.Actions.First(x => x.HttpMethod == actionMethod), null);

            string body = ctx.Response.ReadBody();

            Assert.Equal(expectedResult, body);
        }
        private async Task AssertNotSetResponseCode(ClaimsPrincipal user, int expectedStatusCode)
        {
            IControllerDiscoverer discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.SecureController2));
            var            controller        = discoverer.GetControllers(null).Single();
            IActionInvoker invoker           = new ActionInvoker(
                new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object),
                new ModelBinderCollection(new JsonSerializer(), new Moq.Mock <IServiceProvider>().Object)
                , new JsonSerializer());
            var httpCtx = new Fakes.FakeHttpContext();

            httpCtx.User = user;
            var action = controller.Actions.First(x => x.Name == "get14");
            await invoker.Invoke(httpCtx, action, null);

            int statusCode = httpCtx.Response.StatusCode;

            Assert.Equal(expectedStatusCode, statusCode);
        }
Exemple #11
0
        public async Task LiteApiMiddleareTests_Registered_CanBeInvoked()
        {
            var servicesMock = new Moq.Mock <IServiceProvider>();

            servicesMock.Setup(x => x.GetService(typeof(IServiceProvider))).Returns(servicesMock.Object);

            var middleware = new LiteApiMiddleware(null, LiteApiOptions.Default, servicesMock.Object);
            var httpCtx    = new Fakes.FakeHttpContext();

            httpCtx.Request.Method = "GET";
            httpCtx.Request.Path   = "/";
            await middleware.Invoke(httpCtx);


            // expect exception on next registration
            TestExtensions.AssertExpectedException <Exception>(() =>
                                                               new LiteApiMiddleware(null, LiteApiOptions.Default, null),
                                                               "Middleware can be registered twice");
        }
Exemple #12
0
        public async Task CanGetParameterFromService()
        {
            IControllerDiscoverer discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.ServiceProvidedParameterController));
            var ctrl    = discoverer.GetControllers(null).Single();
            var action  = ctrl.Actions.Single();
            var mb      = new ModelBinderCollection(new JsonSerializer(), GetServiceProvider(), new Fakes.FakeDefaultLiteApiOptionsRetriever());
            var httpCtx = new Fakes.FakeHttpContext();

            (httpCtx.Request as Fakes.FakeHttpRequest).AddQuery("i", "1");
            object[] parameters = mb.GetParameterValues(httpCtx.Request, action);
            Assert.Equal(2, parameters.Length);
            Assert.True(typeof(Controllers.IIncrementService).IsAssignableFrom(parameters[1].GetType()));

            ActionInvoker invoker = new ActionInvoker(new ControllerBuilder(GetServiceProvider()), mb, new JsonSerializer());
            await invoker.Invoke(httpCtx, action);

            var result = httpCtx.Response.ReadBody();

            Assert.Equal("2", result);
        }
        public async Task ActionInvoker_MethodWithDefaultParam_CanBeInvoked()
        {
            IControllerDiscoverer discoverer = new Fakes.FakeLimitedControllerDiscoverer(typeof(Controllers.ParametersController));
            var            controller        = discoverer.GetControllers(null).Single();
            IActionInvoker invoker           = new ActionInvoker(
                new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object),
                new ModelBinderCollection(new JsonSerializer(), new Moq.Mock <IServiceProvider>().Object)
                , new JsonSerializer());
            var ctx = new Fakes.FakeHttpContext();
            await invoker.Invoke(ctx, controller.Actions.First(x => x.Name == "toupper"), null);

            string body = ctx.Response.ReadBody();

            Assert.Equal("\"ABC\"", body);

            ctx = new Fakes.FakeHttpContext();
            (ctx.Request as Fakes.FakeHttpRequest).AddQuery("a", "zxc");
            await invoker.Invoke(ctx, controller.Actions.First(x => x.Name == "toupper"), null);

            body = ctx.Response.ReadBody();
            Assert.Equal("\"ZXC\"", body);
        }