예제 #1
0
        public void SetUp()
        {
            var headers = new FormCollection {
                { "Referer", ExpectedRefererUrl }
            };

            MockRequest.Setup(r => r.Headers).Returns(headers);

            this._autoApprovalService = new Mock <IAutoApprovalService>();
            this._docTypeService      = new Mock <IDocTypeService>();
            this._subDocTypeService   = new Mock <ISubDocTypeService>();
            this._manCoService        = new Mock <IManCoService>();
            this._userService         = new Mock <IUserService>();
            this._logger = new Mock <ILogger>();

            this.SetUpVariables();

            _controller = new AutoApprovalController(
                this._autoApprovalService.Object,
                this._docTypeService.Object,
                this._subDocTypeService.Object,
                this._manCoService.Object,
                this._userService.Object,
                this._logger.Object);

            SetControllerContext(_controller);
        }
        public API_Moq_HttpContext setupNormalRequestValues()
        {
            var genericIdentity  = new GenericIdentity("genericIdentity");
            var genericPrincipal = new GenericPrincipal(genericIdentity, new string[] {});

            MockContext.Setup(context => context.User).Returns(genericPrincipal);
            MockContext.Setup(context => context.Cache).Returns(HttpRuntime.Cache);
            MockContext.Setup(context => context.Server.MapPath(It.IsAny <string>())).Returns((string path) => this.BaseDir.pathCombine(path));

            //Request
            MockRequest.Setup(request => request.InputStream).Returns(new MemoryStream());
            MockRequest.Setup(request => request.Headers).Returns(new NameValueCollection());
            MockRequest.Setup(request => request.QueryString).Returns(new NameValueCollection());
            MockRequest.Setup(request => request.Form).Returns(new NameValueCollection());

            //Response
            var outputStream = new MemoryStream();

            MockResponse.Setup(response => response.OutputStream).Returns(outputStream);

            //var writer = new StringWriter();
//			context.Expect(ctx => ctx.Response.Output).Returns(writer);

            MockResponse.Setup(response => response.Write(It.IsAny <string>())).Callback((string code) => outputStream.Write(code.asciiBytes(), 0, code.size()));
            var cache = new Mock <HttpCachePolicyBase>();

            MockResponse.SetupGet(response => response.Cache).Returns(cache.Object);
            return(this);
        }
예제 #3
0
        public void SetUp()
        {
            _syndicationFeedDomain = new Mock <ISyndicationFeedService>();
            MockRequest.Setup(r => r.Url).Returns(new Uri("http://foo.com/feed/rss"));
            var headers = new NameValueCollection();

            headers.Add("HOST", "localhost");
            MockRequest.Setup(r => r.Headers).Returns(headers);
            MockHttpContext.Setup(h => h.Request).Returns(MockRequest.Object);
        }
예제 #4
0
        public void GivenANotLoggdInUser_WhenILogout_TheUserIsRedirectedToTheHomePage()
        {
            var cookies = new HttpCookieCollection();

            MockRequest.Setup(r => r.Cookies).Returns(cookies);
            var result = _sessionController.Delete() as RedirectToRouteResult;

            Assert.That(result, Is.Not.Null);
            Assert.That(result.RouteValues["controller"], Is.EqualTo("Home").IgnoreCase);
            Assert.That(result.RouteValues["action"], Is.EqualTo("Index").IgnoreCase);
        }
예제 #5
0
        public void SetUp()
        {
            _postDomain = new Mock <IPostService>();
            _controller = new CommentController(_postDomain.Object, null);
            var headers = new FormCollection {
                { "Referer", ExpectedRefererUrl }
            };

            MockRequest.Setup(r => r.Headers).Returns(headers);

            SetControllerContext(_controller);
        }
예제 #6
0
        public void GivenALoggdInUser_WhenILogout_ThenTheCookieIsExpired()
        {
            var    cookies    = new HttpCookieCollection();
            string cookieName = "USER";

            cookies.Add(new HttpCookie(cookieName));
            MockRequest.Setup(r => r.Cookies).Returns(cookies);

            _controller.Logout();
            HttpCookie cookie = FakeResponse.Cookies[GetCookieUserFilterAttribute.UserCookieName];

            Assert.That(cookie.Expires, Is.EqualTo(new DateTime(1970, 1, 1)));
        }
예제 #7
0
        public HttpContextMoq SetupNormalRequestValues()
        {
            var MockUser     = new Mock <IPrincipal>();
            var MockIdentity = new Mock <IIdentity>();

            MockContext.Setup(context => context.User).Returns(MockUser.Object);
            MockUser.Setup(context => context.Identity).Returns(MockIdentity.Object);

            MockRequest.Setup(request => request.Url).Returns(new Uri("http://localhost/"));
            MockRequest.Setup(request => request.PathInfo).Returns(string.Empty);
            MockRequest.Setup(request => request.ServerVariables).Returns(new NameValueCollection());

            return(this);
        }
        public void SetUp()
        {
            var headers = new FormCollection {
                { "Referer", ExpectedRefererUrl }
            };

            MockRequest.Setup(r => r.Headers).Returns(headers);

            _documentService = new Mock <IDocumentService>();
            _userService     = new Mock <IUserService>();
            _manCoService    = new Mock <IManCoService>();
            _logger          = new Mock <ILogger>();

            _documentService.Setup(d => d.GetDocument(It.IsAny <string>())).Returns(new Document());
        }
예제 #9
0
 private void SetMockRequestServerVariables(string userHostAddress)
 {
     //{ "SERVER_NAME", "localhost" },
     //{ "SCRIPT_NAME", "localhost" },
     //{ "SERVER_PORT", "80" },
     //{ "HTTPS", "www.melaos.com" },
     MockRequest.Setup(r => r.Object.ServerVariables).Returns(new NameValueCollection
     {
         // custom
         { "REMOTE_ADDR", userHostAddress },
         { "REMOTE_HOST", userHostAddress },          // default ip location
         { "HTTP_X_FORWARDED_FOR", userHostAddress }, // behind proxy or router ip location
         { "HTTP_FORWARDED", userHostAddress }        // behind proxy or router ip location
     });
 }
예제 #10
0
        public void SetUp()
        {
            _applicationDomain = new Mock <IApplicationService>();
            _indexService      = new Mock <IIndexService>();
            _logger            = new Mock <ILogger>();

            _controller = new IndexController(_applicationDomain.Object, _indexService.Object, _logger.Object);
            var headers = new FormCollection {
                { "Referer", ExpectedRefererUrl }
            };

            MockRequest.Setup(r => r.Headers).Returns(headers);

            _indexService.Setup(r => r.GetIndex(It.IsAny <int>())).Returns(new IndexDefinition());

            SetControllerContext(_controller);
        }
예제 #11
0
        public API_Moq_HttpContext setupNormalRequestValues()
        {
            var genericIdentity  = new GenericIdentity("genericIdentity");
            var genericPrincipal = new GenericPrincipal(genericIdentity, new string[] {});

            MockContext.Setup(context => context.User).Returns(genericPrincipal);
            MockContext.Setup(context => context.Cache).Returns(HttpRuntime.Cache);

            //Request
            MockRequest.Setup(request => request.InputStream).Returns(new MemoryStream());
            MockRequest.Setup(request => request.Cookies).Returns(new HttpCookieCollection());
            MockRequest.Setup(request => request.Headers).Returns(new NameValueCollection());
            MockRequest.Setup(request => request.QueryString).Returns(new NameValueCollection());
            MockRequest.Setup(request => request.Form).Returns(new NameValueCollection());
            MockRequest.Setup(request => request.ServerVariables).Returns(new NameValueCollection());

            MockRequest.Setup(request => request.ContentType).Returns("");
            MockRequest.Setup(request => request.Url).Returns(() => RequestUrl);
            MockRequest.Setup(request => request.IsLocal).Returns(() => RequestUrl.Host == "localhost" || RequestUrl.Host == "127.0.0.1");
            MockRequest.Setup(request => request.IsSecureConnection).Returns(() => RequestUrl.Scheme.lower() == "https");


            //Response
            var outputStream   = new MemoryStream();
            var redirectTarget = "";

            MockResponse.SetupGet(response => response.Cache).Returns(new Mock <HttpCachePolicyBase>().Object);
            MockResponse.Setup(response => response.Cookies).Returns(new HttpCookieCollection());
            MockResponse.Setup(response => response.Headers).Returns(new NameValueCollection());
            MockResponse.Setup(response => response.OutputStream).Returns(outputStream);
            MockResponse.Setup(response => response.Write(It.IsAny <string>())).Callback((string code) => outputStream.Write(code.asciiBytes(), 0, code.size()));
            MockResponse.Setup(response => response.AddHeader(It.IsAny <string>(), It.IsAny <string>())).Callback((string name, string value) => MockResponse.Object.Headers.Add(name, value));
            MockResponse.Setup(response => response.Redirect(It.IsAny <string>())).Callback((string target) => { redirectTarget = target; throw new Exception("Thread was being aborted."); });

            MockResponse.Setup(response => response.IsRequestBeingRedirected).Returns(() => redirectTarget.valid());
            MockResponse.Setup(response => response.RedirectLocation).Returns(() => redirectTarget);

            //Server
            MockServer.Setup(server => server.MapPath(It.IsAny <string>())).Returns((string path) => BaseDir.pathCombine(path));
            MockServer.Setup(server => server.Transfer(It.IsAny <string>())).Callback((string target) => { redirectTarget = target; throw new Exception("Thread was being aborted."); });                                        // use the redirectTarget to hold this value
            MockServer.Setup(server => server.Transfer(It.IsAny <string>(), It.IsAny <bool>())).Callback((string target, bool preserveForm) => { redirectTarget = target; throw new Exception("Thread was being aborted."); });  // use the redirectTarget to hold this value
            //var writer = new StringWriter();
            //context.Expect(ctx => ctx.Response.Output).Returns(writer);
            return(this);
        }
예제 #12
0
        public void GivenALoggdInUser_WhenILogout_ThenTheUserIsRemovedFromTheContext()
        {
            var    cookies    = new HttpCookieCollection();
            string cookieName = "USER";

            // Add response cookies
            FakeResponse.Cookies.Add(new HttpCookie(cookieName));
            Assert.That(FakeResponse.Cookies.Count, Is.EqualTo(1));

            // Add request cookies
            cookies.Add(new HttpCookie(cookieName));
            MockRequest.Setup(r => r.Cookies).Returns(cookies);

            MockHttpContext.SetupProperty(h => h.User);
            _sessionController.HttpContext.User = new UserViewModel();

            Assert.That(_sessionController.HttpContext.User, Is.Not.Null);
            var result = _sessionController.Delete() as RedirectToRouteResult;

            Assert.That(result, Is.Not.Null);
            Assert.That(_sessionController.HttpContext.User, Is.Null);
        }
예제 #13
0
        public void SetUp()
        {
            var headers = new FormCollection {
                { "Referer", ExpectedRefererUrl }
            };

            MockRequest.Setup(r => r.Headers).Returns(headers);

            _appManCoEmailService = new Mock <IAppManCoEmailService>();
            _applicationService   = new Mock <IApplicationService>();
            _manCoService         = new Mock <IManCoService>();
            _docTypeService       = new Mock <IDocTypeService>();
            _userService          = new Mock <IUserService>();
            _logger = new Mock <ILogger>();

            _controller = new OtfController(_appManCoEmailService.Object,
                                            _applicationService.Object,
                                            _manCoService.Object,
                                            _docTypeService.Object,
                                            _userService.Object,
                                            _logger.Object);

            SetControllerContext(_controller);
        }
예제 #14
0
 private void SetMockRequestUserHostAddress(string userHostAddress)
 {
     MockRequest.Setup(r => r.Object.UserHostAddress).Returns(userHostAddress); // custom
 }
예제 #15
0
 private void SetMockRequestRequestType(HttpVerbs verb)
 {
     MockRequest.Setup(y => y.Object.RequestType).Returns(verb == HttpVerbs.Get ? "GET" : "POST"); // custom
 }
예제 #16
0
 private void SetMockRequestCookies(HttpCookieCollection cookies)
 {
     MockRequest.Setup(x => x.Object.Cookies).Returns(cookies); // custom
 }
예제 #17
0
 private void SetMockRequestForm(NameValueCollection formData)
 {
     MockRequest.Setup(r => r.Object.Form).Returns(formData); // custom
 }
예제 #18
0
        public MockHttpContextNewContainer(HttpVerbs verb, HttpCookieCollection cookies, string userHostAddress, string cookieNameToSet)
        {
            // Instantiate variables
            cookies = cookies ?? new HttpCookieCollection();
            NameValueCollection formData = new NameValueCollection();
            Hashtable           items    = new Hashtable();

            InitMocksOfMocks();

            HttpContext context = HttpContext(userHostAddress: userHostAddress);

            // --------------------------Setup Mock of Mocks

            CreateMockContext(context);

            //CreateMockContextSession();

            CreateMockUserIdentity(context);

            //MockRequest.Setup(r => r.Object).Returns(new HttpRequestWrapper(context.Request));
            HttpRequestBase request = new HttpRequestWrapper(context.Request);

            SetMockRequestUserHostAddress(userHostAddress);

            SetMockRequestRequestType(verb);

            SetMockRequestServerVariables(userHostAddress);

            SetMockRequestCookies(cookies);

            SetMockRequestForm(formData);

            MockRequest.Setup(r => r.Object.TotalBytes).Returns(request.TotalBytes);
            MockRequest.Setup(r => r.Object.Unvalidated).Returns(request.Unvalidated);
            MockRequest.Setup(r => r.Object.Url).Returns(request.Url);
            MockRequest.Setup(r => r.Object.UrlReferrer).Returns(request.UrlReferrer);
            MockRequest.Setup(r => r.Object.UserAgent).Returns(request.UserAgent);
            MockRequest.Setup(r => r.Object.UserHostName).Returns(request.UserHostName);
            MockRequest.Setup(r => r.Object.UserLanguages).Returns(request.UserLanguages);
            MockRequest.Setup(r => r.Object.AcceptTypes).Returns(request.AcceptTypes);
            MockRequest.Setup(r => r.Object.AnonymousID).Returns(request.AnonymousID);
            MockRequest.Setup(r => r.Object.ApplicationPath).Returns(request.ApplicationPath);
            MockRequest.Setup(r => r.Object.ClientCertificate).Returns(request.ClientCertificate);
            MockRequest.Setup(r => r.Object.ContentLength).Returns(request.ContentLength);
            MockRequest.Setup(r => r.Object.ContentType).Returns(request.ContentType);
            MockRequest.Setup(r => r.Object.CurrentExecutionFilePath).Returns(request.CurrentExecutionFilePath);
            MockRequest.Setup(r => r.Object.CurrentExecutionFilePathExtension).Returns(request.CurrentExecutionFilePathExtension);
            MockRequest.Setup(r => r.Object.FilePath).Returns(request.FilePath);
            MockRequest.Setup(r => r.Object.Files).Returns(request.Files);
            MockRequest.Setup(r => r.Object.Filter).Returns(request.Filter);
            MockRequest.Setup(r => r.Object.Headers).Returns(request.Headers);
            MockRequest.Setup(r => r.Object.HttpMethod).Returns(request.HttpMethod);
            MockRequest.Setup(r => r.Object.InputStream).Returns(request.InputStream);
            MockRequest.Setup(r => r.Object.IsAuthenticated).Returns(request.IsAuthenticated);
            MockRequest.Setup(r => r.Object.IsLocal).Returns(request.IsLocal);
            MockRequest.Setup(r => r.Object.IsSecureConnection).Returns(request.IsSecureConnection);
            MockRequest.Setup(r => r.Object.LogonUserIdentity).Returns(request.LogonUserIdentity);
            MockRequest.Setup(r => r.Object.Params).Returns(request.Params);
            MockRequest.Setup(r => r.Object.Path).Returns(request.Path);
            MockRequest.Setup(r => r.Object.PathInfo).Returns(request.PathInfo);
            MockRequest.Setup(r => r.Object.PhysicalPath).Returns(request.PhysicalPath);
            MockRequest.Setup(r => r.Object.QueryString).Returns(request.QueryString);
            MockRequest.Setup(r => r.Object.RawUrl).Returns(request.RawUrl);
            MockRequest.Setup(r => r.Object.ReadEntityBodyMode).Returns(request.ReadEntityBodyMode);
            MockRequest.Setup(r => r.Object.RequestContext).Returns(request.RequestContext);
            MockRequest.Setup(r => r.Object.TimedOutToken).Returns(request.TimedOutToken);

            //if (request.AppRelativeCurrentExecutionFilePath != null)
            //{
            //    MockRequest.Setup(r => r.Object.AppRelativeCurrentExecutionFilePath).Returns(
            //        request.AppRelativeCurrentExecutionFilePath); // potential null ref
            //}

            //if (request.Browser != null)
            //{
            //    MockRequest.Setup(r => r.Object.Browser).Returns(request.Browser);
            //}

            //MockRequest.Setup(r => r.Object.ContentEncoding).Returns(request.ContentEncoding);
            //MockRequest.Setup(r => r.Object.HttpChannelBinding).Returns(request.HttpChannelBinding);
            //MockRequest.Setup(r => r.Object.PhysicalApplicationPath).Returns(request.PhysicalApplicationPath);


            MockResponse.Setup(r => r.Object).Returns(new HttpResponseWrapper(context.Response));

            MockResponse.Setup(r => r.Object.Cookies).Returns(cookies);

            SetMockResponseCookie(cookies, cookieNameToSet);

            MockSessionState.Setup(ss => ss.Object).Returns(new HttpSessionStateWrapper(context.Session));
            //MockSessionState.Setup(s => s.Object.SessionID).Returns(Guid.NewGuid().ToString());

            MockServerUtility.Setup(su => su.Object).Returns(new HttpServerUtilityWrapper(context.Server));

            MockApplication.Setup(a => a.Object).Returns(new HttpApplicationStateWrapper(context.Application));

            SetMocksFromMocksofMocks();
        }