public void ShouldCallSetBackgroundColorOnlyOnceWithNestedCallsToOnAndOff()
        {
            // GIVEN
            var domContainer = new Mock<DomContainer>().Object;
            var nativeElementMock = new Mock<INativeElement>();
            var element = new Element(domContainer, nativeElementMock.Object);

            Settings.HighLightColor = "myTestColor";
            var highLight = new HighlightAction(element);

            nativeElementMock.Expect(nativeElement => nativeElement.IsElementReferenceStillValid()).Returns(true);
            nativeElementMock.Expect(nativeElement => nativeElement.GetStyleAttributeValue("backgroundColor")).Returns("initialColor").AtMostOnce();
            nativeElementMock.Expect(nativeElement => nativeElement.SetStyleAttributeValue("backgroundColor", "myTestColor")).AtMostOnce();
            nativeElementMock.Expect(nativeElement => nativeElement.SetStyleAttributeValue("backgroundColor", "initialColor")).AtMostOnce();

            // WHEN
            highLight.On();
            highLight.On();
            highLight.On();
            highLight.Off();
            highLight.Off();
            highLight.Off();

            // THEN
            nativeElementMock.VerifyAll();
        }
Ejemplo n.º 2
0
        private static HtmlHelper GetFormHelper(out StringWriter writer) {
            Mock<HttpRequestBase> mockHttpRequest = new Mock<HttpRequestBase>();
            mockHttpRequest.Expect(r => r.Url).Returns(new Uri("http://www.contoso.com/some/path"));
            Mock<HttpResponseBase> mockHttpResponse = new Mock<HttpResponseBase>(MockBehavior.Strict);

            mockHttpResponse.Expect(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => AppPathModifier + r);
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Expect(c => c.Request).Returns(mockHttpRequest.Object);
            mockHttpContext.Expect(c => c.Response).Returns(mockHttpResponse.Object);
            RouteCollection rt = new RouteCollection();
            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            RouteData rd = new RouteData();
            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");

            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
            mockViewContext.Expect(c => c.HttpContext).Returns(mockHttpContext.Object);
            mockViewContext.Expect(c => c.RouteData).Returns(rd);
            writer = new StringWriter();
            mockViewContext.Expect(c => c.Writer).Returns(writer);

            HtmlHelper helper = new HtmlHelper(
                mockViewContext.Object,
                new Mock<IViewDataContainer>().Object,
                rt);
            return helper;
        }
        public void ProcessRequestAddsServerHeaderCallsExecute() {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>();
            responseMock.Expect(r => r.AppendHeader(MvcHandler.MvcVersionHeaderName, "1.0")).Verifiable();
            contextMock.Expect(c => c.Response).Returns(responseMock.Object);

            RouteData rd = new RouteData();
            rd.Values.Add("controller", "foo");
            RequestContext requestContext = new RequestContext(contextMock.Object, rd);
            MvcHandler mvcHandler = new MvcHandler(requestContext);

            Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
            controllerMock.Protected().Expect("Execute", requestContext).Verifiable();

            ControllerBuilder cb = new ControllerBuilder();
            Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
            controllerFactoryMock.Expect(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
            controllerFactoryMock.Expect(o => o.ReleaseController(controllerMock.Object));
            cb.SetControllerFactory(controllerFactoryMock.Object);
            mvcHandler.ControllerBuilder = cb;

            // Act
            mvcHandler.ProcessRequest(contextMock.Object);

            // Assert
            responseMock.Verify();
            controllerMock.Verify();
        }
        public void Setup() {
            route = new Mock<RouteBase>();
            route.Expect(r => r.GetVirtualPath(It.IsAny<RequestContext>(), It.IsAny<RouteValueDictionary>()))
                 .Returns(() => virtualPathData);

            virtualPathData = new VirtualPathData(route.Object, "~/VirtualPath");

            routes = new RouteCollection();
            routes.Add(route.Object);

            originalRouteData = new RouteData();

            string returnValue = "";
            httpContext = new Mock<HttpContextBase>();
            httpContext.Expect(hc => hc.Request.ApplicationPath).Returns("~");
            httpContext.Expect(hc => hc.Response.ApplyAppPathModifier(It.IsAny<string>()))
                       .Callback<string>(s => returnValue = s)
                       .Returns(() => returnValue);
            httpContext.Expect(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()));

            viewContext = new ViewContext {
                RequestContext = new RequestContext(httpContext.Object, originalRouteData)
            };

            viewDataContainer = new Mock<IViewDataContainer>();

            htmlHelper = new Mock<HtmlHelper>(viewContext, viewDataContainer.Object, routes);
        }
Ejemplo n.º 5
0
        public void BindModel() {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext() {
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ModelMetadata = GetMetadataForObject(new Person()),
                ModelName = "someName"
            };

            Mock<IExtensibleModelBinder> mockDtoBinder = new Mock<IExtensibleModelBinder>();
            mockDtoBinder
                .Expect(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc2) {
                        return true; // just return the DTO unchanged
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(ComplexModelDto), mockDtoBinder.Object, true /* suppressPrefixCheck */);

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder>() { CallBase = true };
            mockTestableBinder.Expect(o => o.EnsureModelPublic(controllerContext, bindingContext)).Verifiable();
            mockTestableBinder.Expect(o => o.GetMetadataForPropertiesPublic(controllerContext, bindingContext)).Returns(new ModelMetadata[0]).Verifiable();
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;
            testableBinder.MetadataProvider = new DataAnnotationsModelMetadataProvider();

            // Act
            bool retValue = testableBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.IsTrue(retValue);
            Assert.IsInstanceOfType(bindingContext.Model, typeof(Person));
            Assert.IsTrue(bindingContext.ValidationNode.ValidateAllProperties);
            mockTestableBinder.Verify();
        }
Ejemplo n.º 6
0
        public static HttpContextBase FakeHttpContext() {

            var context = new Mock<HttpContextBase>();
            var request = new Mock<HttpRequestBase>();
            var response = new Mock<HttpResponseBase>();
            var session = new Mock<HttpSessionStateBase>();
            var server = new Mock<HttpServerUtilityBase>();

            context.Expect(ctx => ctx.Request).Returns(request.Object);
            context.Expect(ctx => ctx.Response).Returns(response.Object);
            context.Expect(ctx => ctx.Session).Returns(session.Object);
            context.Expect(ctx => ctx.Server).Returns(server.Object);


            var form = new NameValueCollection();
            var querystring = new NameValueCollection();
            var cookies = new HttpCookieCollection();
            var user = new GenericPrincipal(new GenericIdentity("testuser"),new string[]{"Administrator"});
            
            request.Expect(r => r.Cookies).Returns(cookies);
            request.Expect(r => r.Form).Returns(form);
            request.Expect(q => q.QueryString).Returns(querystring);
            context.Expect(u => u.User).Returns(user);
            return context.Object;
        }
 public UserLogin_Steps()
 {
     var mock = new Mock<IAuthenticationService>();
     mock.Expect(x => x.IsValidLogin("admin", "password")).Returns(true);
     mock.Expect(x => x.IsValidLogin(It.IsAny<string>(),It.IsAny<string>())).Returns(false);
     _authService = mock.Object;
 }
Ejemplo n.º 8
0
        public void ProcessRequestWithNormalControlFlowForAsynchronousController() {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.ExpectMvcVersionResponseHeader().Verifiable();

            RequestContext requestContext = new RequestContext(mockHttpContext.Object, GetRouteData());
            MvcAsyncHandler handler = new MvcAsyncHandler(requestContext);

            MockAsyncResult asyncResult = new MockAsyncResult();
            Mock<IAsyncController> mockController = new Mock<IAsyncController>();
            mockController.Expect(c => c.BeginExecute(requestContext, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(asyncResult).Verifiable();
            mockController.Expect(c => c.EndExecute(asyncResult)).Verifiable();
            mockController.As<IDisposable>().Expect(c => c.Dispose()).AtMostOnce().Verifiable();

            ControllerBuilder builder = new ControllerBuilder();
            builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
            handler.ControllerBuilder = builder;

            // Act
            IAsyncResult returnedAsyncResult = handler.BeginProcessRequest(mockHttpContext.Object, null, null);
            handler.EndProcessRequest(returnedAsyncResult);

            mockHttpContext.Verify();
            mockController.Verify();
        }
Ejemplo n.º 9
0
        public void ExecuteCoreWithAsynchronousInvokerAndActionCompletesSuccessfully() {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            MockAsyncResult asyncResult = new MockAsyncResult();

            Mock<ITempDataProvider> mockTempDataProvider = new Mock<ITempDataProvider>();
            mockTempDataProvider.Expect(p => p.LoadTempData(controllerContext)).Returns(new Dictionary<string, object>()).Verifiable();
            mockTempDataProvider.Expect(p => p.SaveTempData(controllerContext, It.IsAny<IDictionary<string, object>>())).AtMostOnce().Verifiable();

            Mock<IAsyncActionInvoker> mockInvoker = new Mock<IAsyncActionInvoker>();
            mockInvoker.Expect(i => i.BeginInvokeAction(controllerContext, "SomeAction", It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(asyncResult).Verifiable();
            mockInvoker.Expect(i => i.EndInvokeAction(asyncResult)).Returns(true).Verifiable();

            EmptyController controller = new EmptyController() {
                ControllerContext = controllerContext,
                TempDataProvider = mockTempDataProvider.Object,
                ActionInvoker = mockInvoker.Object
            };

            // Act
            IAsyncResult returnedAsyncResult = controller.BeginExecuteCore(null, null);
            controller.TempData["key"] = "value";
            controller.EndExecuteCore(returnedAsyncResult);

            // Assert
            mockInvoker.Verify();
            mockTempDataProvider.Verify();
        }
Ejemplo n.º 10
0
		private IHttpRequest ConfigureRequest(string path)
		{
			var request = new Mock<IHttpRequest>();
			request.Expect(x => x.QueryString).Returns(new NameValueCollection());
			request.Expect(x => x.PathInfo).Returns(path);

			return request.Object;
		}
        private static ControllerContext GetJsonEnabledControllerContext(string jsonString) {
            byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonString);
            MemoryStream jsonStream = new MemoryStream(jsonBytes);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Expect(o => o.HttpContext.Request.ContentType).Returns("application/json");
            mockControllerContext.Expect(o => o.HttpContext.Request.InputStream).Returns(jsonStream);
            return mockControllerContext.Object;
        }
Ejemplo n.º 12
0
        private IHttpRequest ConfigureRequest(string path)
        {
            var request = new Mock<IHttpRequest>();
            request.Expect(x => x.Items).Returns(new Dictionary<string, object>());
            request.Expect(x => x.QueryString).Returns(PclExportClient.Instance.NewNameValueCollection());
            request.Expect(x => x.PathInfo).Returns(path);

            return request.Object;
        }
Ejemplo n.º 13
0
        public static IUserAuthRepository GetStubRepo()
        {
            var mock = new Mock<IUserAuthRepository>();
            mock.Expect(x => x.GetUserAuthByUserName(It.IsAny<string>()))
                .Returns((UserAuth)null);
            mock.Expect(x => x.CreateUserAuth(It.IsAny<UserAuth>(), It.IsAny<string>()))
                .Returns(new UserAuth { Id = 1 });

            return mock.Object;
        }
        public void GetEndpointAttributes_AcceptsUserHostAddressFormats(string format, EndpointAttributes expected)
        {
            var handler = new TestHandler();
            var request = new Mock<IHttpRequest>();
            request.Expect(req => req.UserHostAddress).Returns(format);
            request.Expect(req => req.IsSecureConnection).Returns(false);
            request.Expect(req => req.HttpMethod).Returns("GET");

            Assert.AreEqual(expected | EndpointAttributes.HttpGet | EndpointAttributes.InSecure, request.Object.GetAttributes());
        }
        public void import_should_add_contacts_to_repository()
        {
            var userid = Guid.NewGuid();
            var username = "******";
            var contact1 = new Contact
                               {
                                   Email = "*****@*****.**",
                                   User = new User { UserId = userid }
                               };
            var contact2 = new Contact
                               {
                                   Email = "*****@*****.**",
                                   User = new User { UserId = userid }
                               };
            var contact3 = new Contact
                               {
                                   Email = "*****@*****.**",
                                   User = new User { UserId = userid }
                               };
            var contacts = new List<Contact>
               {
                   contact1,
                   contact2,
                   contact3
               };

            var mockRepo = new Mock<IContactRepository>();
            mockRepo.Expect(r => r.Add(contact1)).Returns(1);
            mockRepo.Expect(r => r.Add(contact2)).Returns(2);
            mockRepo.Expect(r => r.Add(contact3)).Returns(3);
            mockRepo.Expect(r => r.Get())
                .Returns((new List<Contact>()).AsQueryable());

            var mockRunner = new Mock<IValidationRunner>();
            mockRunner.Expect(v => v.Run(contact1))
                .Returns(new List<ValidationError>());
            mockRunner.Expect(v => v.Run(contact2))
                .Returns(new List<ValidationError>());
            mockRunner.Expect(v => v.Run(contact3))
                .Returns(new List<ValidationError>());

            var service = new InMemoryContactService(
                mockRepo.Object,
                mockRunner.Object);

            service.Import(new User
                               {
                                   UserId = userid,
                                   Username = username
                               }, contacts);

            mockRepo.VerifyAll();
            mockRunner.VerifyAll();
        }
Ejemplo n.º 16
0
        public void ShouldSelectConstructorWithMostResolvableParametersFromTypeImplementation()
        {
            var map = new Mock<IDependencyContainer>();
            map.Expect(m => m.Contains(It.IsAny<Dependency>())).Returns(true);
            map.Expect(m => m.Dependencies).Returns(new IDependency[] { });

            var expectedConstructor = typeof(Vehicle).GetConstructor(new Type[] { typeof(IPerson) });
            IImplementation<ConstructorInfo> implementation = new TransientType(typeof(Vehicle), map.Object, new ConstructorResolver());

            Assert.AreSame(implementation.Target, expectedConstructor);
        }
        public void SetUp()
        {
            Mock<IDbConnection> connectionMock = new Mock<IDbConnection>();
            connectionMock.Expect(x => x.ConnectionString).Returns("Server=myServerAddress;Database=myDataBase;Uid=myUsername;Pwd=myPassword;");
            connectionMock.Expect(x => x.State).Returns(ConnectionState.Closed);

            Mock<IConnectionProvider> providerMock;
            providerMock = new Mock<IConnectionProvider>();
            providerMock.Expect(x => x.CreateConnection()).Returns(connectionMock.Object);

            provider = providerMock.Object;
        }
        private static void SetupControllerForRenderAction(Controller controller) {
            var factory = new Mock<IControllerFactory>();
            var tempDataProvider = new Mock<ITempDataProvider>();
            controller.TempDataProvider = tempDataProvider.Object;
            tempDataProvider.Expect(provider => provider.LoadTempData(controller.ControllerContext)).Returns(new Dictionary<string, object>());
            tempDataProvider.Expect(provider => provider.SaveTempData(controller.ControllerContext, It.IsAny<IDictionary<string, object>>()));

            factory.Expect(f => f.CreateController(It.IsAny<RequestContext>(), It.IsAny<string>())).Returns(controller);
            factory.Expect(f => f.ReleaseController(It.IsAny<ControllerBase>()));

            ControllerBuilder.Current.SetControllerFactory(factory.Object);
        }
Ejemplo n.º 19
0
		private static void AssertLowerCaseUpperCase(Mock<INativeElement> elementMock) 
		{
			// LowerCase
			elementMock.Expect(element => element.TagName).Returns("input");
            elementMock.Expect(element => element.GetAttributeValue("type")).Returns("image");

			// UpperCase
			var elementTag = new ElementTag("INPUT", "IMAGE");
			Assert.IsTrue(elementTag.IsMatch(elementMock.Object), "Compare should compare using CultureInvariant");

            elementMock.VerifyAll();
		}
        public void SetUp()
        {
            Mock<IDbConnection> connectionMock = new Mock<IDbConnection>();
            connectionMock.Expect(x => x.ConnectionString).Returns("Data Source=myServerAddress;Initial Catalog=myDataBase;Integrated Security=SSPI;");
            connectionMock.Expect(x => x.State).Returns(ConnectionState.Closed);

            Mock<IConnectionProvider> providerMock;
            providerMock = new Mock<IConnectionProvider>();
            providerMock.Expect(x => x.CreateConnection()).Returns(connectionMock.Object);

            provider = providerMock.Object;
        }
        public void CreateControllerCanReturnNull() {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            Mock<DefaultControllerFactory> factoryMock = new Mock<DefaultControllerFactory>();
            factoryMock.Expect(o => o.GetControllerType(requestContext, "moo")).Returns(typeof(DummyController));
            factoryMock.Expect(o => o.GetControllerInstance(requestContext, typeof(DummyController))).Returns((ControllerBase)null);

            // Act
            IController controller = ((IControllerFactory)factoryMock.Object).CreateController(requestContext, "moo");

            // Assert
            Assert.IsNull(controller, "It should be OK for CreateController to return null");
        }
        public void HttpContextProperty() {
            var c = new EmptyController();
            Assert.IsNull(c.HttpContext, "Property should be null before Context is set");

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Expect(cc => cc.Controller).Returns(c);
            mockControllerContext.Expect(cc => cc.HttpContext).Returns(mockHttpContext.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.AreEqual<HttpContextBase>(mockHttpContext.Object, c.HttpContext, "Property should equal the value on the Context.");
        }
Ejemplo n.º 23
0
        public void AuthorizeCoreReturnsFalseIfNameDoesNotMatch() {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper() { Users = "SomeName" };

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Expect(c => c.User.Identity.IsAuthenticated).Returns(true);
            mockHttpContext.Expect(c => c.User.Identity.Name).Returns("SomeOtherName");

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.IsFalse(retVal);
        }
Ejemplo n.º 24
0
        public void TryGetDefaultValue_FirstChecksRawDefaultValue() {
            // Arrange
            Mock<ParameterInfo> mockPInfo = new Mock<ParameterInfo>() { DefaultValue = DefaultValue.Mock };
            mockPInfo.Expect(p => p.RawDefaultValue).Returns(42);
            mockPInfo.Expect(p => p.Name).Returns("someParameter");

            // Act
            object defaultValue;
            bool retVal = ParameterInfoUtil.TryGetDefaultValue(mockPInfo.Object, out defaultValue);

            // Assert
            Assert.IsTrue(retVal);
            Assert.AreEqual(42, defaultValue);
        }
        public void GetValueProvider_NoJsonBody_ReturnsNull() {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Expect(o => o.HttpContext.Request.ContentType).Returns("application/json");
            mockControllerContext.Expect(o => o.HttpContext.Request.InputStream).Returns(new MemoryStream());

            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.IsNull(valueProvider);
        }
        public void GetCustomAttributesCallsParameterInfoGetCustomAttributes() {
            // Arrange
            object[] expected = new object[0];
            Mock<ParameterInfo> mockParameter = new Mock<ParameterInfo>();
            mockParameter.Expect(pi => pi.Member).Returns(new Mock<MemberInfo>().Object);
            mockParameter.Expect(pi => pi.GetCustomAttributes(true)).Returns(expected);
            ReflectedParameterDescriptor pd = GetParameterDescriptor(mockParameter.Object);

            // Act
            object[] returned = pd.GetCustomAttributes(true);

            // Assert
            Assert.AreSame(expected, returned);
        }
        public void ThrowsIfNotChildRequest() {
            // Arrange
            ChildActionOnlyAttribute attr = new ChildActionOnlyAttribute();
            Mock<AuthorizationContext> context = new Mock<AuthorizationContext>();
            context.Expect(c => c.IsChildAction).Returns(false);
            context.Expect(c => c.ActionDescriptor.ActionName).Returns("some name");

            // Act & assert
            ExceptionHelper.ExpectInvalidOperationException(
                delegate {
                    attr.OnAuthorization(context.Object);
                },
                @"The action 'some name' is accessible only by a child request.");
        }
        public void DefaultValuePropertyIsReadFirstFromParameterInfoRawDefaultValue() {
            // Arrange
            Mock<ParameterInfo> mockPInfo = new Mock<ParameterInfo>() { DefaultValue = DefaultValue.Mock };
            mockPInfo.Expect(p => p.RawDefaultValue).Returns(42);
            mockPInfo.Expect(p => p.Name).Returns("someParameter");

            ReflectedParameterDescriptor pd = GetParameterDescriptor(mockPInfo.Object);

            // Act
            object defaultValue = pd.DefaultValue;

            // Assert
            Assert.AreEqual(42, defaultValue);
        }
Ejemplo n.º 29
0
        public void EmptyViewNameUsesActionNameAsViewName()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            PartialViewResult result = new PartialViewResultHelper { ViewEngineCollection = viewEngineCollection.Object };
            viewEngine
                .Expect(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName, It.IsAny<bool>()))
                .Callback<ControllerContext, string>(
                    (controllerContext, viewName) => {
                        Assert.AreSame(httpContext, controllerContext.HttpContext);
                        Assert.AreSame(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngineCollection
                .Expect(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName))
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            view
                .Expect(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) => {
                        Assert.AreSame(view.Object, viewContext.View);
                        Assert.AreSame(result.ViewData, viewContext.ViewData);
                        Assert.AreSame(result.TempData, viewContext.TempData);
                        Assert.AreSame(controller, viewContext.Controller);
                    });
            viewEngine
                .Expect(e => e.ReleaseView(context, It.IsAny<IView>()))
                .Callback<ControllerContext, IView>(
                    (controllerContext, releasedView) => {
                        Assert.AreSame(releasedView, view.Object);
                    });

            // Act
            result.ExecuteResult(context);

            // Assert
            viewEngine.Verify();
            viewEngineCollection.Verify();
            view.Verify();
        }
Ejemplo n.º 30
0
        public void AuthorizeCoreReturnsFalseIfRoleDoesNotMatch() {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper() { Roles = "SomeRole" };

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Expect(c => c.User.Identity.IsAuthenticated).Returns(true);
            mockHttpContext.Expect(c => c.User.IsInRole("SomeRole")).Returns(false).Verifiable();

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.IsFalse(retVal);
            mockHttpContext.Verify();
        }
        public void BeginProcessRequest_ForwardsCall()
        {
            // Arrange
            HttpContext   httpContext = new HttpContext(new SimpleWorkerRequest("/", "/", "Page", "Query", TextWriter.Null));
            AsyncCallback callback    = ar => { };
            object        extraData   = new object();
            IAsyncResult  asyncResult = new Mock <IAsyncResult>().Object;

            Mock <IHttpAsyncHandler> mockHandler = new Mock <IHttpAsyncHandler>();

            mockHandler.Expect(o => o.BeginProcessRequest(httpContext, callback, extraData)).Returns(asyncResult);

            MvcDynamicSessionHandler handler = new MvcDynamicSessionHandler(mockHandler.Object);

            // Act
            IAsyncResult retVal = handler.BeginProcessRequest(httpContext, callback, extraData);

            // Assert
            Assert.AreEqual(asyncResult, retVal);
        }
        public void GetControllerInstanceWithBadConstructorThrows()
        {
            // Arrange
            Mock <DefaultControllerFactory> factoryMock = new Mock <DefaultControllerFactory>();

            factoryMock.CallBase = true;
            factoryMock.Expect(o => o.GetControllerType("moo")).Returns(typeof(DummyControllerThrows));
            Mock <HttpContextBase> contextMock = new Mock <HttpContextBase>();

            // Act
            Exception ex = ExceptionHelper.ExpectException <InvalidOperationException>(
                delegate {
                ((IControllerFactory)factoryMock.Object).CreateController(
                    new RequestContext(contextMock.Object, new RouteData()),
                    "moo");
            },
                "An error occurred while creating a controller of type 'System.Web.Mvc.Test.DefaultControllerFactoryTest+DummyControllerThrows'. If the controller doesn't have a controller factory, ensure that it has a parameterless public constructor.");

            Assert.AreEqual <string>("constructor", ex.InnerException.InnerException.Message);
        }
Ejemplo n.º 33
0
        public void TextboxForWithExpressionRendersInputTagUsingExpressionUsingValueFromModelState()
        {
            // Arrange
            Mock <ViewContext> mockViewContext = new Mock <ViewContext>();
            ViewDataDictionary viewData        = new ViewDataDictionary(new Product {
                ProductName = "ASP.NET MVC"
            });

            viewData.ModelState.SetModelValue("ProductName", new ValueProviderResult("Something Else", "Something Else", CultureInfo.InvariantCulture));
            Mock <IViewDataContainer> mockIViewDataContainer = new Mock <IViewDataContainer>();

            mockIViewDataContainer.Expect(c => c.ViewData).Returns(viewData);
            HtmlHelper <Product> htmlHelper = new HtmlHelper <Product>(mockViewContext.Object, mockIViewDataContainer.Object);

            // Act
            string result = htmlHelper.TextBoxFor(p => p.ProductName);

            // Assert
            Assert.AreEqual("<input id=\"ProductName\" name=\"ProductName\" type=\"text\" value=\"Something Else\" />", result);
        }
Ejemplo n.º 34
0
        public void GetValueProvider()
        {
            // Arrange
            FormValueProviderFactory factory = new FormValueProviderFactory();

            Mock <ControllerContext> mockControllerContext = new Mock <ControllerContext>();

            mockControllerContext.Expect(o => o.HttpContext.Request.Form).Returns(_backingStore);

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.AreEqual(typeof(FormValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("foo");

            Assert.IsNotNull(vpResult, "Should have contained a value for key 'foo'.");
            Assert.AreEqual("fooValue", vpResult.AttemptedValue);
            Assert.AreEqual(CultureInfo.CurrentCulture, vpResult.Culture);
        }
        public void CreateCachedController_UnderlyingFactoryReturnsController()
        {
            // Arrange
            RequestContext  requestContext = GetRequestContext();
            EmptyController controller     = new EmptyController();

            Mock <IControllerFactory> mockUnderlyingFactory = new Mock <IControllerFactory>();

            mockUnderlyingFactory.Expect(o => o.CreateController(requestContext, "home")).Returns(controller).AtMostOnce();
            MvcDynamicSessionControllerFactory factory = new MvcDynamicSessionControllerFactory(mockUnderlyingFactory.Object);

            // Act
            IController controller1 = factory.CreateCachedController(requestContext, "home");
            IController controller2 = factory.CreateController(requestContext, "home");

            // Assert
            Assert.AreEqual(controller, controller1);
            Assert.AreSame(controller1, controller2);
            mockUnderlyingFactory.Verify();
        }
Ejemplo n.º 36
0
        public void OnAuthorizationDoesNothingIfRequestIsSecure()
        {
            // Arrange
            Mock <AuthorizationContext> mockAuthContext = new Mock <AuthorizationContext>();

            mockAuthContext.Expect(c => c.HttpContext.Request.IsSecureConnection).Returns(true);
            AuthorizationContext authContext = mockAuthContext.Object;

            ViewResult result = new ViewResult();

            authContext.Result = result;

            RequireHttpsAttribute attr = new RequireHttpsAttribute();

            // Act
            attr.OnAuthorization(authContext);

            // Assert
            Assert.AreSame(result, authContext.Result, "Result should not have been changed.");
        }
Ejemplo n.º 37
0
        private static HttpContextBase GetHttpContext(string appPath, Mock <HttpResponseBase> mockResponse)
        {
            Mock <HttpContextBase> mockContext = new Mock <HttpContextBase>();
            Mock <HttpRequestBase> mockRequest = new Mock <HttpRequestBase>();

            if (!String.IsNullOrEmpty(appPath))
            {
                mockRequest.Expect(o => o.ApplicationPath).Returns(appPath);
            }
            mockRequest.Expect(o => o.Url).Returns(new Uri("http://foo.bar.baz"));
            mockRequest.Expect(o => o.RawUrl).Returns("/rawUrl");
            mockRequest.Expect(o => o.PathInfo).Returns(String.Empty);
            mockContext.Expect(o => o.Request).Returns(mockRequest.Object);
            mockContext.Expect(o => o.Session).Returns((HttpSessionStateBase)null);

            mockResponse.Expect(o => o.ApplyAppPathModifier(It.IsAny <string>())).Returns <string>(r => HtmlHelperTest.AppPathModifier + r);
            mockContext.Expect(o => o.Response).Returns(mockResponse.Object);

            return(mockContext.Object);
        }
Ejemplo n.º 38
0
        public void ExecuteCallsMethodInfoOnSuccess()
        {
            // Arrange
            Mock <ControllerContext> mockControllerContext = new Mock <ControllerContext>();

            mockControllerContext.Expect(c => c.Controller).Returns(new ConcatController());
            Dictionary <string, object> parameters = new Dictionary <string, object>()
            {
                { "a", "hello " },
                { "b", "world" }
            };

            ReflectedActionDescriptor ad = GetActionDescriptor(typeof(ConcatController).GetMethod("Concat"));

            // Act
            object result = ad.Execute(mockControllerContext.Object, parameters);

            // Assert
            Assert.AreEqual("hello world", result);
        }
Ejemplo n.º 39
0
        public void ElementRefresh()
        {
            var finderMock        = new ElementFinderMock();
            var nativeElementMock = new Mock <INativeElement>();
            var domContainer      = new Mock <DomContainer>(new object[] { });

            finderMock.FindAllElements = () => new List <Element> {
                new Element(domContainer.Object, nativeElementMock.Object)
            };
            nativeElementMock.Expect(native => native.TagName).Returns("mockedtag");

            element = new Element(domContainer.Object, finderMock);

            Assert.AreEqual("mockedtag", element.TagName);

            element.Refresh();

            Assert.AreEqual("mockedtag", element.TagName);
            Assert.That(finderMock.FindAllImplCounter, Is.LessThanOrEqualTo(2), "Atmost 2 times");
        }
Ejemplo n.º 40
0
        public void TestExitMatch_removesCssClass()
        {
            string cssSelector = Some.String();
            string markerClass = Some.String();

            string markingScript = Some.String();

            Mock<IScriptLoader> scriptLoader = new Mock<IScriptLoader>();
            Mock<WatiN.Core.DomContainer> domContainer = new Mock<DomContainer>();

            scriptLoader.Expect(s => s.GetCssMarkRemovalScript(cssSelector, markerClass)).Returns(markingScript).Verifiable();

            var sut = new TestableCssSelectorConstraint(scriptLoader.Object, domContainer.Object, markerClass);

            sut.Initialize(cssSelector);

            sut.DoEnterMatch();

            domContainer.Verify();
        }
Ejemplo n.º 41
0
        public void ExecuteThrowsIfActionMethodReturnsNull()
        {
            // Arrange
            Mock <ControllerContext> mockControllerContext = new Mock <ControllerContext>();

            mockControllerContext.Expect(c => c.Controller).Returns(new ExecuteController());
            ControllerContext controllerContext = mockControllerContext.Object;

            MethodInfo actionMethod = typeof(ExecuteController).GetMethod("FooReturnsNull");
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            ReflectedDelegatePatternActionDescriptor ad = GetActionDescriptor(actionMethod);

            // Act & assert
            ExceptionHelper.ExpectInvalidOperationException(
                delegate {
                ad.BeginExecute(controllerContext, parameters, null, null);
            },
                @"Method 'System.Func`1[System.Int32] FooReturnsNull()' returned null. The method must return a value.");
        }
Ejemplo n.º 42
0
        private void Update(Mock <IStory> story)
        {
            var category = new Mock <ICategory>();

            category.Expect(c => c.UniqueName).Returns("Dummy");

            story.ExpectGet(s => s.BelongsTo).Returns(category.Object);

            story.Expect(s => s.ChangeNameAndCreatedAt(It.IsAny <string>(), It.IsAny <DateTime>())).Verifiable();
            story.ExpectSet(s => s.Title).Verifiable();
            story.Expect(s => s.ChangeCategory(It.IsAny <ICategory>())).Verifiable();
            story.ExpectSet(s => s.HtmlDescription).Verifiable();
            story.Expect(s => s.AddTag(It.IsAny <ITag>())).Verifiable();

            var updatedCategory = new Mock <ICategory>();

            _categoryRepository.Expect(r => r.FindByUniqueName(It.IsAny <string>())).Returns(updatedCategory.Object).Verifiable();

            _storyService.Update(story.Object, string.Empty, DateTime.MinValue, "This is a title", "foobar", "This is the description", "foo,bar");
        }
Ejemplo n.º 43
0
        public void BuyShipInvalidId()
        {
            // Arrange
            Mock <User>        userMock    = new Mock <User>();
            Mock <GameManager> managerMock = new Mock <GameManager>(userMock.Object);

            managerMock.Expect(m => m.CurrentPlayer.Ship.CosmoSystem.GetBuyableShip(-5))
            .Returns <SystemShip>(null).AtMostOnce().Verifiable();
            ShipController controller = new ShipController(managerMock.Object);

            // Act
            ActionResult result = controller.BuyShip(-5);

            // Assert
            Assert.That(result, Is.TypeOf(typeof(ViewResult)), "Should return a view");
            Assert.That(controller.ModelState.IsValid, Is.False, "A error should be returned");
            Assert.That(controller.ModelState["shipId"].Errors, Is.Not.Empty, "ShipId should be the error field");

            managerMock.Verify();
        }
Ejemplo n.º 44
0
        private static MvcHandler GetMvcHandler(IController controller)
        {
            Mock <HttpContextBase> mockHttpContext = new Mock <HttpContextBase>();

            mockHttpContext.Expect(o => o.Response.AddHeader("X-AspNetMvc-Version", "2.0"));

            RouteData routeData = new RouteData();

            routeData.Values["controller"] = "SomeController";
            RequestContext requestContext = new RequestContext(mockHttpContext.Object, routeData);

            ControllerBuilder controllerBuilder = new ControllerBuilder();

            controllerBuilder.SetControllerFactory(new SimpleControllerFactory(controller));

            return(new MvcHandler(requestContext)
            {
                ControllerBuilder = controllerBuilder
            });
        }
Ejemplo n.º 45
0
        public void FormAnonymousValuesAndAttributes()
        {
            // Arrange
            Mock <HttpResponseBase> mockResponse = new Mock <HttpResponseBase>(MockBehavior.Strict);
            AjaxHelper  ajaxHelper  = GetAjaxHelper(mockResponse);
            AjaxOptions ajaxOptions = new AjaxOptions {
                UpdateTargetId = "some-id"
            };
            object values         = new { controller = "Controller" };
            object htmlAttributes = new { method = "get" };

            // Arrange expectations
            mockResponse.Expect(response => response.Write(AjaxFormWithHtmlAttributes)).Verifiable();

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions, htmlAttributes);

            // Assert
            mockResponse.Verify();
        }
Ejemplo n.º 46
0
        public void RouteFormAnonymousValues()
        {
            // Arrange
            Mock <HttpResponseBase> mockResponse = new Mock <HttpResponseBase>(MockBehavior.Strict);
            AjaxHelper  ajaxHelper  = GetAjaxHelper(mockResponse);
            AjaxOptions ajaxOptions = GetEmptyOptions();
            AjaxHelper  poes        = GetAjaxHelper();

            // Arrange expectations
            string x = ajaxHelper.RouteLink("a", "namedroute", GetEmptyOptions());
            string y = poes.RouteLink("a", "namedroute", null, ajaxOptions, new RouteValueDictionary());

            mockResponse.Expect(response => response.Write(AjaxRouteFormWithEmptyOptions)).Verifiable();

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", null, ajaxOptions);

            // Assert
            mockResponse.Verify();
        }
Ejemplo n.º 47
0
        public void ExecuteResultSetsContentDispositionIfSpecified()
        {
            // Arrange
            Mock <ControllerContext> mockControllerContext = new Mock <ControllerContext>(MockBehavior.Strict);

            mockControllerContext.ExpectSet(c => c.HttpContext.Response.ContentType, "application/my-type").Verifiable();
            mockControllerContext.Expect(c => c.HttpContext.Response.AddHeader("Content-Disposition", "attachment; filename=filename.ext")).Verifiable();

            EmptyFileResult result = new EmptyFileResult("application/my-type")
            {
                FileDownloadName = "filename.ext"
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            Assert.IsTrue(result.WasWriteFileCalled);
            mockControllerContext.Verify();
        }
Ejemplo n.º 48
0
        public void GetTab_Should_Return_A_Tab_from_database_when_cache_is_empty_and_then_caches_it()
        {
            var            cache          = new Mock <ICache>();
            var            database       = new Mock <IDatabase>();
            ITabRepository pageRepository = new TabRepository(database.Object, cache.Object);

            const int pageId    = 1;
            var       page      = default(Tab);
            var       sampleTab = new Tab()
            {
                ID = pageId, Title = "Test Tab", ColumnCount = 3, LayoutType = 3, VersionNo = 1, PageType = (int)Enumerations.PageType.PersonalTab, CreatedDate = DateTime.Now
            };

            database
            .Expect <IQueryable <Tab> >(d => d.Query <int, Tab>(CompiledQueries.TabQueries.GetTabById, 1))
            .Returns(new Tab[] { sampleTab }.AsQueryable()).Verifiable();

            "Given TabRepository and empty cache".Context(() =>
            {
                // cache is empty
                cache.Expect(c => c.Get(It.IsAny <string>())).Returns(default(object));
                // It will cache the Tab object afte loading from database
                cache.Expect(c => c.Add(It.Is <string>(cacheKey => cacheKey == CacheKeys.TabKeys.TabId(pageId)),
                                        It.Is <Tab>(cacheTab => object.ReferenceEquals(cacheTab, sampleTab)))).Verifiable();
            });

            "when GetTabById is called".Do(() =>
                                           page = pageRepository.GetTabById(1));

            "it checks in the cache first and finds nothing and then caches it".Assert(() =>
                                                                                       cache.VerifyAll());


            "it loads the page from database".Assert(() =>
                                                     database.VerifyAll());

            "it returns the page as expected".Assert(() =>
            {
                Assert.Equal <int>(pageId, page.ID);
            });
        }
Ejemplo n.º 49
0
        private static HtmlHelper GetFormHelper(out StringWriter writer)
        {
            Mock <HttpRequestBase> mockHttpRequest = new Mock <HttpRequestBase>();

            mockHttpRequest.Expect(r => r.Url).Returns(new Uri("http://www.contoso.com/some/path"));
            Mock <HttpResponseBase> mockHttpResponse = new Mock <HttpResponseBase>(MockBehavior.Strict);

            mockHttpResponse.Expect(r => r.ApplyAppPathModifier(It.IsAny <string>())).Returns <string>(r => AppPathModifier + r);
            Mock <HttpContextBase> mockHttpContext = new Mock <HttpContextBase>();

            mockHttpContext.Expect(c => c.Request).Returns(mockHttpRequest.Object);
            mockHttpContext.Expect(c => c.Response).Returns(mockHttpResponse.Object);
            RouteCollection rt = new RouteCollection();

            rt.Add(new Route("{controller}/{action}/{id}", null)
            {
                Defaults = new RouteValueDictionary(new { id = "defaultid" })
            });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null)
            {
                Defaults = new RouteValueDictionary(new { id = "defaultid" })
            });
            RouteData rd = new RouteData();

            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");

            Mock <ViewContext> mockViewContext = new Mock <ViewContext>();

            mockViewContext.Expect(c => c.HttpContext).Returns(mockHttpContext.Object);
            mockViewContext.Expect(c => c.RouteData).Returns(rd);
            writer = new StringWriter();
            mockViewContext.Expect(c => c.Writer).Returns(writer);

            HtmlHelper helper = new HtmlHelper(
                mockViewContext.Object,
                new Mock <IViewDataContainer>().Object,
                rt);

            return(helper);
        }
Ejemplo n.º 50
0
        public void BindModel()
        {
            // Arrange
            ControllerContext             controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext    = new ExtensibleModelBindingContext()
            {
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ModelMetadata        = GetMetadataForObject(new Person()),
                ModelName            = "someName"
            };

            Mock <IExtensibleModelBinder> mockDtoBinder = new Mock <IExtensibleModelBinder>();

            mockDtoBinder
            .Expect(o => o.BindModel(controllerContext, It.IsAny <ExtensibleModelBindingContext>()))
            .Returns(
                delegate(ControllerContext cc, ExtensibleModelBindingContext mbc2) {
                return(true);        // just return the DTO unchanged
            });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(ComplexModelDto), mockDtoBinder.Object, true /* suppressPrefixCheck */);

            Mock <TestableMutableObjectModelBinder> mockTestableBinder = new Mock <TestableMutableObjectModelBinder>()
            {
                CallBase = true
            };

            mockTestableBinder.Expect(o => o.EnsureModelPublic(controllerContext, bindingContext)).Verifiable();
            mockTestableBinder.Expect(o => o.GetMetadataForPropertiesPublic(controllerContext, bindingContext)).Returns(new ModelMetadata[0]).Verifiable();
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;

            testableBinder.MetadataProvider = new DataAnnotationsModelMetadataProvider();

            // Act
            bool retValue = testableBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.IsTrue(retValue);
            Assert.IsInstanceOfType(bindingContext.Model, typeof(Person));
            Assert.IsTrue(bindingContext.ValidationNode.ValidateAllProperties);
            mockTestableBinder.Verify();
        }
Ejemplo n.º 51
0
        public void ContainerMustInjectFactoryInstances()
        {
            var mockFactory = new Mock <IFactory <ISampleService> >();

            mockFactory.Expect(f => f.CreateInstance(It.IsAny <IFactoryRequest>())).Returns(new SampleClass());

            var container = new ServiceContainer();

            container.AddFactory(mockFactory.Object);

            var instance =
                (SampleClassWithFactoryDependency)container.AutoCreate(typeof(SampleClassWithFactoryDependency));

            Assert.IsNotNull(instance);

            IFactory <ISampleService> factory = instance.Factory;

            factory.CreateInstance(null);

            mockFactory.VerifyAll();
        }
Ejemplo n.º 52
0
        public void ContainerMustReturnServiceInstance()
        {
            var mockFactory = new Mock <IFactory>();
            var container   = new ServiceContainer();

            Type serviceType = typeof(ISerializable);
            var  instance    = new object();

            container.AddFactory(serviceType, mockFactory.Object);

            // The container must call the IFactory.CreateInstance method
            mockFactory.Expect(f => f.CreateInstance(It.Is <IFactoryRequest>(request => request.ServiceType == serviceType &&
                                                                             request.Container == container))).Returns(instance);

            object result = container.GetService(serviceType);

            Assert.IsNotNull(result, "The container failed to return the given service instance");
            Assert.AreSame(instance, result, "The service instance returned does not match the given instance");

            mockFactory.VerifyAll();
        }
Ejemplo n.º 53
0
        public void ShouldMentionDialogHandlerAsCandidate()
        {
            // GIVEN
            var window         = new Window(new IntPtr(123));
            var mainWindowHwnd = new IntPtr(456);

            var dialogHandlerMock = new Mock <IDialogHandler>();

            dialogHandlerMock.Expect(dialog => dialog.CanHandleDialog(window, mainWindowHwnd)).Returns(true);

            var dialogHandlerHelper = new DialogHandlerHelper();

            Assert.That(dialogHandlerHelper.CandidateDialogHandlers.Count, Is.EqualTo(0), "Pr-condition: expected no candidates");

            // WHEN
            dialogHandlerHelper.HandlePossibleCandidate(dialogHandlerMock.Object, window, mainWindowHwnd);

            // THEN
            Assert.That(dialogHandlerHelper.CandidateDialogHandlers.Count, Is.EqualTo(1));
            dialogHandlerMock.VerifyAll();
        }
        public void Sent()
        {
            // Arrange
            Mock <User> userMock = new Mock <User>();

            userMock.Expect(u => u.GetMessagesSent())
            .Returns(new List <Message>()).AtMostOnce().Verifiable();
            Mock <GameManager>      managerMock = new Mock <GameManager>(userMock.Object);
            CommunicationController controller  = new CommunicationController(managerMock.Object);

            // Act
            ActionResult result = controller.Sent(null);

            // Assert
            Assert.That(result, Is.TypeOf(typeof(ViewResult)), "Should return a view");
            Assert.That(controller.ModelState.IsValid, "No errors should be returned");
            ViewResult viewResult = (ViewResult)result;

            Assert.That(viewResult.ViewData["Messages"], Is.InstanceOfType(typeof(IEnumerable <Message>)), "Messages should be an IEnumerable of Message objects");
            managerMock.Verify();
        }
        public void Compose()
        {
            // Arrange
            Mock <User> userMock = new Mock <User>();

            userMock.Expect(u => u.GetBuddyList())
            .Returns(new BuddyList[0]).AtMostOnce().Verifiable();
            Mock <GameManager>      managerMock = new Mock <GameManager>(userMock.Object);
            CommunicationController controller  = new CommunicationController(managerMock.Object);

            // Act
            ActionResult result = controller.Compose(null);

            // Assert
            Assert.That(result, Is.TypeOf(typeof(ViewResult)), "Should return a view");
            Assert.That(controller.ModelState.IsValid, "No errors should be returned");
            ViewResult viewResult = (ViewResult)result;

            Assert.That(viewResult.ViewData["toUserId"], Is.InstanceOfType(typeof(SelectList)), "toUserId should be an SelectList of buddies");
            managerMock.Verify();
        }
        public void BodyShouldReturnAnIENativeElement()
        {
            // GIVEN
            var htmlElementMock = new Mock <IHTMLElement>();
            var htmlElement     = htmlElementMock.Object;

            var htmlDocument2Mock = new Mock <IHTMLDocument2>();

            htmlDocument2Mock.Expect(document => document.body).Returns(htmlElement);
            var htmlDocument = htmlDocument2Mock.Object;

            var ieDocument = new IEDocument(htmlDocument);

            // WHEN
            var nativeElement = ieDocument.Body;

            // THEN
            IEElement ieElement = (IEElement)nativeElement;

            Assert.That(ReferenceEquals(ieElement.AsHtmlElement, htmlElement), "Unexpected instance");
        }
        public void DeserializeReturnsDeserializedToken()
        {
            // Arrange
            Mock <IStateFormatter> mockFormatter = new Mock <IStateFormatter>();

            mockFormatter.Expect(f => f.Deserialize("serialized value")).Returns(new Triplet("the salt", "the value", new DateTime(2001, 1, 1)));

            AntiForgeryDataSerializer serializer = new AntiForgeryDataSerializer()
            {
                Formatter = mockFormatter.Object
            };

            // Act
            AntiForgeryData token = serializer.Deserialize("serialized value");

            // Assert
            Assert.IsNotNull(token);
            Assert.AreEqual(new DateTime(2001, 1, 1), token.CreationDate);
            Assert.AreEqual("the salt", token.Salt);
            Assert.AreEqual("the value", token.Value);
        }
        public async Task TestLinkBody()
        {
            string body = JsonConvert.SerializeObject(new
            {
                links = new
                {
                    single = new {href = "a"},
                    collection = new object[] {new {href = "b", title = "Title 1"}, new {href = "c"}, true, new {something = false}},
                    template = new {href = "{id}", templated = true}
                }
            });
            Mock.Expect(HttpMethod.Get, "http://localhost/endpoint").Respond(JsonMime, body);

            await _endpoint.GetAsync();

            _endpoint.Link("single").Should().Be(new Uri("http://localhost/a"));
            _endpoint.GetLinks("collection").Should().BeEquivalentTo(
                new Link(new Uri("http://localhost/b"), "Title 1"),
                new Link(new Uri("http://localhost/c")));
            _endpoint.LinkTemplate("template").ToString().Should().Be("{id}");
        }
Ejemplo n.º 59
0
        public void ShouldCallGetAllInstancesMethodOnNextContainer()
        {
            var map       = new DependencyMap();
            var container = map.CreateContainer();

            Assert.IsNotNull(container);

            var mockContainer = new Mock <IMicroContainer>();

            mockContainer.Expect(m => m.GetAllInstances(typeof(int))).Returns(new object[] { 42 });

            container.NextContainer = mockContainer.Object;

            var results = container.GetAllInstances(typeof(int));

            mockContainer.VerifyAll();

            var resultList = new List <object>(results);

            Assert.IsTrue(resultList.Contains(42));
        }
Ejemplo n.º 60
0
        public void OnCacheAuthorizationReturnsValidIfUserIsAuthorized()
        {
            // Arrange
            Mock <AuthorizeAttributeHelper> mockHelper = new Mock <AuthorizeAttributeHelper>()
            {
                CallBase = true
            };

            mockHelper.Expect(h => h.PublicAuthorizeCore(It.IsAny <HttpContextBase>())).Returns(true);
            AuthorizeAttributeHelper helper = mockHelper.Object;

            Mock <HttpContextBase> mockHttpContext = new Mock <HttpContextBase>();

            mockHttpContext.Expect(c => c.User).Returns(new Mock <IPrincipal>().Object);

            // Act
            HttpValidationStatus validationStatus = helper.PublicOnCacheAuthorization(mockHttpContext.Object);

            // Assert
            Assert.AreEqual(HttpValidationStatus.Valid, validationStatus);
        }