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(); }
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); }
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(); }
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; }
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(); }
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(); }
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; }
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; }
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(); }
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); }
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."); }
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); }
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); }
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(); }
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); }
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); }
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(); }
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."); }
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); }
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); }
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"); }
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(); }
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."); }
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"); }
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(); }
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 }); }
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(); }
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(); }
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(); }
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); }); }
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 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(); }
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(); }
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(); }
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}"); }
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)); }
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); }