Mocking HttpClient in unit tests

Question

I have some issues trying to wrap my code to be used in unit tests  The issues is this  I Have the interface IHttpHandler   public interface IHttpHandler       HttpClient client   get        And the class using it  HttpHandler   public class HttpHandler   IHttpHandler       public HttpClient client               get                       return new HttpClient                        And then the Connection class  which uses simpleIOC to inject the client implementation   public class Connection       private IHttpHandler  httpClient       public Connection IHttpHandler httpClient                 httpClient   httpClient            And then I have a unit test project which has this class    private IHttpHandler  httpClient    TestMethod  public void TestMockConnection         var client   new Connection  httpClient        client doSomething              Here I want to somehow create a mock instance of the http client        Instead of the real one  How Should I approach this            Now obviously I will have methods in the Connection class that will retrieve data  JSON  from a my back end  However  I want to write unit tests for this class  and obviously I don t want to write tests against the real back end  rather a mocked one  I Have tried to google a good answer to this without great success  I can and have used Moq to mock before  but never on something like httpClient  How Should I approach this problem   Thanks in advance

User · Answer

Inspired by PointZeroTwo s answer  here s a sample using NUnit and FakeItEasy   SystemUnderTest in this example is the class that you want to test - no sample content given for it but I assume you have that already    TestFixture  public class HttpClientTests       private ISystemUnderTest  systemUnderTest      private HttpMessageHandler  mockMessageHandler        SetUp      public void Setup                  mockMessageHandler   A Fake lt HttpMessageHandler gt             var httpClient   new HttpClient  mockMessageHandler             systemUnderTest   new SystemUnderTest httpClient               Test      public void HttpError                    Arrange         A CallTo  mockMessageHandler               Where x   gt  x Method Name     SendAsync                WithReturnType lt Task lt HttpResponseMessage gt  gt                 Returns Task FromResult new HttpResponseMessage                               StatusCode   HttpStatusCode InternalServerError                  Content   new StringContent  abcd                                Act         var result    systemUnderTest DoSomething                Assert            Assert AreEqual

User · Answer

As also mentioned in the comments you need to abstract away the HttpClient so as not to be coupled to it  I ve done something similar in the past  I ll try to adapt what I did with what you are trying to do   First look at the HttpClient class and decided on what functionality it provided that would be needed    Here is a possibility    public interface IHttpClient       System Threading Tasks Task lt T gt  DeleteAsync lt T gt  string uri  where T   class      System Threading Tasks Task lt T gt  DeleteAsync lt T gt  Uri uri  where T   class      System Threading Tasks Task lt T gt  GetAsync lt T gt  string uri  where T   class      System Threading Tasks Task lt T gt  GetAsync lt T gt  Uri uri  where T   class      System Threading Tasks Task lt T gt  PostAsync lt T gt  string uri  object package       System Threading Tasks Task lt T gt  PostAsync lt T gt  Uri uri  object package       System Threading Tasks Task lt T gt  PutAsync lt T gt  string uri  object package       System Threading Tasks Task lt T gt  PutAsync lt T gt  Uri uri  object package       Again as stated before this was for particular purposes  I completely abstracted away most dependencies to anything dealing with HttpClient and focused on what I wanted returned  You should evaluate how you want to abstract the HttpClient to provide only the necessary functionality you want   This will now allow you to mock only what is needed to be tested   I would even recommend doing away with IHttpHandler completely and use the HttpClient abstraction IHttpClient  But I m just not picking as you can replace the body of your handler interface with the members of the abstracted client   An implementation of the IHttpClient can then be used to wrapp adapt a real concrete HttpClient or any other object for that matter  that can be used to make HTTP requests as what you really wanted was a service that provided that functionality as apposed to HttpClient specifically  Using the abstraction is a clean  My opinion  and SOLID approach and can make your code more maintainable if you need to switch out the underlying client for something else as the framework changes   Here is a snippet of how an implementation could be done        lt summary gt      HTTP Client adaptor wraps a  lt see cref  System Net Http HttpClient   gt       that contains a reference to  lt see cref  ConfigurableMessageHandler   gt       lt  summary gt  public sealed class HttpClientAdaptor   IHttpClient       HttpClient httpClient       public HttpClientAdaptor IHttpClientFactory httpClientFactory            httpClient   httpClientFactory CreateHttpClient   Custom configurations                     other code            lt summary gt           Send a GET request to the specified Uri as an asynchronous operation           lt  summary gt           lt typeparam name  T  gt Response type lt  typeparam gt           lt param name  uri  gt The Uri the request is sent to lt  param gt           lt returns gt  lt  returns gt      public async System Threading Tasks Task lt T gt  GetAsync lt T gt  Uri uri  where T   class           var result   default T             Try to get content as T         try                 send request and get the response             var response   await httpClient GetAsync uri  ConfigureAwait false                 if there is content in response to deserialize             if  response Content Headers ContentLength GetValueOrDefault    gt  0                      get the content                 string responseBodyAsText   await response Content ReadAsStringAsync   ConfigureAwait false                     desrialize it                 result   deserializeJsonToObject lt T gt  responseBodyAsText                           catch  Exception ex                Log Error ex                     return result                  other code     As you can see in the above example  a lot of the heavy lifting usually associated with using HttpClient is hidden behind the abstraction    You connection class can then be inject with the abstracted client  public class Connection       private IHttpClient  httpClient       public Connection IHttpClient httpClient                 httpClient   httpClient            Your test can then mock what is needed for your SUT  private IHttpClient  httpClient    TestMethod  public void TestMockConnection         SomeModelObject model   new SomeModelObject        var httpClientMock   new Mock lt IHttpClient gt         httpClientMock Setup c   gt  c GetAsync lt SomeModelObject gt  It IsAny lt string gt               Returns      gt  Task FromResult model          httpClient   httpClientMock Object       var client   new Connection  httpClient           Assuming doSomething uses the client to make        a request for a model of type SomeModelObject     client doSomething

User · Answer

This is an old question  but I feel the urge to extend the answers with a solution I didn t see here  You can fake the Microsoft assemly  System Net Http  and then use ShinsContext during the test       In VS 2017  right click on the System Net Http assembly and choose  Add Fakes Assembly  Put your code in the unit test method under a ShimsContext Create   using  This way  you can isolate the code where you are planning to fake the HttpClient  Depends on your implementation and test  I would suggest to implement all the desired acting where you call a method on the HttpClient and want to fake the returned value  Using ShimHttpClient AllInstances will fake your implementation in all the instances created during your test  For example  if you want to fake the GetAsync   method  do the following    TestMethod  public void FakeHttpClient         using  ShimsContext Create                  System Net Http Fakes ShimHttpClient AllInstances GetAsyncString    c  requestUri    gt                        Return a service unavailable response           var httpResponseMessage   new HttpResponseMessage HttpStatusCode ServiceUnavailable             var task   Task FromResult httpResponseMessage             return task                        your implementation will use the fake method s  automatically         var client   new Connection  httpClient           client doSomething

User · Answer

After carefully searching  I figured out the best approach to accomplish this      private HttpResponseMessage response        SetUp      public void Setup                 var handlerMock   new Mock lt HttpMessageHandler gt              handlerMock             Protected               Setup lt Task lt HttpResponseMessage gt  gt                  quot SendAsync quot                 ItExpr IsAny lt HttpRequestMessage gt                   ItExpr IsAny lt CancellationToken gt                   This line will let you to change the response in each test method             ReturnsAsync      gt  response             httpClient   new HttpClient handlerMock Object            yourClinet   new YourClient   httpClient           As you noticed I have used Moq and Moq Protected packages

User · Answer

All you need is a test version of HttpMessageHandler class which you pass to HttpClient ctor  The main point is that your test HttpMessageHandler class will have a HttpRequestHandler delegate that the callers can set and simply handle the HttpRequest the way they want    public class FakeHttpMessageHandler   HttpMessageHandler               public Func lt HttpRequestMessage  CancellationToken  HttpResponseMessage gt  HttpRequestHandler   get  set               r  c    gt               new HttpResponseMessage                               ReasonPhrase   r RequestUri AbsoluteUri                  StatusCode   HttpStatusCode OK                          protected override Task lt HttpResponseMessage gt  SendAsync HttpRequestMessage request  CancellationToken cancellationToken                        return Task FromResult HttpRequestHandler request  cancellationToken                      You can use an instance of this class to create a concrete HttpClient instance  Via the HttpRequestHandler delegate you have full control over outgoing http requests from HttpClient

User · Answer

You could use RichardSzalay MockHttp library which mocks the HttpMessageHandler and can return an HttpClient object to be used during tests   GitHub MockHttp  PM  Install-Package RichardSzalay MockHttp  From the GitHub documentation     MockHttp defines a replacement HttpMessageHandler  the engine that drives HttpClient  that provides a fluent configuration API and provides a canned response  The caller  eg  your application s service layer  remains unaware of its presence    Example from GitHub   var mockHttp   new MockHttpMessageHandler        Setup a respond for the user api  including a wildcard in the URL  mockHttp When  http   localhost api user              Respond  application json      name     Test McGee         Respond with JSON     Inject the handler or client into your application code var client   mockHttp ToHttpClient     var response   await client GetAsync  http   localhost api user 1234       or without async  var response   client GetAsync  http   localhost api user 1234   Result   var json   await response Content ReadAsStringAsync        No network connection required Console Write json        name     Test McGee

User · Answer

I m not convinced by many of the answers   First of all  imagine you want to unit test a method that uses HttpClient  You should not instantiate HttpClient directly in your implementation  You should inject a factory with the responsibility of providing an instance of HttpClient for you  That way you can mock later on that factory and return whichever HttpClient you want  e g  a mock HttpClient and not the real one    So  you would have a factory like the following   public interface IHttpClientFactory       HttpClient Create        And an implementation   public class HttpClientFactory       IHttpClientFactory       public HttpClient Create                 var httpClient   new HttpClient            return httpClient            Of course you would need to register in your IoC Container this implementation  If you use Autofac it would be something like   builder      RegisterType lt IHttpClientFactory gt         As lt HttpClientFactory gt         SingleInstance      Now you would have a proper and testeable implementation  Imagine that your method is something like   public class MyHttpClient       IMyHttpClient       private readonly IHttpClientFactory  httpClientFactory       public SalesOrderHttpClient IHttpClientFactory httpClientFactory                 httpClientFactory   httpClientFactory             public async Task lt string gt  PostAsync Uri uri  string content                using  var client    httpClientFactory Create                          var clientAddress   uri GetLeftPart UriPartial Authority               client BaseAddress   new Uri clientAddress               var content   new StringContent content  Encoding UTF8   application json                var uriAbsolutePath   uri AbsolutePath              var response   await client PostAsync uriAbsolutePath  content               var responseJson   response Content ReadAsStringAsync   Result              return responseJson                      Now the testing part  HttpClient extends HttpMessageHandler  which is abstract  Let s create a  mock  of HttpMessageHandler that accepts a delegate so that when we use the mock we can also setup each behaviour for each test   public class MockHttpMessageHandler        HttpMessageHandler       private readonly Func lt HttpRequestMessage  CancellationToken  Task lt HttpResponseMessage gt  gt   sendAsyncFunc       public MockHttpMessageHandler Func lt HttpRequestMessage  CancellationToken  Task lt HttpResponseMessage gt  gt  sendAsyncFunc                 sendAsyncFunc   sendAsyncFunc             protected override async Task lt HttpResponseMessage gt  SendAsync HttpRequestMessage request  CancellationToken cancellationToken                return await  sendAsyncFunc Invoke request  cancellationToken             And now  and with the help of Moq  and FluentAssertions  a library that makes unit tests more readable   we have everything needed to unit test our method PostAsync that uses HttpClient  public static class PostAsyncTests       public class Given A Uri And A JsonMessage When Posting Async           Given WhenAsync Then Test               private SalesOrderHttpClient  sut          private Uri  uri          private string  content          private string  expectedResult          private string  result           protected override void Given                          uri   new Uri  http   test com api resources                 content       foo      bar                   expectedResult       result      ok                   var httpClientFactoryMock   new Mock lt IHttpClientFactory gt                 var messageHandlerMock                   new MockHttpMessageHandler  request  cancellation    gt                                        var responseMessage                           new HttpResponseMessage HttpStatusCode Created                                                        Content   new StringContent     result      ok                                                      var result   Task FromResult responseMessage                       return result                                   var httpClient   new HttpClient messageHandlerMock               httpClientFactoryMock                  Setup x   gt  x Create                     Returns httpClient                var httpClientFactory   httpClientFactoryMock Object                sut   new SalesOrderHttpClient httpClientFactory                      protected override async Task WhenAsync                          result   await  sut PostAsync  uri   content                        Fact          public void Then It Should Return A Valid JsonMessage                          result Should   BeEquivalentTo  expectedResult                       Obviously this test is silly  and we re really testing our mock  But you get the idea  You should test meaningful logic depending on your implementation such as     if the code status of the response is not 201  should it throw an exception  if the response text cannot be parsed  what should happen  etc    The purpose of this answer was to test something that uses HttpClient and this is a nice clean way to do so

User · Answer

Microsoft now recommends using an IHttpClientFactory instead of directly using HttpClient  https   docs microsoft com en-us aspnet core fundamentals http-requests view aspnetcore-5 0 Example Mock with request that returns expected result  private LoginController GetLoginController         var expected    quot Hello world quot       var mockFactory   new Mock lt IHttpClientFactory gt          var mockMessageHandler   new Mock lt HttpMessageHandler gt         mockMessageHandler Protected            Setup lt Task lt HttpResponseMessage gt  gt   quot SendAsync quot   ItExpr IsAny lt HttpRequestMessage gt     ItExpr IsAny lt CancellationToken gt              ReturnsAsync new HttpResponseMessage                       StatusCode   HttpStatusCode OK              Content   new StringContent expected                   var httpClient   new HttpClient mockMessageHandler Object        mockFactory Setup     gt    CreateClient It IsAny lt string gt      Returns httpClient        var logger   Mock Of lt ILogger lt LoginController gt  gt          var controller   new LoginController logger  mockFactory Object        return controller     Source  https   stackoverflow com a 66256132 3850405

User · Answer

This is a common question  and I was heavily on the side wanting the ability to mock HttpClient  but I think I finally came to the realization that you shouldn t be mocking HttpClient  It seems logical to do so  but I think we ve been brainwashed by things we see in open source libraries    We often see  Clients  out there that we mock in our code so that we can test in isolation  so we automatically try to apply the same principle to HttpClient  HttpClient actually does a lot  you can think of it as a manager for HttpMessageHandler  so you don t wanna mock that  and that s why it still doesn t have an interface  The part that you re really interested in for unit testing  or designing your services  even  is the HttpMessageHandler since that is what returns the response  and you can mock that    It s also worth pointing out that you should probably start treating HttpClient like a bigger deal  For example  Keep your instatiating of new HttpClients to a minimum  Reuse them  they re designed to be reused and use a crap ton less resources if you do  If you start treating it like a bigger deal  it ll feel much more wrong wanting to mock it and now the message handler will start to be the thing that you re injecting  not the client    In other words  design your dependencies around the handler instead of the client  Even better  abstract  services  that use HttpClient which allow you to inject a handler  and use that as your injectable dependency instead  Then in your tests  you can fake the handler to control the response for setting up your tests   Wrapping HttpClient is an insane waste of time   Update  See Joshua Dooms s example  It s exactly what I m recommending

User · Answer

I think the issue is that you ve got it just a little upside down     public class AuroraClient   IAuroraClient       private readonly HttpClient  client       public AuroraClient     this new HttpClientHandler                     public AuroraClient HttpMessageHandler messageHandler                 client   new HttpClient messageHandler             If you look at the class above  I think this is what you want   Microsoft recommends keeping the client alive for optimal performance  so this type of structure allows you to do that  Also the HttpMessageHandler is an abstract class and therefore mockable  Your test method would then look like this    TestMethod  public void TestMethod1            Arrange     var mockMessageHandler   new Mock lt HttpMessageHandler gt            Set up your mock behavior here     var auroraClient   new AuroraClient mockMessageHandler Object          Act        Assert     This allows you to test your logic while mocking the HttpClient s behavior   Sorry guys  after writing this and trying it myself  I realized that you can t mock the protected methods on the HttpMessageHandler   I subsequently added the following code to allow for injection of a proper mock   public interface IMockHttpMessageHandler       Task lt HttpResponseMessage gt  SendAsync HttpRequestMessage request  CancellationToken cancellationToken      public class MockHttpMessageHandler   HttpMessageHandler       private readonly IMockHttpMessageHandler  realMockHandler       public MockHttpMessageHandler IMockHttpMessageHandler realMockHandler                 realMockHandler   realMockHandler             protected override async Task lt HttpResponseMessage gt  SendAsync HttpRequestMessage request  CancellationToken cancellationToken                return await  realMockHandler SendAsync request  cancellationToken             The tests written with this then look something like the following     TestMethod  public async Task GetProductsReturnsDeserializedXmlXopData            Arrange     var mockMessageHandler   new Mock lt IMockHttpMessageHandler gt            Set up Mock behavior here      var client   new AuroraClient new MockHttpMessageHandler mockMessageHandler Object           Act        Assert

User · Answer

One of my colleagues noticed that most of the HttpClient methods all call SendAsync HttpRequestMessage request  CancellationToken cancellationToken  under the hood  which is a virtual method off of HttpMessageInvoker   So by far the easiest way to mock out HttpClient was to simply mock that particular method   var mockClient   new Mock lt HttpClient gt     mockClient Setup client   gt  client SendAsync It IsAny lt HttpRequestMessage gt     It IsAny lt CancellationToken gt      ReturnsAsync  mockResponse Object     and your code can call most  but not all  of the HttpClient class methods  including a regular  httpClient SendAsync req    Check here to confirm https   github com dotnet corefx blob master src System Net Http src System Net Http HttpClient cs

User · Answer

Joining the party a bit late  but I like using wiremocking  https   github com WireMock-Net WireMock Net  whenever possible in the integrationtest of a dotnet core microservice with downstream REST dependencies   By implementing a TestHttpClientFactory extending the IHttpClientFactory we can override the method   HttpClient CreateClient string name   So when using the named clients within your app you are in control of returning a HttpClient wired to your wiremock   The good thing about this approach is that you are not changing anything within the application you are testing  and enables course integration tests doing an actual REST request to your service and mocking the json  or whatever  the actual downstream request should return  This leads to concise tests and as little mocking as possible in your application       public class TestHttpClientFactory   IHttpClientFactory        public HttpClient CreateClient string name                var httpClient   new HttpClient                       BaseAddress   new Uri G Config Get lt string gt    App Endpoints  name                    G Config is our singleton config access  so the endpoint                 to the running wiremock is used in the test                    return httpClient            and     in bootstrap of your Microservice IHttpClientFactory factory   new TestHttpClientFactory    container Register lt IHttpClientFactory gt  factory

User · Answer

Perhaps there would be some code to change in your current project but for new projects you should absolutely consider using Flurl    https   flurl dev  It is a HTTP client library for  NET with a fluent interface that specifically enables testability for code that uses it to make HTTP requests   There are plenty of code samples on the website but in a nutshell you use it like this in your code   Add the usings   using Flurl  using Flurl Http    Send a get request and read the response   public async Task SendGetRequest        var response   await  https   example com  GetAsync                  In the unit tests Flurl acts as a mock that can be configured to behave as desired and also to verify the calls that were done     using  var httpTest   new HttpTest            Arrange    httpTest RespondWith  OK   200          Act    await sut SendGetRequest           Assert    httpTest ShouldHaveCalled  https   example com          WithVerb HttpMethod Get

User · Answer

Your interface exposes the concrete HttpClient class  therefore any classes that use this interface are tied to it  this means that it cannot be mocked   HttpClient does not inherit from any interface so you will have to write your own  I suggest a decorator-like pattern   public interface IHttpHandler       HttpResponseMessage Get string url       HttpResponseMessage Post string url  HttpContent content       Task lt HttpResponseMessage gt  GetAsync string url       Task lt HttpResponseMessage gt  PostAsync string url  HttpContent content       And your class will look like this   public class HttpClientHandler   IHttpHandler       private HttpClient  client   new HttpClient         public HttpResponseMessage Get string url                return GetAsync url  Result             public HttpResponseMessage Post string url  HttpContent content                return PostAsync url  content  Result             public async Task lt HttpResponseMessage gt  GetAsync string url                return await  client GetAsync url              public async Task lt HttpResponseMessage gt  PostAsync string url  HttpContent content                return await  client PostAsync url  content             The point in all of this is that HttpClientHandler creates its own HttpClient  you could then of course create multiple classes that implement IHttpHandler in different ways   The main issue with this approach is that you are effectively writing a class that just calls methods in another class  however you could create a class that inherits from HttpClient  See Nkosi s example  it s a much better approach than mine   Life would be much easier if HttpClient had an interface that you could mock  unfortunately it does not   This example is not the golden ticket however  IHttpHandler still relies on HttpResponseMessage  which belongs to System Net Http namespace  therefore if you do need other implementations other than HttpClient  you will have to perform some kind of mapping to convert their responses into HttpResponseMessage objects  This of course is only a problem if you need to use multiple implementations of IHttpHandler but it doesn t look like you do so it s not the end of the world  but it s something to think about   Anyway  you can simply mock IHttpHandler without having to worry about the concrete HttpClient class as it has been abstracted away   I recommend testing the non-async methods  as these still call the asynchronous methods but without the hassle of having to worry about unit testing asynchronous methods  see here

User · Answer

Building on the other answers  I suggest this code  which does not have any outside dependencies    TestClass  public class MyTestClass        TestMethod      public async Task MyTestMethod                 var httpClient   new HttpClient new MockHttpMessageHandler              var content   await httpClient GetStringAsync  http   some fake url             Assert AreEqual  Content as string   content            public class MockHttpMessageHandler   HttpMessageHandler       protected override async Task lt HttpResponseMessage gt  SendAsync          HttpRequestMessage request          CancellationToken cancellationToken                var responseMessage   new HttpResponseMessage HttpStatusCode OK                        Content   new StringContent  Content as string                       return await Task FromResult responseMessage

User · Answer

HttpClient s extensibility lies in the HttpMessageHandler passed to the constructor  Its intent is to allow platform specific implementations  but you can also mock it  There s no need to create a decorator wrapper for HttpClient   If you d prefer a DSL to using Moq  I have a library up on GitHub Nuget that makes things a little easier  https   github com richardszalay mockhttp  var mockHttp   new MockHttpMessageHandler        Setup a respond for the user api  including a wildcard in the URL  mockHttp When  http   localost api user              Respond  application json      name     Test McGee         Respond with JSON     Inject the handler or client into your application code var client   new HttpClient mockHttp    var response   await client GetAsync  http   localhost api user 1234       or without async  var response   client GetAsync  http   localhost api user 1234   Result   var json   await response Content ReadAsStringAsync        No network connection required Console Write json        name     Test McGee

User · Answer

DO NOT have a wrapper that creates a new instance of HttpClient  If you do that  you will run out of sockets at runtime  even though you are disposing the HttpClient object   If using MOQ  the correct way to do this is to add using Moq Protected  to your test and then write code like the following  var response   new HttpResponseMessage HttpStatusCode OK        Content   new StringContent  quot It worked  quot      var mockHttpMessageHandler   new Mock lt HttpMessageHandler gt     mockHttpMessageHandler      Protected        Setup lt Task lt HttpResponseMessage gt  gt            quot SendAsync quot           ItExpr IsAny lt HttpRequestMessage gt             ItExpr IsAny lt CancellationToken gt          ReturnsAsync      gt  response     var httpClient   new HttpClient mockHttpMessageHandler Object

User · Answer

One alternative would be to setup a stub HTTP server that returns canned responses based on pattern matching the request url  meaning you test real HTTP requests not mocks  Historically this would have taken significant develoment effort and would have been far to slow to be considered for unit testing  however OSS library WireMock net is easy to use and fast enough to be run with lots of tests so may be worth considering  Setup is a few lines of code   var server   FluentMockServer Start    server Given        Request Create          WithPath   some thing   UsingGet            RespondWith         Response Create           WithStatusCode 200          WithHeader  Content-Type    application json           WithBody    attr   value             You can find a more details and guidance on using wiremock in tests here

User · Answer

Since HttpClient use SendAsync method to perform all HTTP Requests  you can override SendAsync method and mock the HttpClient   For that wrap creating HttpClient to a interface  something like below   public interface IServiceHelper       HttpClient GetClient        Then use above interface for dependency injection in your service  sample below   public class SampleService       private readonly IServiceHelper serviceHelper       public SampleService IServiceHelper serviceHelper                this serviceHelper   serviceHelper             public async Task lt HttpResponseMessage gt  Get int dummyParam                try                       var dummyUrl    http   www dummyurl com api controller     dummyParam              var client   serviceHelper GetClient                HttpResponseMessage response   await client GetAsync dummyUrl                               return response                    catch  Exception                           log              throw                      Now in unit test project create a helper class for mocking SendAsync   Here it is a FakeHttpResponseHandler class which is inheriting DelegatingHandler which will provide an option to override the SendAsync method  After overriding the SendAsync method need to setup a response for each HTTP Request which is calling SendAsync method  for that create a Dictionary with key as Uri and value as HttpResponseMessage so that whenever there is a HTTP Request and if the Uri matches SendAsync will return the configured HttpResponseMessage    public class FakeHttpResponseHandler   DelegatingHandler       private readonly IDictionary lt Uri  HttpResponseMessage gt  fakeServiceResponse      private readonly JavaScriptSerializer javaScriptSerializer      public FakeHttpResponseHandler                 fakeServiceResponse    new Dictionary lt Uri  HttpResponseMessage gt             javaScriptSerializer    new JavaScriptSerializer                    lt summary gt          Used for adding fake httpResponseMessage for the httpClient operation           lt  summary gt           lt typeparam name  TQueryStringParameter  gt  query string parameter  lt  typeparam gt           lt param name  uri  gt Service end point URL  lt  param gt           lt param name  httpResponseMessage  gt  Response expected when the service called  lt  param gt      public void AddFakeServiceResponse Uri uri  HttpResponseMessage httpResponseMessage                fakeServiceResponse Remove uri           fakeServiceResponse Add uri  httpResponseMessage                   lt summary gt          Used for adding fake httpResponseMessage for the httpClient operation having query string parameter           lt  summary gt           lt typeparam name  TQueryStringParameter  gt  query string parameter  lt  typeparam gt           lt param name  uri  gt Service end point URL  lt  param gt           lt param name  httpResponseMessage  gt  Response expected when the service called  lt  param gt           lt param name  requestParameter  gt Query string parameter  lt  param gt      public void AddFakeServiceResponse lt TQueryStringParameter gt  Uri uri  HttpResponseMessage httpResponseMessage  TQueryStringParameter requestParameter                var serilizedQueryStringParameter   javaScriptSerializer Serialize requestParameter           var actualUri   new Uri string Concat uri  serilizedQueryStringParameter            fakeServiceResponse Remove actualUri           fakeServiceResponse Add actualUri  httpResponseMessage                 all method in HttpClient call use SendAsync method internally so we are overriding that method here      protected override Task lt HttpResponseMessage gt  SendAsync HttpRequestMessage request  CancellationToken cancellationToken                if fakeServiceResponse ContainsKey request RequestUri                         return Task FromResult fakeServiceResponse request RequestUri                       return Task FromResult new HttpResponseMessage HttpStatusCode NotFound                        RequestMessage   request              Content   new StringContent  Not matching fake found                         Create a new implementation for IServiceHelper by mocking framework or like below   This FakeServiceHelper class we can use to inject the FakeHttpResponseHandler class so that whenever the HttpClient created by this class it will use FakeHttpResponseHandler class instead of the actual implementation    public class FakeServiceHelper   IServiceHelper       private readonly DelegatingHandler delegatingHandler       public FakeServiceHelper DelegatingHandler delegatingHandler                this delegatingHandler   delegatingHandler             public HttpClient GetClient                 return new HttpClient delegatingHandler             And in test configure FakeHttpResponseHandler class by adding the Uri and expected HttpResponseMessage   The Uri should be the actual serviceendpoint Uri so that when the overridden SendAsync method is called from actual service implementation it will match the Uri in Dictionary and respond with the configured HttpResponseMessage  After configuring inject the FakeHttpResponseHandler object to the fake IServiceHelper implementation  Then inject the FakeServiceHelper class to the actual service which will make the actual service to use the override SendAsync method    TestClass  public class SampleServiceTest       private FakeHttpResponseHandler fakeHttpResponseHandler        TestInitialize      public void Initialize                 fakeHttpResponseHandler   new FakeHttpResponseHandler                TestMethod      public async Task GetMethodShouldReturnFakeResponse                 Uri uri   new Uri  http   www dummyurl com api controller             const int dummyParam   123456          const string expectdBody    Expected Response            var expectedHttpResponseMessage   new HttpResponseMessage HttpStatusCode OK                        Content   new StringContent expectdBody                      fakeHttpResponseHandler AddFakeServiceResponse uri  expectedHttpResponseMessage  dummyParam            var fakeServiceHelper   new FakeServiceHelper fakeHttpResponseHandler            var sut   new SampleService fakeServiceHelper            var response   await sut Get dummyParam            var responseBody   await response Content ReadAsStringAsync             Assert AreEqual HttpStatusCode OK  response StatusCode           Assert AreEqual expectdBody  responseBody             GitHub Link   which is having sample implementation

User · Answer

To add my 2 cents  To mock specific http request methods either Get or Post  This worked for me  mockHttpMessageHandler Protected   Setup lt Task lt HttpResponseMessage gt  gt   quot SendAsync quot   ItExpr Is lt HttpRequestMessage gt  a   gt  a Method    HttpMethod Get   ItExpr IsAny lt CancellationToken gt                                                      Returns Task FromResult new HttpResponseMessage                                                                                                         StatusCode   HttpStatusCode OK                                                      Content   new StringContent  quot  quot                                                        Verifiable

User · Answer

I agree with some of the other answers that the best approach is to mock HttpMessageHandler rather than wrap HttpClient   This answer is unique in that it still injects HttpClient  allowing it to be a singleton or managed with dependency injection   HttpClient is intended to be instantiated once and re-used throughout the life of an application    Source   Mocking HttpMessageHandler can be a little tricky because SendAsync is protected   Here s a complete example  using xunit and Moq  using System  using System Net  using System Net Http  using System Threading  using System Threading Tasks  using Moq  using Moq Protected  using Xunit     Use nuget to install xunit and Moq  namespace MockHttpClient       class Program           static void Main string   args                var analyzer   new SiteAnalyzer Client               var size   analyzer GetContentSize  quot http   microsoft com quot   Result              Console WriteLine   quot Size   size  quot                       private static readonly HttpClient Client   new HttpClient       Singleton            public class SiteAnalyzer           public SiteAnalyzer HttpClient httpClient                 httpClient   httpClient                     public async Task lt int gt  GetContentSize string uri                        var response   await  httpClient GetAsync  uri                var content   await response Content ReadAsStringAsync                return content Length                     private readonly HttpClient  httpClient             public class SiteAnalyzerTests            Fact          public async void GetContentSizeReturnsCorrectLength                    Arrange             const string testContent    quot test content quot               var mockMessageHandler   new Mock lt HttpMessageHandler gt                 mockMessageHandler Protected                    Setup lt Task lt HttpResponseMessage gt  gt   quot SendAsync quot   ItExpr IsAny lt HttpRequestMessage gt     ItExpr IsAny lt CancellationToken gt                      ReturnsAsync new HttpResponseMessage                       StatusCode   HttpStatusCode OK                      Content   new StringContent testContent                                  var underTest   new SiteAnalyzer new HttpClient mockMessageHandler Object                    Act             var result   await underTest GetContentSize  quot http   anyurl quot                    Assert             Assert Equal testContent Length  result

User · Answer

Here s a simple solution  which worked well for me   Using the moq mocking library      ARRANGE var handlerMock   new Mock lt HttpMessageHandler gt  MockBehavior Strict   handlerMock     Protected         Setup the PROTECTED method to mock     Setup lt Task lt HttpResponseMessage gt  gt          SendAsync         ItExpr IsAny lt HttpRequestMessage gt           ItExpr IsAny lt CancellationToken gt               prepare the expected response of the mocked http call     ReturnsAsync new HttpResponseMessage              StatusCode   HttpStatusCode OK        Content   new StringContent     id  1  value   1                 Verifiable        use real http client with mocked handler here var httpClient   new HttpClient handlerMock Object       BaseAddress   new Uri  http   test com         var subjectUnderTest   new MyTestClass httpClient       ACT var result   await subjectUnderTest     GetSomethingRemoteAsync  api test whatever        ASSERT result Should   NotBeNull       this is fluent assertions here    result Id Should   Be 1       also check the  http  call was like we expected it var expectedUri   new Uri  http   test com api test whatever     handlerMock Protected   Verify      SendAsync      Times Exactly 1      we expected a single external request    ItExpr Is lt HttpRequestMessage gt  req   gt        req Method    HttpMethod Get     we expected a GET request        amp  amp  req RequestUri    expectedUri    to this uri          ItExpr IsAny lt CancellationToken gt         Source  https   gingter org 2018 07 26 how-to-mock-httpclient-in-your-net-c-unit-tests

User · Answer

I did something very simple  as I was in a DI environment    public class HttpHelper   IHttpHelper       private ILogHelper  logHelper       public HttpHelper ILogHelper logHelper                 logHelper   logHelper             public virtual async Task lt HttpResponseMessage gt  GetAsync string uri  Dictionary lt string  string gt  headers   null                HttpResponseMessage response          using  var client   new HttpClient                          if  headers    null                                foreach  var h in headers                                        client DefaultRequestHeaders Add h Key  h Value                                               response   await client GetAsync uri                      return response             public async Task lt T gt  GetAsync lt T gt  string uri  Dictionary lt string  string gt  headers   null                             rawResponse   await GetAsync uri  headers                           and the mock is        TestInitialize      public void Initialize                             httpHelper   new Mock lt HttpHelper gt   logHelper Object    CallBase   true                           TestMethod      public async Task SuccessStatusCode WithAuthHeader                               httpHelper Setup m   gt  m GetAsync  uri  myHeaders   Returns              Task lt HttpResponseMessage gt  Factory StartNew      gt                                return new HttpResponseMessage System Net HttpStatusCode OK                                        Content   new StringContent JsonConvert SerializeObject  testData                                                        var result   await  httpHelper Object GetAsync lt TestDTO gt                 Assert AreEqual

[c#] Mocking HttpClient in unit tests

Examples related to c#

Examples related to unit-testing

Examples related to moq