public static RouteData GetRouteDataFor(this RouteCollection collection, string url, bool isPost = false)
    {
        var context = new HttpContextMock();
        context.HttpRequest
            .SetupGet(r => r.ApplicationPath)
            .Returns("/");
        context.HttpRequest
            .SetupGet(r => r.AppRelativeCurrentExecutionFilePath)
            .Returns(url);
        context.HttpRequest
            .SetupGet(r => r.PathInfo)
            .Returns(string.Empty);

        if (isPost) {
            context.HttpRequest
                .SetupGet(r => r.HttpMethod)
                .Returns("POST");
        }

        context.HttpResponse
            .Setup(r => r.ApplyAppPathModifier(It.IsAny<string>()))
            .Returns<string>(r => {
                return r;
            });

        return collection.GetRouteData(context.Object);
    }
 public void SetUp()
 {
     contextMock = new HttpContextMock();
     var files = Rhino.Mocks.MockRepository.GenerateMock<HttpFileCollectionBase>();
     files.Stub(x => x.Count).Return(0);
     contextMock.Request.Stub(x => x.Files).Return(files);
 }
    public void ShouldAllowSettingQueryViaDictionary()
    {
        var httpContextMock = HttpContextMock.Default();
        var name            = Any.String();
        var value           = Any.String();

        httpContextMock.Request().WithQuery(new QueryCollection(new Dictionary <string, StringValues>
        {
            [name] = value
        }));

        httpContextMock.Request().RealInstance.Query[name].Should().BeEquivalentTo(new StringValues(value));
    }
Exemplo n.º 4
0
        public void WriteResponse()
        {
            var stream = new MemoryStream(Encoding.UTF8.GetBytes("test contents"));

            using (var result = new StreamResult(stream))
            {
                var contextMock = new HttpContextMock();
                result.WriteResponse(contextMock.response);
                Assert.Equals(contextMock.response.StatusCode, 200);
                Assert.Equals(contextMock.response.ContentType, "application/octet-stream");
                Assert.Equals(contextMock.response.GetContentsFromBody(), "test contents");
            }
        }
        public void can_add_a_value_to_the_application_object()
        {
            var mockHttpContext = new HttpContextMock();
            const int clientAccountId = 123;
            mockHttpContext.HttpApplicationState.Setup(x => x.Add("test", clientAccountId));
            mockHttpContext.HttpApplicationState.Setup(x => x["test"]).Returns(clientAccountId);

            mockHttpContext.Object.Application.Add("test", clientAccountId);

            Assert.NotNull(mockHttpContext.Object.Application);
            Assert.Equal(123, mockHttpContext.Object.Application["test"]);

            mockHttpContext.HttpApplicationState.VerifyAll();
        }
        public void can_call_modify_client_web_method()
        {
            var mockHttpContext = new HttpContextMock();

            var clientAccountIdList = new List<int>();

            mockHttpContext.HttpApplicationState.Setup(x => x["ClientAccounts"]).Returns(clientAccountIdList);

            var ses = new MyWebService(mockHttpContext.Object);

            Assert.Equal("Client Account Modification Complete", ses.ModifyClientAccount(0));

            mockHttpContext.HttpApplicationState.VerifyAll();
        }
        public void throws_exception_when_trying_to_modify_an_account_that_is_already_processing()
        {
            var mockHttpContext = new HttpContextMock();
            const int clientAccountId = 123;
            var clientAccountIdList = new List<int>() { clientAccountId };

            mockHttpContext.HttpApplicationState.Setup(x => x["ClientAccounts"]).Returns((object x) => clientAccountIdList).AtMost(2);

            var ses = new MyWebService(mockHttpContext.Object);

            Assert.Throws<ApplicationException>(() => ses.ModifyClientAccount(clientAccountId));

            mockHttpContext.HttpApplicationState.VerifyAll();
        }
    public void ShouldAllowRewindingRequestBody()
    {
        var httpContextMock = HttpContextMock.Default();

        httpContextMock.Request().WithStringBody(Any.String());
        using var streamReader  = new StreamReader(httpContextMock.Request().RealInstance.Body);
        using var streamReader2 = new StreamReader(httpContextMock.Request().RealInstance.Body);
        var content = streamReader.ReadToEnd();

        httpContextMock.Request().RewindBody();
        var content2 = streamReader2.ReadToEnd();

        content.Should().Be(content2);
    }
Exemplo n.º 9
0
        public void WithRequestAsObjectShouldWorkWithSetRequestAction()
        {
            var httpContext = new HttpContextMock();

            httpContext.Request.Form = new FormCollection(new Dictionary <string, StringValues> {
                ["Test"] = "TestValue"
            });

            MyController <MvcController>
            .Instance()
            .WithHttpRequest(httpContext.Request)
            .Calling(c => c.WithRequest())
            .ShouldReturn()
            .Ok();
        }
Exemplo n.º 10
0
        public void WriteResponse()
        {
            var formats = new[] { Formatting.None, Formatting.Indented };

            foreach (var format in formats)
            {
                var result         = new JsonResult(new { a = 1 }, format);
                var contextMock    = new HttpContextMock();
                var exceptedResult = JsonConvert.SerializeObject(new { a = 1 }, format);
                result.WriteResponse(contextMock.response);
                Assert.Equals(contextMock.response.StatusCode, 200);
                Assert.Equals(contextMock.response.ContentType, result.ContentType);
                Assert.Equals(contextMock.response.GetContentsFromBody(), exceptedResult);
            }
        }
Exemplo n.º 11
0
        public void WithRequestAsObjectShouldWorkWithSetRequestAction()
        {
            var httpContext = new HttpContextMock();

            httpContext.Request.Form = new FormCollection(new Dictionary <string, StringValues> {
                ["Test"] = "TestValue"
            });

            MyViewComponent <HttpRequestComponent>
            .Instance()
            .WithHttpRequest(httpContext.Request)
            .InvokedWith(c => c.Invoke())
            .ShouldReturn()
            .View();
        }
Exemplo n.º 12
0
        public void WriteResponse()
        {
            var image       = new Bitmap(123, 456);
            var result      = new ImageResult(image);
            var contextMock = new HttpContextMock();

            result.WriteResponse(contextMock.response);
            contextMock.response.body.Seek(0, SeekOrigin.Begin);
            Assert.Equals(contextMock.response.StatusCode, 200);
            Assert.Equals(contextMock.response.ContentType, "image/jpeg");
            var imageVerify = Image.FromStream(contextMock.response.body);

            Assert.Equals(imageVerify.Width, 123);
            Assert.Equals(imageVerify.Height, 456);
        }
Exemplo n.º 13
0
        public void SendVerificationCodeSuccessful()
        {
            // Arrange
            string testUserName = "******";

            Mock <User> mockUserModel = new Mock <User>();
            Mock <CosmoMongerMembershipUser> mockUser = new Mock <CosmoMongerMembershipUser>(mockUserModel.Object);

            mockUser.Expect(m => m.SendVerificationCode(It.IsRegex("http://www.cosmomonger.com/Account/VerifyEmail?username=TestUser&verificationCode=.*")))
            .AtMostOnce().Verifiable();

            Mock <MembershipProvider> mockMembership = new Mock <MembershipProvider>();

            mockMembership.Expect <MembershipUser>(m => m.GetUser(testUserName, false))
            .Returns(mockUser.Object).AtMostOnce().Verifiable();

            // Mock the HTTP request also
            HttpRequestMock mockRequest = new HttpRequestMock();
            Uri             mockUrl     = new Uri("http://www.cosmomonger.com/Account/SendVerificationCode?username=TestUser");

            mockRequest.Expect(r => r.Url)
            .Returns(mockUrl);
            mockRequest.Expect(r => r.HttpMethod)
            .Returns("GET");
            mockRequest.Expect(r => r.AppRelativeCurrentExecutionFilePath)
            .Returns("~/Account/");

            HttpContextMock mockHttpContext = new HttpContextMock();

            mockHttpContext.Expect(c => c.Request)
            .Returns(mockRequest.Object);

            RouteCollection routeCollection = new RouteCollection();

            MvcApplication.RegisterRoutes(routeCollection);
            RouteData route = routeCollection.GetRouteData(mockHttpContext.Object);

            AccountController controller = new AccountController(mockMembership.Object);

            controller.ControllerContext = new ControllerContext(mockHttpContext.Object, route, new Mock <ControllerBase>().Object);
            controller.Url = new UrlHelper(new RequestContext(mockHttpContext.Object, route));

            // Act
            ViewResult result = (ViewResult)controller.SendVerificationCode(testUserName);

            // Assert
            Assert.That(result.ViewName, Is.EqualTo("SentVerificationCode"), "Should have returned the SentVerificationCode view");
        }
    public void ShouldAllowSettingBytesBody()
    {
        var httpContextMock = HttpContextMock.Default();
        var content         = Any.Array <byte>(3);

        httpContextMock.Request().WithBytesBody(content);

        var result = new List <byte>
        {
            (byte)httpContextMock.Request().RealInstance.Body.ReadByte(),
            (byte)httpContextMock.Request().RealInstance.Body.ReadByte(),
            (byte)httpContextMock.Request().RealInstance.Body.ReadByte()
        };

        result.Should().Equal(content);
        httpContextMock.Request().RealInstance.Body.Length.Should().Be(3);
    }
Exemplo n.º 15
0
    public async Task <AddTodoItemAdapterResponse> AttemptToAddTodoItem(Func <HttpRequestMock, HttpRequestMock> customize)
    {
        var httpContextMock = HttpContextMock.Default();
        await _adapter.AddTodoEndpoint.Handle(
            customize(httpContextMock.Request()
                      .AppendPathSegment("todo")
                      .WithHeader("Authorization", $"Bearer {TestTokens.GenerateToken()}")
                      .WithHeader("Content-Type", MediaTypeNames.Application.Json)
                      .WithHeader("Accept", MediaTypeNames.Application.Json)
                      .WithQueryParam("customerId", Any.String())
                      .WithJsonBody(new { title = "Meeting", content = "there's a meeting you need to attend" })).RealInstance,
            httpContextMock.Response().RealInstance,
            new CancellationToken()
            );

        var httpResponseMock = httpContextMock.Response();

        return(new AddTodoItemAdapterResponse(httpResponseMock));
    }
Exemplo n.º 16
0
        protected override void EstablishContext()
        {
            base.EstablishContext();
            var script = new StringBuilder();
            script.AppendLine("class {0} < Controller".FormattedWith(_controllerName));
            script.AppendLine("  def my_action");
            script.AppendLine("    \"Can't see ninjas\".to_clr_string");
            script.AppendLine("  end");
            script.AppendLine("end");

            _rubyEngine.ExecuteScript(script.ToString());
             var rubyClass = _rubyEngine.GetRubyClass(_controllerName);

            var httpContext = new HttpContextMock().Object;
            var requestContext = new RequestContext(httpContext, new RouteData());
            var controller = _rubyEngine.CreateInstance<RubyController>(rubyClass);
            controller.InternalInitialize(new ControllerConfiguration { Context = requestContext, Engine = _rubyEngine, RubyClass = rubyClass });

            _controllerContext = new ControllerContext(requestContext, controller);
        }
        private RouteContext GetRouteContext(string url, string method = "GET", string queryString = null,
            string body = null, string contentType = null)
        {
            var httpContext = new HttpContextMock();
            httpContext.Request.Path = new PathString(url);
            httpContext.Request.QueryString = new QueryString(queryString);
            httpContext.Request.Method = method;
            httpContext.Request.ContentType = contentType;

            if (body != null)
            {
                httpContext.Request.Body = new MemoryStream();
                var streamWriter = new StreamWriter(httpContext.Request.Body);
                streamWriter.Write(body);
                streamWriter.Flush();
                httpContext.Request.Body.Position = 0;
            }

            return new RouteContext(httpContext);
        }
        private RouteContext GetRouteContext(string url, string method = "GET", string queryString = null,
            string body = null, string contentType = null)
        {
            var httpContext = new HttpContextMock();
            httpContext.Request.Path = new PathString(url);
            httpContext.Request.QueryString = new QueryString(queryString);
            httpContext.Request.Method = method;
            httpContext.Request.ContentType = contentType;

            if (body != null)
            {
                httpContext.Request.Body = new MemoryStream();
                var streamWriter = new StreamWriter(httpContext.Request.Body);
                streamWriter.Write(body);
                streamWriter.Flush();
                httpContext.Request.Body.Position = 0;
            }

            return new RouteContext(httpContext);
        }
        public static TModel ReadFromStream <TModel>(Stream stream, string contentType, Encoding encoding)
        {
            stream.Restart();

            // formatters do not support non HTTP context processing
            var httpContext = new HttpContextMock();

            httpContext.Request.Body        = stream;
            httpContext.Request.ContentType = contentType;

            var typeOfModel           = typeof(TModel);
            var modelMetadataProvider = TestServiceProvider.GetRequiredService <IModelMetadataProvider>();
            var modelMetadata         = modelMetadataProvider.GetMetadataForType(typeOfModel);

            var inputFormatterContext = new InputFormatterContext(
                httpContext,
                string.Empty,
                new ModelStateDictionary(),
                modelMetadata,
                (str, enc) => new StreamReader(httpContext.Request.Body, encoding));

            var inputFormatter = inputFormatters.GetOrAdd(contentType, _ =>
            {
                var mvcOptions = TestServiceProvider.GetRequiredService <IOptions <MvcOptions> >();
                var formatter  = mvcOptions.Value?.InputFormatters?.FirstOrDefault(f => f.CanRead(inputFormatterContext));
                ServiceValidator.ValidateFormatterExists(formatter, contentType);

                return(formatter);
            });

            var result = AsyncHelper.RunSync(() => inputFormatter.ReadAsync(inputFormatterContext)).Model;

            try
            {
                return((TModel)result);
            }
            catch (Exception)
            {
                throw new InvalidDataException($"Expected stream content to be formatted to {typeOfModel.ToFriendlyTypeName()} when using '{contentType}', but instead received {result.GetName()}.");
            }
        }
Exemplo n.º 20
0
        protected override void EstablishContext()
        {
            base.EstablishContext();
            var script = new StringBuilder();

            script.AppendLine("class {0} < Controller".FormattedWith(_controllerName));
            script.AppendLine("  def my_action");
            script.AppendLine("    \"Can't see ninjas\".to_clr_string");
            script.AppendLine("  end");
            script.AppendLine("end");

            _rubyEngine.ExecuteScript(script.ToString());
            _rubyClass = _rubyEngine.GetRubyClass(_controllerName);

            _httpContextMock = new HttpContextMock();
            var httpContext = _httpContextMock.Object;

//            EstablishHttpContext(httpContext);

            _requestContext = new RequestContext(httpContext, new RouteData());
        }
Exemplo n.º 21
0
        public void WriteResponse()
        {
            using (var layout = new TestDirectoryLayout()) {
                Application.Ioc.Unregister <TemplateManager>();
                Application.Ioc.RegisterMany <TemplateManager>(ReuseType.Singleton);
                layout.WritePluginFile("PluginA", "templates/__test_a.html", "test a {{ name }}");
                layout.WritePluginFile("PluginB", "templates/__test_b.html", "test b {{ name }}");

                var result      = new TemplateResult("__test_a.html", new { name = "asd" });
                var contextMock = new HttpContextMock();
                result.WriteResponse(contextMock.response);
                Assert.Equals(contextMock.response.StatusCode, 200);
                Assert.Equals(contextMock.response.ContentType, "text/html");
                Assert.Equals(contextMock.response.GetContentsFromBody(), "test a asd");

                result      = new TemplateResult("__test_b.html", new { name = "asd" });
                contextMock = new HttpContextMock();
                result.WriteResponse(contextMock.response);
                Assert.Equals(contextMock.response.StatusCode, 200);
                Assert.Equals(contextMock.response.ContentType, "text/html");
                Assert.Equals(contextMock.response.GetContentsFromBody(), "test b asd");
            }
        }
    static HttpContextMock GetHttpContext(string appPath, string requestPath, string httpMethod)
    {
        HttpContextMock httpContext = new HttpContextMock();

        if (!string.IsNullOrEmpty(appPath)) {
            httpContext.HttpRequest.SetupGet(r => r.ApplicationPath).Returns(appPath);
        } else {
            httpContext.HttpRequest.SetupGet(r => r.ApplicationPath).Returns("http://test.com");
        }

        if (!string.IsNullOrEmpty(requestPath)) {
            httpContext.HttpRequest.SetupGet(r => r.AppRelativeCurrentExecutionFilePath).Returns(requestPath);
        }

        httpContext.HttpRequest.SetupGet(r => r.PathInfo).Returns(string.Empty);

        if (!string.IsNullOrEmpty(httpMethod)) {
            httpContext.HttpRequest.SetupGet(r => r.HttpMethod).Returns(httpMethod);
        }

        httpContext.HttpResponse.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => r.Contains(AppPathModifier) ? r : AppPathModifier + r);

        return httpContext;
    }
        public void WithRequestAsObjectShouldWorkWithSetRequestActionForPocoController()
        {
            MyApplication
            .StartsFrom <DefaultStartup>()
            .WithServices(services =>
            {
                services.AddHttpContextAccessor();
            });

            var httpContext = new HttpContextMock();

            httpContext.Request.Form = new FormCollection(new Dictionary <string, StringValues> {
                ["Test"] = "TestValue"
            });

            MyController <FullPocoController>
            .Instance()
            .WithHttpRequest(httpContext.Request)
            .Calling(c => c.WithRequest())
            .ShouldReturn()
            .Ok();

            MyApplication.StartsFrom <DefaultStartup>();
        }
Exemplo n.º 24
0
        public void Run()
        {
            var extensionConfigPath = arguments["extension"].Trim();
            var workingDirectory = arguments["directory"].Trim();

            if (!File.Exists(extensionConfigPath))
            {
                log.ErrorFormat("The extension configuration file '{0}' doesn't exist", extensionConfigPath);
                return;
            }

            if (!Directory.Exists(workingDirectory))
            {
                log.ErrorFormat("Directory '{0}' doesn't exist", workingDirectory);
                return;
            }

            var builder = new ExtensionBuilder();
            var fileInfo = new FileInfo(extensionConfigPath);
            var extensionConfig = ProjectConfiguration.Create(fileInfo.FullName);

            if (string.IsNullOrEmpty(extensionConfig.Name))
            {
                log.ErrorFormat("The extension needs a name, build cancelled");
                return;
            }

            log.InfoFormat("Building extension {0}.", extensionConfig.Name);

            var extensionFile = Path.Combine(fileInfo.DirectoryName, extensionConfig.Name + ".zip");
            builder.BuildExtension(fileInfo.DirectoryName, extensionFile);

            var projectFiles = Directory
                .GetFiles(workingDirectory, "Project.config", SearchOption.AllDirectories)
                .Where(s => s != fileInfo.FullName && !s.Contains(@"\bin\"));

            foreach (var projectFile in projectFiles)
            {
                var projectInfo = new FileInfo(projectFile);
                var projectConfig = ProjectConfiguration.Create(projectInfo.FullName);

                if (projectConfig.Dependencies.Contains(extensionConfig.Name))
                {
                    var httpContext = new HttpContextMock("/");
                    var projectContext = new SageContext(httpContext, delegate(string path)
                    {
                        path = path.ReplaceAll("^~?/", string.Empty).ReplaceAll("/", "\\");
                        if (!Path.IsPathRooted(path))
                            path = Path.Combine(projectInfo.DirectoryName, path);

                        return path;

                    },	projectConfig);

                    string installPath = Path.Combine(projectContext.Path.ExtensionPath, Path.GetFileName(extensionFile));
                    File.Copy(extensionFile, installPath, true);
                }
            }
        }
 protected HttpTestContext()
 {
     TestHelper.ExecuteTestCleanup();
     this.httpContextMock = TestHelper.CreateHttpContextMock();
 }
        public void WithRequestAsObjectShouldWorkWithSetRequestAction()
        {
            var httpContext = new HttpContextMock();
            httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> { ["Test"] = "TestValue" });

            MyController<MvcController>
                .Instance()
                .WithHttpRequest(httpContext.Request)
                .Calling(c => c.WithRequest())
                .ShouldReturn()
                .Ok();
        }
Exemplo n.º 27
0
        public bool ParseArguments(string[] args)
        {
            arguments = new NameValueCollection();
            foreach (string arg in args)
            {
                if (arg.StartsWith("-targetpath:"))
                {
                    arguments["targetPath"] = arg.Substring(12).Trim('"');
                }

                if (arg.StartsWith("-category:"))
                {
                    arguments["category"] = arg.Substring(10).Trim('"');
                }

                if (arg.StartsWith("-reportpath:"))
                {
                    arguments["reportpath"] = arg.Substring(12).Trim('"');
                }

                if (arg.StartsWith("-emitsummary:"))
                {
                    arguments["emitSummary"] = arg.Substring(13) == "1" ? "1" : "0";
                }

                if (arg.StartsWith("-merge:"))
                {
                    arguments["mergeAssets"] = arg.Substring(7).ContainsAnyOf("yes", "1", "true") ? "1" : "0";
                }
            }

            if (arguments["targetPath"] != null && arguments["category"] != null)
            {
                HttpContextMock httpContext = new HttpContextMock("sage");

                context = new SageContext(httpContext, arguments["category"], this.MapPath);
                categoryPath = context.Path.GetPhysicalCategoryPath(arguments["category"]);

                return true;
            }

            return false;
        }
        public void WithRequestAsObjectShouldWorkWithSetRequestAction()
        {
            var httpContext = new HttpContextMock();
            httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> { ["Test"] = "TestValue" });

            MyViewComponent<HttpRequestComponent>
                .Instance()
                .WithHttpRequest(httpContext.Request)
                .InvokedWith(c => c.Invoke())
                .ShouldReturn()
                .View();
        }
Exemplo n.º 29
0
 public UnitTestContext(AuthenticationScheme authenticationScheme, Action <CertificateAuthenticationOptions> certificateAuthenticationOptionsConfigurer, HttpContextMock httpContext, LoggerFactoryMock loggerFactory, SystemClockMock systemClock, UrlEncoder urlEncoder)
 {
     this.AuthenticationScheme = authenticationScheme ?? throw new ArgumentNullException(nameof(authenticationScheme));
     this.CertificateAuthenticationOptionsMonitor = new OptionsMonitorMock <CertificateAuthenticationOptions>(certificateAuthenticationOptionsConfigurer);
     this.HttpContext   = httpContext ?? throw new ArgumentNullException(nameof(httpContext));
     this.LoggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
     this.SystemClock   = systemClock ?? throw new ArgumentNullException(nameof(systemClock));
     this.UrlEncoder    = urlEncoder ?? throw new ArgumentNullException(nameof(urlEncoder));
 }
Exemplo n.º 30
0
        /// <summary>
        /// Tests the specified URL against all configured routes and displays a view that shows the results as an HTML table. 
        /// </summary>
        /// <param name="url">The URL to test</param>
        /// <param name="httpMethod">The HTTP request method to test with.</param>
        /// <returns>The HTML string that contains the table with the test results.</returns>
        public string Index(string url, string httpMethod)
        {
            if (!Context.IsDeveloperRequest)
            {
                Response.StatusCode = 404;
                return string.Empty;
            }

            url = MakeAppRelative(url ?? string.Empty);
            httpMethod = httpMethod ?? "GET";

            var httpContext = new HttpContextMock(url, httpMethod);

            var httpMethodOptions = FormatOptions(httpMethod, new[] { "GET", "POST", "PUT", "DELETE", "HEAD" });
            var routeDataText = GetRoutesText(httpContext);
            return string.Format(HtmlFormat, url, httpMethodOptions, routeDataText);
        }
    public void ShouldContainEmptyBodyInResponse()
    {
        var httpContextMock = HttpContextMock.Default();

        httpContextMock.Response().BodyString().Should().BeEmpty();
    }
 protected HttpTestContext()
 {
     TestHelper.ExecuteTestCleanup();
     this.httpContextMock = TestHelper.CreateHttpContextMock();
 }
        public void Setup()
        {
            _resolver = new Mock<IRepositoryResolver>();
            _resolver.Setup(x => x.GetRepository(It.IsAny<string>()))
                .Returns(new Repository(TestUtils.GetRepositoryPath("Test")));

            _controller = new RepositoryController(new Mock<ISettingsProvider>().Object, _resolver.Object, null);

            _executingContext = new Mock<ActionExecutingContext>();
            _executingContext.Setup(x => x.Controller).Returns(_controller);

            _actionParameters = new Dictionary<string, object>();
            _executingContext.Setup(x => x.ActionParameters).Returns(_actionParameters);
            _actionParameters.Add("request", new RepositoryNavigationRequest());

            _routeData = new RouteData();
            _executingContext.Setup(x => x.RouteData).Returns(_routeData);

            var requestContext = new Mock<RequestContext>();
            var httpContext = new HttpContextMock();
            requestContext.Setup(x => x.HttpContext).Returns(httpContext.Object);
            _executingContext.Setup(x => x.HttpContext).Returns(httpContext.Object);

            _filter = new RepositoryRequestAttribute
            {
                RepositoryResolver = _resolver.Object
            };
        }
Exemplo n.º 34
0
        private static string GetRoutesText(HttpContextMock fakeContext)
        {
            var sb = new StringBuilder();
            foreach (Route route in RouteTable.Routes)
            {
                RouteData rd = route.GetRouteData(fakeContext);

                var isMatch = false;
                var match = rd == null ? "No" : "Yes";

                // Get values
                var values = "N/A";
                if (rd != null)
                {
                    isMatch = true;
                    values = FormatValues(rd.Values);
                }

                // Get defaults
                var defaults = FormatValues(route.Defaults);

                // Get constraints
                var constraints = FormatValues(route.Constraints);

                // Get dataTokens
                var dataTokens = FormatValues(route.DataTokens);

                // Create table row
                var name = route is LowerCaseRoute ? ((LowerCaseRoute)route).Name : "No name";
                var row = FormatRow(isMatch, match, name, route.Url, defaults, constraints, dataTokens, values);
                sb.Append(row);
            }

            return sb.ToString();
        }