Develop Reference

.Net Core - Docker Linux memory usage keeps increasing

I am bit frustrated now what's wrong with my code, and I hope you guys can help me with it, so here are the things I have tried.
so I tried making the HttpClient static, and I tried using the IHttpClientFactory.CreateClient() and I even added this on my .csproj
<ServerGarbageCollection>false</ServerGarbageCollection>
Here is the sample code that I have been doing
public class TestController : BaseController
{
private static HttpClient _httpClient = new();
public TestController()
{
}
[HttpGet("bills")]
public async Task<IActionResult> GetBillsPresentment([FromQuery] GetBillPresentmentQuery query)
{
if (!query.AccountNumber.Contains("-"))
query.AccountNumber = FormatAccountNumber(query.AccountNumber);
var billDetails = await GetBillDetail(query.AccountNumber);
if (billDetails == null)
throw new ProviderProcessException(ProviderErrorCode.INVALID_ACCOUNT_NUMBER);
return Ok(new BillPresentmentVm
{
User = new CustomerDto
{
CustomerName = billDetails.Name
},
Billing = new BillingDto
{
AccountNumber = query.AccountNumber,
DueDate = DateTime.Parse(billDetails.LastReadDate).AddMonths(1),
Outstanding = !string.IsNullOrEmpty(billDetails.Arrears) ? decimal.Parse(billDetails.Arrears) : null
}
});
}
private async Task<ResponseModel> GetBillDetail(string accountNumber)
{
try
{
var payload = new { accno = accountNumber };
string json = JsonConvert.SerializeObject(payload);
var buffer = System.Text.Encoding.UTF8.GetBytes(json);
using var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await _httpClient.PostAsync("https://test.com", byteContent);
if (!response.IsSuccessStatusCode)
throw new ProviderProcessException(ProviderErrorCode.BILLING_CYCLE_UNAVAILABLE);
var result = await response.Content.ReadAsStringAsync();
if (result == "Accno not found!") return null;
var data = JsonConvert.DeserializeObject<ResponseModel>(result);
return data;
}
catch (Exception)
{
throw new ProviderProcessException(ProviderErrorCode.BILLING_CYCLE_UNAVAILABLE);
}
}
private static string FormatAccountNumber(string accountNumber)
{
return string.Format("{0:#######-########}", Convert.ToInt64(accountNumber));
}
}
And here's the docker memory usage
The memory usage keeps increasing after a request. Can someone explains me why it is not decreasing?
Thank you very much in advance

I solve this issue using IHttpClientFactory instead of HttpClient.
https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/use-httpclientfactory-to-implement-resilient-http-requests

I use some thing like this and it works fine on large amount of requests per second and it use memory in normal way .
namespace BehsaLoyalty.ApiClient
{
public class ApiRepo : IApiRepo
{
private readonly IHttpClientFactory _HttpClientFactory;
public ApiRepo (IHttpClientFactory httpClientFactory)
{
_HttpClientFactory = httpClientFactory;
}
public async Task<ResponseModel> PostMyObject(Myobject model, CancellationToken cancellationToken)
{
HttpClient httpClient = _HttpClientFactory.CreateClient("ApiDestinationURI");
using HttpRequestMessage request = new(HttpMethod.Post, "/blah/blah");
request.Content = new StringContent(JsonSerializer.Serialize(model));
request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpResponseMessage response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseContentRead, cancellationToken);
response.EnsureSuccessStatusCode();
string createdContent = await response.Content.ReadAsStringAsync();
ResponseModel ResponseReturn = JsonSerializer.Deserialize<ResponseModel>(createdContent);
return ResponseReturn;
}
}
}

Polly FallbackAsync policy with a dynamic action that raises an event so that the request / response can be written to a database

I'm looking for a way to attach a generic Polly fallback policy to my typed HttpClient. My policy gets applied to certain request types as and when required, otherwise it applies a NoOpPolicy. Im interested in the onFallbackAsync Task. I need to save the request/response to a database table, but I'm struggling to figure out how to apply this because I can't see how to inject a dependency. I seem to be missing something obvious, but I don't know what. Can this be done with a delegating handler?
My typed client basically looks like this, and is used for a variety of different API calls:
public class ApiClient : IApiClient
{
private readonly HttpClient _httpClient;
private readonly ILogger _logger;
private HttpRequestMessage _httpRequestMessage;
private HttpContent _httpContent;
private IDictionary<string, string> _queryParameters;
public ApiClient(HttpClient httpClient, ILogger logger)
{
_httpClient = httpClient;
_logger = logger;
_httpRequestMessage = new HttpRequestMessage();
_queryParameters = new Dictionary<string, string>();
}
public void SetUrl(string urlPath)
{
urlPath = urlPath.TrimEnd('/');
_httpClient.BaseAddress = new Uri(urlPath);
}
public void SetQueryParamters(IDictionary<string, string> parameters)
{
_queryParameters = parameters;
}
public void AddQueryParamter(string key, string value)
{
_queryParameters.Add(key, value);
}
public async Task<T> Get<T>()
{
_httpRequestMessage.Method = HttpMethod.Get;
return await EnvokeService<T>();
}
public async Task<T> PostJsonAsync<T>(object body)
{
var settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore
};
_httpContent = new JsonContent(JsonConvert.SerializeObject(body, settings));
_httpRequestMessage.Method = HttpMethod.Post;
return await EnvokeService<T>();
}
private async Task<T> EnvokeService<T>()
{
string responseContent = null;
try
{
_httpRequestMessage.Content = _httpContent;
_httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
var responseMessage = await _httpClient.SendAsync(_httpRequestMessage, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
responseContent = await responseMessage.Content.ReadAsStringAsync();
if (responseMessage.IsSuccessStatusCode)
{
T result;
var serializer = new JsonSerializer();
using (var sr = new StreamReader(await responseMessage.Content.ReadAsStreamAsync()))
using (var jsonTextReader = new JsonTextReader(sr))
{
result = serializer.Deserialize<T>(jsonTextReader);
}
_logger.Debug(logMessage);
return result;
}
throw new HttpRequestException($"Error Code: {responseMessage.StatusCode}. Response: {responseContent}");
}
catch (Exception e)
{
_logger.Exception(e, "Error");
throw;
}
}
}
It is setup like this:
public static class ApiHttpClientConfigurator
{
public static void AddApiHttpClient (this IServiceCollection services)
{
IPolicyRegistry<string> registry = services.AddPolicyRegistry();
registry.Add("WaitAndRetryPolicy", ResiliencePolicies.GetHttpPolicy(new TimeSpan(0, 1, 0)));
registry.Add("NoOpPolicy", Policy.NoOpAsync().AsAsyncPolicy<HttpResponseMessage>());
services.AddHttpClient<ApiHttpClient>().AddPolicyHandlerFromRegistry(PolicySelector);
services.AddSingleton<IApiHttpClientFactory, ApiHttpClientFactory>();
}
private static IAsyncPolicy<HttpResponseMessage> PolicySelector(IReadOnlyPolicyRegistry<string> policyRegistry, HttpRequestMessage httpRequestMessage)
{
// if we have a message of type X then apply the policy
if (httpRequestMessage.RequestUri.AbsoluteUri.Contains("/definitely/apply/a/retry/policy"))
{
return policyRegistry.Get<IAsyncPolicy<HttpResponseMessage>>("WaitAndRetryPolicy");
}
return policyRegistry.Get<IAsyncPolicy<HttpResponseMessage>>("NoOpPolicy");
}
}
Registered as so:
services.AddApiHttpClient();
My policies are defined as such:
public static class ResiliencePolicies
{
public static IAsyncPolicy<HttpResponseMessage> HttpFallBackPolicy
{
get => Policy<HttpResponseMessage>.Handle<Exception>().FallbackAsync(new HttpResponseMessage(HttpStatusCode.InternalServerError), d =>
{
// TODO: publish event
InstanceOfMediatr.Publish(new RequestFailedEvent(request/response/data/here))
Log.Warning($"Fallback: {d.Exception.GetType().Name} {d.Exception.Message}");
return Task.CompletedTask;
});
}
public static IAsyncPolicy<HttpResponseMessage> HttpRetryPolicy
{
get => HttpPolicyExtensions.HandleTransientHttpError()
.Or<TimeoutRejectedException>()
.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(retryAttempt * 0.5));
}
public static IAsyncPolicy<HttpResponseMessage> GetHttpTimeoutPolicy(TimeSpan timeSpan) =>
Policy.TimeoutAsync<HttpResponseMessage>(timeSpan);
public static IAsyncPolicy<HttpResponseMessage> GetHttpPolicy(TimeSpan timeout) =>
Policy.WrapAsync(HttpFallBackPolicy, HttpRetryPolicy, GetHttpTimeoutPolicy(timeout));
}
The final part of the puzzle would appear to be, how can I complete the TODO section above? I seem to need a dynamic fallback action, but I'm really not sure how to implement it, or whether or not it is even possible.

Just in case anyone else comes across this problem, there are two ways to solve it depending upon your requirements (using AddPolicyHandlerFromRegistry() or AddPolicyHandler()).
Through IServiceProvider
AddPolicyHandler() has a convenient overload where you can inject IServiceProvider:
.AddPolicyHandler((provider, message) =>
HttpPolicyExtensions
.HandleTransientHttpError()
.FallbackAsync(
fallbackValue: new HttpResponseMessage(HttpStatusCode.InternalServerError),
onFallbackAsync: (result, context) =>
{
var publisher = provider.GetService<IPublisher>();
publisher.Publish(new HttpRequestFallbackEvent());
return Task.CompletedTask;
}))
Through Context
If you are using a PolicyRegistry and AddPolicyHandlerFromRegistry(), then it is easier to use the Context as described here. First extend the Polly's Context:
public static class ContextExtensions
{
private static readonly string PublisherKey = "PublisherKey";
public static Context WithDependencies(this Context context, IPublisher publisher)
{
context[PublisherKey] = publisher;
return context;
}
public static IPublisher GetPublisher(this Context context)
{
if (context.TryGetValue(PublisherKey, out object publisher))
{
return publisher as IPublisher;
}
return null;
}
}
Then in your client, inject your dependency (i.e. IPublisher) and add it to the new Context and add that to the executing context:
var context = new Context().WithDependencies(_publisher);
request.SetPolicyExecutionContext(context);
var responseMessage = await _httpClient.SendAsync(request)
Now you can use that in your registered and selected policy:
private static IAsyncPolicy<HttpResponseMessage> FallbackPolicy()
{
return HttpPolicyExtensions
.HandleTransientHttpError()
.Or<Exception>()
.FallbackAsync(
fallbackValue: new HttpResponseMessage(HttpStatusCode.InternalServerError),
onFallbackAsync: (result, context) =>
{
var publisher = context.GetPublisher();
publisher.Publish(new HttpRequestFallbackEvent());
return Task.CompletedTask;
}));
}

Unable to resolve service for type 'System.Net.Http.HttpClient' using DI

I writing phone verification functional via Twilio and using System.Net.Http.HttpClient
I inject it in AppService like this
public class TwilioVerifyClientAppService: IVerifyPhone
{
private readonly HttpClient _client;
public TwilioVerifyClientAppService(HttpClient client)
{
_client = client;
}
public async Task<TwilioSendVerificationCodeResponse> StartVerification(int countryCode, string phoneNumber)
{
var requestContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("via", "sms"),
new KeyValuePair<string, string>("country_code", countryCode.ToString()),
new KeyValuePair<string, string>("phone_number", phoneNumber),
});
var response = await _client.PostAsync("protected/json/phones/verification/start", requestContent);
var content = await response.Content.ReadAsStringAsync();
// this will throw if the response is not valid
return JsonConvert.DeserializeObject<TwilioSendVerificationCodeResponse>(content);
}
public async Task<TwilioCheckCodeResponse> CheckVerificationCode(int countryCode, string phoneNumber,
string verificationCode)
{
var queryParams = new Dictionary<string, string>()
{
{"country_code", countryCode.ToString()},
{"phone_number", phoneNumber},
{"verification_code", verificationCode},
};
var url = QueryHelpers.AddQueryString("protected/json/phones/verification/check", queryParams);
var response = await _client.GetAsync(url);
var content = await response.Content.ReadAsStringAsync();
// this will throw if the response is not valid
return JsonConvert.DeserializeObject<TwilioCheckCodeResponse>(content);
}
}
}
When I try to run method, I get this error
Here is how I call this method in controller
[ApiController]
[Route("api/[controller]/[action]")]
public class ProfileController : ControllerBase
{
private readonly IUserProfile _profileAppService;
private readonly UserManager<AppUser> _userManager;
private readonly IFileUpload _fileUpload;
private readonly IVerifyPhone _verifyPhone;
public ProfileController(IUserProfile profileAppService,
UserManager<AppUser> userManager, IFileUpload fileUpload, IVerifyPhone verifyPhone)
{
_profileAppService = profileAppService;
_userManager = userManager;
_fileUpload = fileUpload;
_verifyPhone = verifyPhone;
}
[Authorize]
[HttpPost]
public async Task<IActionResult> ConfirmCodeSend([FromForm] PhoneInputDto input)
{
var result = await _verifyPhone.StartVerification(input.DialingCode, input.PhoneNumber);
if (result.Success)
{
return Ok("Code sent");
}
return BadRequest();
}
[Authorize]
[HttpPost]
public async Task<IActionResult> ConfirmCodeCheck([FromForm] PhoneInputDto input)
{
var result =
await _verifyPhone.CheckVerificationCode(input.DialingCode, input.PhoneNumber, input.VerificationCode);
if (result.Success)
{
return Ok("Phone verified");
}
return BadRequest();
}
}
}
An unhandled exception occurred while processing the request. InvalidOperationException: Unable to resolve service for type
'System.Net.Http.HttpClient' while attempting to activate
'TooSeeWeb.Infrastructure.AppServices.UserProfile.TwilioVerifyClientAppService'.
In Startup.cs
I register my interface like this
services.AddScoped<IVerifyPhone, TwilioVerifyClientAppService>();
I tried to write this in Startup.cs
services.AddHttpClient<TwilioVerifyClientAppService>();
But I still see this error.
How I can solve this?

You registered the class as a typed client but not the interface, yet try to inject the interface as a dependency into the controller.
Update the typed client registration to include the interface
services.AddHttpClient<IVerifyPhone, TwilioVerifyClientAppService>();
provided TwilioVerifyClientAppService is derived from IVerifyPhone
public class TwilioVerifyClientAppService: IVerifyPhone {
//...
}
and remove the scoped registration
services.AddScoped<IVerifyPhone, TwilioVerifyClientAppService>();

Testing controller with xUnit

I have webapi where it needs to call some other endpoint and get data.
My current code as follows
//http client implementation
public interface IHttpClientFactory
{
HttpClient Create();
}
public class HttpClientFactory : IHttpClientFactory
{
private readonly ApplicationSettings _applicationSettings;
HttpClient _httpClient;
public HttpClientFactory(IOptions<ApplicationSettings> settings)
{
_applicationSettings = settings.Value;
}
public HttpClient Create()
{
if (_httpClient != null)
return _httpClient;
var client = new HttpClient()
{
BaseAddress = new Uri($"{_applicationSettings.BaseUrl}")
};
_httpClient = client;
return _httpClient;
}
}
public interface IGetItemsQuery
{
Task<IEnumerable<T>> Execute<T>(string url);
}
public class GetItemQuery: IGetItemsQuery
{
private readonly IHttpClientFactory _httpClientFactory;
public GetPhotosQuery(IHttpClientFactory httpClientFactory)
{
_httpClientFactory = httpClientFactory;
}
public async Task<IEnumerable<T>> Execute<T>(string url)
{
using (var response = await _httpClientFactory.Create().GetAsync($"{url}").ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
var resp = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var items = JArray.Parse(resp);
return items.ToObject<T[]>();
}
}
In my controller part
private readonly IGetItemsQuery _getItemsQuery;
public HomeController(IGetItemsQuery getItemsQuery)
{
_getItemsQuery = getItemsQuery;
}
appsettings
"ApplicationSettings": {
"BaseUrl": "http://someendpoint.com/"
}
Startup
services.Configure<ApplicationSettings>(Configuration.GetSection("ApplicationSettings"));
services.AddScoped<IGetItemsQuery, GetPhotosQuery>();
services.AddScoped<IHttpClientFactory, HttpClientFactory>();
I want to try something like below in my test
[Fact]
public void Test_Index()
{
// Arrange
var itemsQuery = new Mock<IGetItemsQuery>();
var controller = new HomeController(itemsQuery.Object);
// Act
var result = controller.Index();
// Assert
var viewResult = Assert.IsType<ViewResult>(result);
Assert.Null(viewResult.ViewName);
}
This is creating mock IGetItemsQuery but this isn't mocking the actual IHttpClientFactory.
Is there a way to do this

Based on your design with the abstracted dependencies there would be no need to mock a client factory in order to unit test the controller.
As you have done in your test, you mock IGetItemsQuery, but you have not set it up to behave as expected when invoked in the test.
If, for example, the controller method under test look something like this
private readonly IGetItemsQuery getItemsQuery;
public HomeController(IGetItemsQuery getItemsQuery) {
this.getItemsQuery = getItemsQuery;
}
public async Task<IActionResult> Index() {
var url = "....";
var items = await getItemsQuery.Execute<MyItem>(url);
return View(items);
}
Then an isolated unit test for the Index action as the method under test could look something like
[Fact]
public async Task Index_Should_Return_View_With_Items() {
// Arrange
var itemsQuery = new Mock<IGetItemsQuery>();
var items = new MyItem[] {
new MyItem(),
new MyItem()
};
itemsQuery.Setup(_ => _.Execute<MyItem>(It.IsAny<string>()))
.ReturnsAsync(items);
var controller = new HomeController(itemsQuery.Object);
// Act
var result = await controller.Index();
// Assert
var viewResult = Assert.IsType<ViewResult>(result);
Assert.Null(viewResult.ViewName);
}

Moq Unit Test case - ASP.NET MVC with WebAPI

I am trying to UnitTest my MVC Controller method, which internally makes call to an WebAPI(using HttpClient). I'm not able to figure out how can I fake the httpclient call, as it should not go for actual request. Below is my source code and unit test case. Test case fails, as the call goes for actual HttpRequest (An error occurred while sending the request. A connection with the server could not be established)
Base MVC Controller
public class BaseController : Controller
{
public virtual async Task<T> PostRequestAsync<T>(string endpoint, Object obj) where T : class
{
var address = "http://localhost:5001/api/Login";
StringContent json = new StringContent(JsonConvert.SerializeObject(obj), Encoding.UTF8, "");
using (var client = new HttpClient())
{
try
{
var response = await client.PostAsync(address, json); // Test case fails here
if (response.IsSuccessStatusCode)
{
string data = await response.Content.ReadAsStringAsync();
return JsonConvert.DeserializeObject<T>(data);
}
return default(T);
}
catch (WebException)
{
throw;
}
}
}
}
Derived class Controller
public class AccountController : BaseController
{
public AccountController() : base()
{
}
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var result = await PostRequestAsync<ResultObject>(Constants.UserLoginAPI, model); // this is call for basecontroller method which actually has HttpClient call.
var output = JsonConvert.DeserializeObject<UserObject>(result.Object.ToString());
if (result.Succeeded && !string.IsNullOrEmpty(output.Email))
{
var userRoleInfo = await GetRequestAsync<List<UserRoleObject>>(string.Format(Constants.GetUserRoleInfoAPI, output.Email));
if (userRoleInfo != null)
{
var claims = new List<Claim>
{
new Claim(ClaimTypes.Name, output.Email),
new Claim("Username", output.UserName)
};
var claimsIdentity = new ClaimsIdentity(
claims, CookieAuthenticationDefaults.AuthenticationScheme);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), new AuthenticationProperties { IsPersistent = model.RememberMe });
}
return View(new LoginViewModel());
}
}
return View(model);
}
}
TestMethod
[Fact]
public async Task LoginTest_Post_UserHasInValidCredentials()
{
// Arrange
var mockModel = new LoginViewModel { };
mockModel.Password = "TestPassword";
mockModel.Email = "test#test.com";
mockModel.RememberMe = false;
var commonResult = new CommonResult { Object = null, Succeeded = false, StatusCode = Common.Enums.ResponseStatusCodeEnum.Success };
var email = string.Empty;
var mockHttp = new MockHttpMessageHandler();
var mockBase = new Mock<BaseController>() { CallBase=true};
mockHttp.When("http://127.0.0.1:5001/*").Respond("application/json", "{'name' : 'Test McGee'}"); // Respond with JSON - using RichardSzalay.MockHttp;
//// Inject the handler or client into your application code
StringContent jsonInput = new StringContent(JsonConvert.SerializeObject(mockModel), Encoding.UTF8, "application/json");
var client = new HttpClient(mockHttp);
var response = await client.PostAsync("http://127.0.0.1:5001" + Constants.UserLoginAPI, jsonInput);
var json = await response.Content.ReadAsStringAsync();
mockBase.Setup(test => test.PostRequestAsync<CommonResult>(Constants.UserLoginAPI, mockModel)).Returns(Task.FromResult(CommonResult()));
var result = await accountController.Login(mockModel); // test case fails, as the call goes for actual HttpRequest (An error occurred while sending the request. A connection with the server could not be established)
//var viewResult = Assert.IsType<ViewResult>(result);
Assert.NotNull(commonResult);
Assert.False(commonResult.Succeeded);
Assert.Empty(email);
//Assert.NotNull(model.Email);
}

Tight coupling to HttpClient in the base controller makes it difficult to test derived classes in isolation. Review and refactor that code to follow DI.
No need to have a base controller and it is usually not advised.
Extract PostRequestAsync out into its own service abstraction and implementation.
public interface IWebService {
Task<T> PostRequestAsync<T>(string endpoint, Object obj) where T : class;
Task<T> GetRequestAsync<T>(string endpoint) where T : class;
}
public class WebService : IWebService {
static HttpClient client = new HttpClient();
public virtual async Task<T> PostRequestAsync<T>(string requestUri, Object obj) where T : class {
var content = new StringContent(JsonConvert.SerializeObject(obj), Encoding.UTF8, "");
try {
var response = await client.PostAsync(requestUri, content); // Test case fails here
if (response.IsSuccessStatusCode) {
string data = await response.Content.ReadAsStringAsync();
return JsonConvert.DeserializeObject<T>(data);
}
return default(T);
} catch (WebException) {
throw;
}
}
public async Task<T> GetRequestAsync<T>(string requestUri) where T : class {
try {
var response = await client.GetAsync(requestUri);
if (response.IsSuccessStatusCode) {
string data = await response.Content.ReadAsStringAsync();
return JsonConvert.DeserializeObject<T>(data);
}
return default(T);
} catch (WebException) {
throw;
}
}
}
Refactor derived controllers to depend on the service abstraction
public class AccountController : Controller {
private readonly IWebService webService;
public AccountController(IWebService webService) {
this.webService = webService;
}
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) {
if (ModelState.IsValid) {
var result = await webService.PostRequestAsync<ResultObject>(Constants.UserLoginAPI, model);
if (result.Succeeded) {
var output = JsonConvert.DeserializeObject<UserObject>(result.Object.ToString());
if (output != null && !string.IsNullOrEmpty(output.Email)) {
var userRoleInfo = await webService.GetRequestAsync<List<UserRoleObject>>(string.Format(Constants.GetUserRoleInfoAPI, output.Email));
if (userRoleInfo != null) {
var claims = new List<Claim>
{
new Claim(ClaimTypes.Name, output.Email),
new Claim("Username", output.UserName)
};
var claimsIdentity = new ClaimsIdentity(
claims, CookieAuthenticationDefaults.AuthenticationScheme);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), new AuthenticationProperties { IsPersistent = model.RememberMe });
}
return View(new LoginViewModel());
}
}
}
return View(model);
}
}
This should now allow you to mock the dependency when testing in isolation without adverse side effects.
[Fact]
public async Task LoginTest_Post_UserHasInValidCredentials() {
// Arrange
var mockModel = new LoginViewModel { };
mockModel.Password = "TestPassword";
mockModel.Email = "test#test.com";
mockModel.RememberMe = false;
var commonResult = new CommonResult {
Object = null,
Succeeded = false,
StatusCode = Common.Enums.ResponseStatusCodeEnum.Success
};
var mockWebService = new Mock<IWebService>();
var accountController = new AccountController(mockWebService.Object) {
//HttpContext would also be needed
};
mockWebService
.Setup(test => test.PostRequestAsync<CommonResult>(Constants.UserLoginAPI, mockModel))
.ReturnsAsync(commonResult);
//
//Act
var result = await accountController.Login(mockModel);
//Assert
//...Make assertions here
}

I would inject an IHttpClient interface, and in release register a HttpClient wrapper that implements that interface.