如何使用本地 json 文件从模拟端点获取结果？

Question

I'm pretty new in .NET and I have to mock GetCustomerDetailsAsync endpoint using a local json file in order to get the file results and create a way to enable and disable the mocking mechanism. Here is the handler where I have to implement the logic

  public class GetCustomerDetailsQueryHandler : IRequestHandler<GetCustomerDetailsQuery, CustomerInsertionModel>
{
    private readonly ICustomerApiClient _customerApiClient;
    private readonly IAccountApiClientGraphQl _accountApiClientGraphQl;
    private readonly IMapper _mapper;
    private readonly IMediator _mediator;
    private readonly IOptions<CommonFeaturesOptions> _commonFeaturesOptions;
    public GetCustomerDetailsQueryHandler(ICustomerApiClient customerApiClient,
                                          IAccountApiClientGraphQl accountApiClientGraphQl,
                                          IMediator mediator,
                                          IMapper mapper,
                                          IOptions<CommonFeaturesOptions> commonFeaturesOptions)
    {
        _customerApiClient = customerApiClient ?? throw new ArgumentNullException(nameof(customerApiClient));
        _accountApiClientGraphQl = accountApiClientGraphQl ?? throw new ArgumentNullException(nameof(accountApiClientGraphQl));
        _mediator = mediator;
        _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
        _commonFeaturesOptions = commonFeaturesOptions ?? throw new ArgumentNullException(nameof(commonFeaturesOptions));
    }

 public async Task<CustomerInsertionModel> Handle(GetCustomerDetailsQuery request, CancellationToken cancellationToken)
    {
        //if(!EnablePostfixations){
        //var customerApiResponse = (await _customerApiClient.GetCustomerDetailsAsync(_mapper.Map<GetCustomerDetailsRequest>(request)))
        //                                  .CustomerDetails.FirstOrDefault();
        //}
        //else
        //{
        //var response = await _customerApiClient.GetCustomerDetailsAsync(
        //                             _mapper.Map<GetCustomerDetailsRequest>((request, _commonFeaturesOptions.Value)));
       var customerApiResponse = (await _customerApiClient.GetCustomerDetailsAsync(_mapper.Map<GetCustomerDetailsRequest>(request)))
                              .CustomerDetails.FirstOrDefault();
          if (customerApiResponse is null)
        {
            return new CustomerInsertionModel((false, string.Empty))
                        .MarkCustomerAsNotFound();
        }

        var customer = new CustomerInsertionModel(customerApiResponse.Cif,
            customerApiResponse.CnpCui,
            customerApiResponse.Category,
            customerApiResponse.Insolvency,
            request.AddInsolvency,
            request.CloseCustomerCategories.ToList());

        return customer 
       } 
   }

commented lines are just for guidence (what to do, inject an IOptions with a boolean that decide when to enable and disable the mocking mechanism ) plus I wanna know where should I have to deserialize the file(in handler or outside of it?)

 public class DeserializeFromFileAsync
{
    public class PostfixationsFile
    {
        public string Customer_no { get; set; }
        public string First_name { get; set; }
        public string Last_name { get; set; }
        public string Customer_type { get; set; }
        public string Adress_line { get; set; }
        public int Cnp { get; set; }
        public string Customer_category { get; set; }
        public int Open_branch { get; set; }
        public string Branch_name { get; set; }
        public string Insolventa { get; set; }
    }

    public class Program
    {
        public static async Task Main()
        {
            string fileName = @"FullPath";
            using FileStream openStream = File.OpenRead(fileName);
            PostfixationsFile weatherForecast = await JsonSerializer.DeserializeAsync<PostfixationsFile>(openStream);
        }
    }
}

and this is the json file.

[
 { "customer_no": "03242524",
    "first_name": "Prenume",
    "last_name": "Nume",
    "customer_type": "PF",'
    "adress_line": " Str. FN  Nr.    Bl.    Sc.    Et.    Ap.    Sect.    Loc.    Jud.  ",
    "cnp": "1970907336523",
    "customer_category": "PF_ONLINE",
    "open_branch": "213",
    "branch_name": "SUCURSALA DEJ",
    "insolventa": "NU"
},
{ "customer_no": "03242524",
    "first_name": "Prenume",
    "last_name": "Nume",
    "customer_type": "PF",'
    "adress_line": " Str. FN  Nr.    Bl.    Sc.    Et.    Ap.    Sect.    Loc.    Jud.  ",
    "cnp": "1970907336523_J77",
    "customer_category": "PF_ONLINE",
    "open_branch": "213",
    "branch_name": "SUCURSALA DEJ",
    "insolventa": "NU"
 }
]

Sorry for this messy message but is first time when I ask something here.

Answer 1

I wasn't able to build your code as it has a lot of dependencies which I'd need to make all sorts of assumptions about - you may want to read about creating a minimal, reproducible example .

However, I should be able to help you to understand how to use mocks. The first thing to know about mocks is that they should only be used in unit tests, not in your production code. So you wouldn't want to pass a flag into your actual handler to tell it whether or not to run in "mock" mode. Instead, you can create an instance of a mock in your unit test and then inject the mock into the code you're testing, so that your unit test can concentrate on the behaviour of the code you're testing, rather than the behaviour of any external code / web service / database etc that it is dependent on.

Imagine this is the class you want to test (equivalent of your GetCustomerDetailsQueryHandler ).

    public class MyHandler
    {
        private readonly IThingToMock thingToMock;

        public MyHandler(IThingToMock thingToMock)
        {
            this.thingToMock = thingToMock;
        }

        public string MethodToTest(int id)
        {
            var request = new RequestModel { Id = id };
            var response = this.thingToMock.GetInformation(request);
            return response.Foo;
        }

        public async Task<string> MethodToTestAsync(int id)
        {
            var request = new RequestModel { Id = id };
            var response = await this.thingToMock.GetInformationAsync(request).ConfigureAwait(false);
            return response.Foo;
        }
    }

This is dependent on IThingToMock (equivalent of your ICustomerApiClient ), which looks like this:

    public interface IThingToMock
    {
        ResponseModel GetInformation(RequestModel request);
        Task<ResponseModel> GetInformationAsync(RequestModel request);
    }

And IThingToMock 's request and response models look like this (I've deliberately kept them really simple):

    public class RequestModel
    {
        public int Id { get; set; }
    }

    public class ResponseModel
    {
        public string Foo { get; set; }
    }

Before you can start mocking, you need to add a unit test project to your solution (in Visual Studio's new project wizard, choose the template for a xUnit, nUnit or MSTest unit test project - which one you use is a matter of personal preference, I'm using xUnit for this answer).

Next, add a mocking NuGet package to your test project and add the appropriate using directive to your unit tests, eg using Moq; . I'm using Moq here, but again, other mocking packages are available, and it's up to you which one you want to use.

Now you can write a unit test, like this:

        [Fact]
        public void MethodToTest_AnyRequest_ReturnsExpectedResponse()
        {
            // Arrange
            var mockThing = new Mock<IThingToMock>();
            var expectedFoo = "Bar";
            mockThing.Setup(m => m.GetInformation(It.IsAny<RequestModel>()))
                .Returns(new ResponseModel { Foo = expectedFoo });
            var handler = new MyHandler(mockThing.Object);

            // Act
            var actualFoo = handler.MethodToTest(1);

            // Assert
            Assert.Equal(expectedFoo, actualFoo);
        }

Let's break this down. First, we create an instance of Mock<IThingToMock> . This has an Object property, which is an implementation of IThingToMock with all its methods and properties, except that by default the methods do nothing and any members with a return value return the default value for their return type (usually null ).

Next, we use the Setup method to make our mock behave in the way we want. In this example, we're saying that its GetInformation method should always return a particular ResponseModel regardless of the properties of the RequestModel which were passed to it. I'm telling it to return a hard-coded value here, but you could tell the mock to return the data deserialized from your JSON file instead.

And then at the end of the Arrange step, we're injecting the mocked IThingToMock into the constructor of the MyHandler class, which is the class we want to test the behaviour of.

To control the behaviour of an asynchronous method, set up the mock using the ReturnsAsync method instead of Returns , for example:

        [Fact]
        public async Task MethodToTestAsync_AnyRequest_ReturnsExpectedResponse()
        {
            // Arrange
            var mockThing = new Mock<IThingToMock>();
            var expectedFoo = "Bar";
            mockThing.Setup(m => m.GetInformationAsync(It.IsAny<RequestModel>()))
                .ReturnsAsync(new ResponseModel { Foo = expectedFoo });
            var handler = new MyHandler(mockThing.Object);

            // Act
            var actualFoo = await handler.MethodToTestAsync(1);

            // Assert
            Assert.Equal(expectedFoo, actualFoo);
        }

Hopefully these examples give you sufficient insight into how mocks are used in unit tests to be able to apply the principles to your own situation. You may also want to read How YOU can Learn Mock testing in .NET Core and C# with Moq , which provides more examples of how to use Moq, this time with nUnit rather than xUnit, as well as some good practice around unit testing generally. And of course, be sure to consult the documentation for whichever mocking package you're using.

Happy mocking!