DEV Community: Diego Faria

BuddyInjector

Diego Faria — Thu, 22 Aug 2024 16:56:30 +0000

I want to share a personal project I've been working on called BuddyInjector.

BuddyInjector is a lightweight dependency injector created to help with tests.

The main focus of BuddyInjector is to eliminate the boilerplate of instantiating each dependency of your class to write simple tests, keeping it very simple to override only what you need for your mocks.

In this post, I will show you an example of a common use case.
If you like to read the project documentation (it's very short), you can go directly to the GitHub repository.

Intro

To keep it simple, let's use a basic scenario. We have a Service that calculates a value and returns the result. This Services depends on two repositories, RepositoryA and RepositoryB. Getting a value from each repository, the Service sums the values and returns the value.

The interface and the implementation of the repositories.

    public interface IRepositoryA
    {
        int GetTotal();
    }

    public interface IRepositoryB
    {
        int GetTotal();
    }

    public class RepositoryA : IRepositoryA
    {
        public int GetTotal()
        {
            return 1_000;
        }
    }

    public class RepositoryB : IRepositoryB
    {
        public int GetTotal()
        {
            return 500;
        }
    }

The interface and the implementation of the Service.

    public interface IService
    {
        int Total();
    }

    public class Service(IRepositoryA repositoryA, IRepositoryB repositoryB) : IService
    {
        public int Total()
        {
            return repositoryA.GetTotal() + repositoryB.GetTotal();
        }
    }

As you can see in the code, the repositories have a value hardcoded to simplify the example. So calling Total() from Service should return 1500, because RepositoryA returns 1000 and RepositoryB returns 500.

The test implementation without BuddyInjector

For the first example, let's create a normal unit test for Service.Total().

    public class UnitTest1
    {
        [Fact]
        public void Given_Real_Implmentations_With_Manual_Instantions_Should_Return_1500()
        {
            // Arrange
            IRepositoryA repositoryA = new RepositoryA();
            IRepositoryB repositoryB = new RepositoryB();
            IService service = new Service(repositoryA, repositoryB);

            // Act
            int value = service.Total();

            // Assert
            Assert.Equal(1_500, value);
        }
    }

As you can see, we need to instantiate each class manually to test only a single method. So imagine if we add more dependencies to the Service class or if we would like to create multiple tests to the Total() method.

BuddyInjector was created to help with this problem.

The test implementation using BuddyInjector

First, we need to register the dependencies into BuddyInjector. If you already use dependency injections in your projects, there is nothing new in this step.

At the register, we inform the type and the implementation. So it can be read as "When you find something that expects IRepositoryA delivery an instance of RepositoryA", for example.

BuddyInjector buddyInjector = new BuddyInjector();
buddyInjector.RegisterTransient<IRepositoryA, RepositoryA>();
buddyInjector.RegisterTransient<IRepositoryB, RepositoryB>();
buddyInjector.RegisterTransient<IService, Service>();

But repeating it on every test doesn't solve the problem presented in the first approach, right?

To solve it, BuddyInjector has the RegisterAll method. It allows us to write the dependencies instantiations once and reuse it through an Action delegate.

public Action<BuddyInjector> defaultInstances = buddyInjector =>
{
    buddyInjector.RegisterTransient<IRepositoryA, RepositoryA>();
    buddyInjector.RegisterTransient<IRepositoryB, RepositoryB>();
    buddyInjector.RegisterTransient<IService, Service>();
};

BuddyInjector buddyInjector = new BuddyInjector().RegisterAll(defaultInstances);

Here is the new approach of the test using the BuddyInjector.

public class UnitTest1
{
    public Action<BuddyInjector> defaultInstances = buddyInjector =>
    {
        buddyInjector.RegisterTransient<IRepositoryA, RepositoryA>();
        buddyInjector.RegisterTransient<IRepositoryB, RepositoryB>();
        buddyInjector.RegisterTransient<IService, Service>();
    };

    [Fact]
    public void Given_Real_Implmentations_With_BuddyInjector_Instantions_Should_Return_1500()
    {
        // Arrange
        using BuddyInjector buddyInjector = new BuddyInjector().RegisterAll(defaultInstances);

        IService service = buddyInjector.GetInstance<IService>();

        // Act
        int value = service.Total();

        // Assert
        Assert.Equal(1_500, value);
    }
}

Cool, right?

And now, to finish the example, let's see how to override using the simplicity of the BuddyInjector.

For this example, let's change the value returned by RepositoryB. Originally it returns 500, but for our example, we'll substitute it for 900.

To substitute the object creating a mock, we'll use the NSubstitute package. This article will not cover how to use the NSubstitute, but to explain the basics we say to the code "When someone calls method X, returns the value Y", so the result is a fake value.

public class UnitTest1
{
    public Action<BuddyInjector> defaultInstances = buddyInjector =>
    {
        buddyInjector.RegisterTransient<IRepositoryA, RepositoryA>();
        buddyInjector.RegisterTransient<IRepositoryB, RepositoryB>();
        buddyInjector.RegisterTransient<IService, Service>();
    };

    [Fact]
    public void Given_Mock_Implmentations_With_BuddyInjector_Instantions_Should_Return_1900()
    {
        // Arrange
        var repositoryBMock = Substitute.For<IRepositoryB>();
        repositoryBMock
            .GetTotal()
            .Returns(900);

        using BuddyInjector buddyInjector = new BuddyInjector().RegisterAll(defaultInstances);

        // Override the injection of only what you need.
        buddyInjector.RegisterTransient<IRepositoryB>(() => repositoryBMock);

        IService service = buddyInjector.GetInstance<IService>();

        // Act
        int value = service.Total();

        // Assert
        Assert.Equal(1_900, value);
    }
}

In this last example, we registered all the original classes and substituted only what we needed for the test, which was the IRepositoryB. So the BuddyInjector overrated the first register for the last register created buddyInjector.RegisterTransient<IRepositoryB>(() => repositoryBMock);

It'll work only for the specific test. When the scope of the tests is finished, the BuddyInjector will close the scope too, disposing everything that needs it, and start a new object on the next tests.

Photo by Markus Spiske on Unsplash

Implementing a middleware in HttpClient calls

Diego Faria — Fri, 19 Jul 2024 19:50:54 +0000

Intro

This article intends to show how to create a pre-request and a post-response, like a middleware, on the HttpClient.

Implementation

HttpClient accepts a HttpMessageHandler on the constructor. It allows us to modify the request behavior, including for example a pre-request and a post-response treatment. A good example is to include logs to intercept the data that is being sent and the response received just in one place or to add a required header for all requests.

Follow the implementation below:

public class CustomMessageHandler : HttpClientHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        Console.WriteLine("Doing something before request.");

        var response = await base.SendAsync(request, cancellationToken);

        Console.WriteLine("Doing something after request.");

        return response;
    }
}

We need to create a new class that inherits a HttpMessageHandler, so in this case, we inherit from HttpClientHandler that is an HttpMessageHandler. It allows us to override the SendAsync method. This method is the main method that is called to send the request. So no matter if you use GetAsync, PostAsync, etc., under the hood, the final method called is the SendAsync.

In the example above, overriding it we can put some logic before we call the base.SendAsync and we can add any logic after the response.

To implement it, we need to inject it via the constructor of the HttpClient.

using (var client = new HttpClient(new CustomMessageHandler())
{
    BaseAddress = new Uri("https://jsonplaceholder.typicode.com")
})

Here is the final code:

using System.Threading.Tasks;

namespace CustomHttpClient
{
    public class Program
    {
        static async Task Main(string[] args)
        {
            using (var client = new HttpClient(new CustomMessageHandler())
            {
                BaseAddress = new Uri("https://jsonplaceholder.typicode.com")
            }) 
            {
                var response = await client.GetStringAsync("/posts/1");

                Console.WriteLine(response);
                Console.ReadKey();
            };
        }
    }

    public class CustomMessageHandler : HttpClientHandler
    {
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            Console.WriteLine("Doing something before request.");

            var response = await base.SendAsync(request, cancellationToken);

            Console.WriteLine("Doing something after request.");

            return response;
        }
    }
}

And the result is what you can see below:

Doing something before request.
Doing something after request.
{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
  "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
}

Photo by Irvan Smith on Unsplash

Reading JSON with custom formats in C#

Diego Faria — Fri, 14 Oct 2022 04:51:47 +0000

The Problem

The JSON is the most common type used by APIs to respond requests.
Sometimes we receive contents that aren't possible to parse using built-in types in C#. Example, imagine that an API responds a date like Brazilian format (dd/MM/yyy) and we need to read this value in our app.

For this example, lets assume the JSON below:

{"name":"John","birthDate":"31/12/1990"}

Preparing the scenario

First of all, we need to create the class that represents the person.

public class Person
{
    [JsonPropertyName("name")]
    public string Name { get; set; }

    [JsonPropertyName("birthDate")]
    public DateTime BirthDate { get; set; }

    public override string ToString()
    {
        return $"Name: {Name} | BirthDate: {BirthDate}";
    }
}

Now we need to create a variable that represents the JSON.

public class Program
{
    public static string jsonExample = "{"
        + "\"name\":\"John\","
        + "\"birthDate\":\"31/12/1990\""
        + "}";

    public static void Main(string[] args)
    {
    }
}

And finally we create the parser using the built-in JsonSerializer.Deserialize

public class Program
{
    public static string jsonExample = "{"
        + "\"name\":\"John\","
        + "\"birthDate\":\"31/12/1990\""
        + "}";
    public static void Main(string[] args)
    {

        var person = JsonSerializer.Deserialize<Person>(jsonExample);
        Console.WriteLine(person);
    }
}

Running the code

When we try to run the code we receive an exception informing System.FormatException : The JSON value is not in a supported DateTime format. because the C# don't know how to apply the custom date to the type DateTime.

The solution

To solve this problem, we need to create a custom json converter using the built-in abstract class JsonConverter<T>.

First we need to create a class that inherit from JsonConverter<T> where T is the type of expected result. In this case DateTime.

public class MyCustomJsonConverter : JsonConverter<DateTime>
{

}

After that we implements the inherited methods.

public class MyCustomJsonConverter : JsonConverter<DateTime>
{
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }

    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }
}

Now we need to implement two methods, the first one is to read a custom json value and the second one is to write a custom json value. For this purpose we will use only the first one, because we are reading a value.

The system will pass the expected json using the Utf8JsonReader reader parameter.
As Utf8JsonReader is a struct, it's necessary to get the value using the GetString() that returns a string? type.

And finally we use the DateTime.ParseExact() to format the date as expected.

public class MyCustomJsonConverter : JsonConverter<DateTime>
{
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        var dateTimeFromJson = reader.GetString()!;

        return DateTime.ParseExact(dateTimeFromJson, "dd/MM/yyyy", CultureInfo.InvariantCulture);
    }

    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }
}

Ok, we have a custom converter, now we need to apply this converter on property Person.BirthDate to the serializer do the hard work for us.

It's simple. We just need to decorate the BirthDate property with the attribute JsonConverter() that expects a type of converter.

public class Person
{
    [JsonPropertyName("name")]
    public string Name { get; set; }

    [JsonPropertyName("birthDate")]
    [JsonConverter(typeof(MyCustomJsonConverter))]
    public DateTime BirthDate { get; set; }

    public override string ToString()
    {
        return $"Name: {Name} | BirthDate: {BirthDate}";
    }
}

Running the code

It's all we need to create the custom converter. Now we can just run the code and see the result.

Name: John | BirthDate: 1990-12-31 12:00:00 AM

Source

How to write custom converters for JSON serialization (marshalling) in .NET

Credits

Photo by James Harrison on Unsplash