3

The most experienced developer in my current team has set a few hard rules based on best practices we should follow. Among them is "You never ever mock domain object". I asked him why we couldn't but he never had time to give me a proper answer. Now he's away for a week, and I reached a peak distrust to that rule, here's my situation.

My domain object has an Update method with several parameters, one being an interface for a calculator. It then updates a few fields, runs the calculators and assign its results to some other of its fields.

The proper unit test for the Update method itself is reasonably long.

Now I have some piece of code which do a few things then call Update on such a domain object.

I would normally mock the objects, and just check the Update method is being called with the proper arguments. But now, I have to test it's being properly called, by checking its fields and mocking the calculator then same way I did when unit testing the Update method itself. And I would have to do that everywhere the Update methods gets called. How fun will it be when the Update method change a bit, and every of those tests suddenly break and need refactoring... I feels this rule is just like shooting myself in the foot..

So I need to know, why You never ever mock domain object"?

Improve this question
7
  • 2
    The main problem is most likely the Update method itself, which attempts to fulfill too many use cases at once. "I would normally mock the objects, and just check the Update method is being called with the proper arguments": that doesn't tell you much on the correctness of the program. Commented Nov 19, 2018 at 16:31
  • I have a hard time with this correctness definition. For me well unit tested code provides clarity and thrust. The unit tests of Update should show what Update does and proves it does it the right way. If I need to test Update's result everytime it is called, it means I urge the caller to distrust Update's own unit tests. Which would be like stripping away the core concept of unit testing from its essence. Commented Nov 20, 2018 at 8:58
  • What do you understand under domain object? a domain model? or domain services? a domain model definitely should never be mocked. domain services (like an tax calculator) its pretty much fine, to mock the interface and return the required result Commented Nov 20, 2018 at 11:30
  • 1
    @SergeJacquemin Ok, I understand better now. You mean that calling aggregate.Update is part of a larger business process which you are attempting to test, but you feel the need to check the correctness of Update() everytime. I agree, you shouldn't have to do this and you most likely dont either. Why can't you just check the ouputs of the larger process given the inputs, without checking the result of calling Update() specifically. If you are already unit testing Update on it's own that should be enough. Commented Nov 20, 2018 at 15:01
  • 1
    @SergeJacquemin Well, in that specific scenario it doesn't seem like if there's a need to call a real Update implementation. From the look of things you don't seem to be testing the domain, but testing an application service perhaps? A mock would be fine in this scenario IMO, but if you can't have a mock then just use a helper class to generate a fixture and a fake call to Update() which you can reuse across your tests. Commented Nov 20, 2018 at 15:42

3 Answers 3

Reset to default
2

You never ever mock domain object

This is more of a heuristic than a best practice. And I can imagine that it make sense in some projects.

This heuristic can help to have better tests. Good tests are easy to write, easy to read and they will break as soon as something goes wrong. If you mock your domain model, you will probably also have to mock it's behavior. And if you have some complex behavior in your model, mocking it will be time consuming. The test will also be more fragile (mistakes can happen in predicting the domain model output).

The other alternative is to do sociable unit testing. That means the unit to be tested will not be a single class in isolation but a class and some of its dependencies. In other words, you just use a concrete object of your domain model in the test.

I would normally mock the objects, and just check the Update method is being called with the proper arguments. But now, I have to test it's being properly called, by checking its fields and mocking the calculator then same way I did when unit testing the Update method itself.

Checking that the update method is being called doesn't necessarily mean the success of the test. This is probably not what you want to check to see if your service works correctly. If you pass a concrete class of your model(including the calculators) you won't have to do any useless checks or repeat what has been done in other tests.

One of the differences between this solution and testing classes in isolation is that when there is bug in your domain model, many other tests will fail. But this is totally fine in my opinion since it will have to be fixed anyway.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

You never ever mock domain object

There might be different reasons to avoid mocking your domain objects:

  1. Mocking libraries, the same as ORMs, can affect design of your domain objects. They usually require interfaces or virtual methods in C#.

  2. A preference to test against real instances. Very often people use mocking libraries because it is an easy way to create a fake or a stub. Very often you can build an instance of your domain object and use it in your test. Most likely a fact that method Update was called can be easily checked via state change.

I would normally mock the objects, and just check the Update method is being called with the proper arguments. But now, I have to test it's being properly called, by checking its fields and mocking the calculator then same way I did when unit testing the Update method itself.

How fun will it be when the Update method change a bit, and every of those tests suddenly break and need refactoring...

It was already mentioned in the comment that probably Update method has to many responsibilities and that's why is used in lots of use cases.

There are different tastes when it comes to defining a system under test (sut). If you tend to test classes then you often find yourself using mocking libraries. If you tend to test scenarios or behaviors then most likely you will only care about state changes.

You can probably explore a different design for your domain object: Try to split Update method into explicit domain specific methods so each client will trigger a different behavior. Given this approach a "reasonably long" test for the Update method can even become obsolete since it will be tested by other tests.

Improve this answer

Comments

1

While Update() is probably not as tailored a method as you would expect from a rich domain model - which may have an impact on test fragility - I agree that you should take "never do X" advice with a grain of salt.

If you understand all the implications and know that the integration test version will be less maintainable, definitely use mocks. You, and not blanket statements or cargo cults, are the ultimate judge to what's better for your system in your context.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.