Mocking 및 HttpContextBase.get_User()

Question

HttpContext의 User 속성을 조롱하고 싶습니다. Scott Hanselmans MVCHelper 클래스와 RhinoMock을 사용하고 있습니다. ,

...

MockIdentity fakeId = new MockIdentity("TEST_USER", "Windows", true); 
MockPrincipal fakeUser = new MockPrincipal(null, fakeId); 

using (mocks.Record()) 
{ 
    Expect.Call(fakeHttpContext.User).Return(fakeUser); 
} 

...

내 MockIdentity 및 MockPrincipal 클래스 모의 객체는 IIdentity 및 IPrincipal에 부합됩니다

는이 같은 코드를 포함하는 단위 테스트를 가지고 각기.

System.NotImplementedException을 :보고 단위 테스트를 실행할 때

나는 오류를 얻는 방법 또는 작업이 구현 가 없습니다. System.Web.HttpContextBase.get_User()에서

이것은 User 속성에 대한 기대치를 설정하려고 할 때 발생합니다.

httpContextBase에는 구현되지 않은 getter 및 setter가 있지만 Rhino가 조롱 할 때 Rhino가 처리한다고 생각합니다.

즉, HttpContextbase에서 파생시켜 내 모의 개체의 속성을 재정의해야한다는 의미입니까? 이상하게 보입니다.

다른 사용자는이 문제를 가지고 있고 그것은 여기에보고 있어요 : http://www.mail-archive.com/rhinomocks@googlegroups.com/msg00546.html

Answer 1

는 사용자 속성을 조롱하기 위해, 당신은이 작업을 수행 할 수 있습니다

var httpContext = MockRepository.GenerateStub<HttpContextBase>(); 
httpContext.Stub(x=>x.User).Return(yourFakePrincipalHere); 

var controllerContext = new ControllerContext(httpContext, ....); 

var controller = new HomeController(); 
controller.ControllerContext = controllerContext; 

을 (이 경우, 새로운 RM 3.5 API를 사용하여 당신은/기록/재생 승을 다하고 :

using(mocks.Record) 
{ 
    _httpContext = _mocks.DynamicMock<HttpContextBase>(); 
    SetupResult.For(_httpContext.User).Return(...); 
} 

using(mocks.PlayBack()) 
{ 
    .... 
} 

Answer 2

나는 거의 동일한 문제를 가지고 있었고, MOQ로 이동.

이

내가 내 응용 프로그램에서 사용하는 사용자 지정 도우미 :

public static class MvcMockHelpers 
    { 
     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); 

      response.Expect(r => r.Cookies).Returns(cookies); 

      context.Expect(u => u.User).Returns(user); 



      return context.Object; 
     } 

     public static HttpContextBase FakeHttpContext(string url) 
     { 
      HttpContextBase context = FakeHttpContext(); 
      context.Request.SetupRequestUrl(url); 

      return context; 

     } 


     public static void SetFakeControllerContext(this Controller controller) 
     { 
      var httpContext = FakeHttpContext(); 
      ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller); 
      controller.ControllerContext = context; 
     } 

     public static void SetFakeControllerContext(this Controller controller, RouteData routeData) 
     { 
      SetFakeControllerContext(controller, new Dictionary<string, string>(), new HttpCookieCollection(), routeData); 
     } 

     public static void SetFakeControllerContext(this Controller controller, HttpCookieCollection requestCookies) 
     { 
      SetFakeControllerContext(controller,new Dictionary<string,string>(),requestCookies, new RouteData()); 
     } 

     public static void SetFakeControllerContext(this Controller controller, Dictionary<string, string> formValues) 
     { 
      SetFakeControllerContext(controller, formValues, new HttpCookieCollection(), new RouteData()); 
     } 

     public static void SetFakeControllerContext(this Controller controller, 
      Dictionary<string, string> formValues, 
      HttpCookieCollection requestCookies, 
      RouteData routeData) 
     { 
      var httpContext = FakeHttpContext(); 

      foreach (string key in formValues.Keys) 
      { 
       httpContext.Request.Form.Add(key, formValues[key]); 

      } 
      foreach (string key in requestCookies.Keys) 
      { 
       httpContext.Request.Cookies.Add(requestCookies[key]); 

      } 
      ControllerContext context = new ControllerContext(new RequestContext(httpContext, routeData), controller); 
      controller.ControllerContext = context; 
     } 

     public static void SetFakeControllerContextWithLogin(this Controller controller, string userName, 
      string password, 
      string returnUrl) 
     { 

      var httpContext = FakeHttpContext(); 


      httpContext.Request.Form.Add("username", userName); 
      httpContext.Request.Form.Add("password", password); 
      httpContext.Request.QueryString.Add("ReturnUrl", returnUrl); 

      ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller); 
      controller.ControllerContext = context; 
     } 


     static string GetUrlFileName(string url) 
     { 
      if (url.Contains("?")) 
       return url.Substring(0, url.IndexOf("?")); 
      else 
       return url; 
     } 

     static NameValueCollection GetQueryStringParameters(string url) 
     { 
      if (url.Contains("?")) 
      { 
       NameValueCollection parameters = new NameValueCollection(); 

       string[] parts = url.Split("?".ToCharArray()); 
       string[] keys = parts[1].Split("&".ToCharArray()); 

       foreach (string key in keys) 
       { 
        string[] part = key.Split("=".ToCharArray()); 
        parameters.Add(part[0], part[1]); 
       } 

       return parameters; 
      } 
      else 
      { 
       return null; 
      } 
     } 

     public static void SetHttpMethodResult(this HttpRequestBase request, string httpMethod) 
     { 
      Mock.Get(request) 
       .Expect(req => req.HttpMethod) 
       .Returns(httpMethod); 
     } 

     public static void SetupRequestUrl(this HttpRequestBase request, string url) 
     { 
      if (url == null) 
       throw new ArgumentNullException("url"); 

      if (!url.StartsWith("~/")) 
       throw new ArgumentException("Sorry, we expect a virtual url starting with \"~/\"."); 

      var mock = Mock.Get(request); 

      mock.Expect(req => req.QueryString) 
       .Returns(GetQueryStringParameters(url)); 
      mock.Expect(req => req.AppRelativeCurrentExecutionFilePath) 
       .Returns(GetUrlFileName(url)); 
      mock.Expect(req => req.PathInfo) 
       .Returns(string.Empty); 
     } 

Answer 3

[Dislaimer : 나는에서 일 10]

나는 당신이 필요로 할 다른 방법을 제시해야보다 당신이 요청하지만 답변을보고 한 게 아니에요 알 - Isolator 사용 : 조롱 프레임 워크를 변경하는 것은 아니다

var fakeId = Isolate.Fake.Instance<IIdentity>(); 
Isolate.WhenCalled(() => fakeId.AuthenticationType).WillReturn("Windows"); 
Isolate.WhenCalled(() => fakeId.Name).WillReturn("TEST_USER"); 
Isolate.WhenCalled(() => fakeId.IsAuthenticated).WillReturn(true); 

var fakePrincipal = Isolate.Fake.Instance<IPrincipal>(); 
Isolate.WhenCalled(() => fakePrincipal.Identity).WillReturn(fakeId); 

var fakeContext = Isolate.Fake.Instance<HttpContext>(); 
Isolate.WhenCalled(() => fakeContext.User).WillReturn(fakePrincipal);