Moq VS AutoMapper

In terms of mocking there are several frameworks you can use, but I've mainly relied on Moq and NSubstitute. Within this demo, I'm going to use NSubstitute as I've found it a little easier to use.

Or you just run into bullshit like https://github.com/Moq/moq4/issues/173

Now to the real benefit of DI: If you are testing a method in your application that calls the ReservationRepository.GetReservation() method, you can use a library like Moq to simply "mock" a class that uses the IReservationRepository interface and define the return result of the GetReservation() method. Pass the mocked class into the constructor of the class you are testing.

MOQ https://github.com/moq/moq4

Moq

Both projects use similar testing infrastructure. I write unit tests in C# using XUnit.net. I frequently use mock objects in testing, and MOQ is my tool of choice. I utilize continuous testing and coverage analysis through Rider. I do not have specific objectives for code coverage. When writing complicated algorithms, I frequently shoot for 100% coverage of the algorithm. I test simple properties inconsistently, and frequently do not test guard clauses.

🔗 Moq documentation | GitHub

But the reality is that I don't really write my tests with it. Toss on the MSTest attributes as needed of course. But all the testing code itself is FluentAssertions with a bit of Moq. (Though I find rarely need to use Moq/mocking anymore -- scandalous, I know.)

Moq tutorial

AutoMapper

The 13.0 Upgrade Guide page was created back in April, but there is no sign of the release yet.

The most well-know is probably AutoMapper, but it's not universally liked.

AutoMapper - well for automapping

When working with AutoMapper, we often bump into runtime errors due to invalid mapping configuration, such as this one:

What problems will resolve automapper?

If you are a fan of data mappers, you might want to enhance the implementation with additional extension methods. Here is an example for AutoMapper.

I'm wondering myself. Most mappers like https://automapper.org/ will make a best effort mapper automatically via introspection. If this is just a DSL/annotation suite that requires explicit, complete mapping implementations then this strikes me as a re-implementation of parts of kotlin in kotlin.