The solutions usually fall into 4 categories:
- Don't test private methods
- Use reflection
- Use a nested class
- Change the visibility
Let's look at them in turn:
Don't test private methods
This really leaves us with three choices:
- refactor to make the method public in some helper class
- test through a calling method with a higher visibility
- give up
A delightful choice between increased bloat, higher test complexity and resignation!
No, thank you!
Use reflection
Why make things simple when you can also make them hard and long-winded?
Haven't you always been dreaming of needing 10 lines of code to make a
method call? (Yes, there are now even entire tools dedicated
to this big operation!) Extra bonus points because you can now also
prevent your IDE's compiler and refactoring tools from helping you!
No, thank you!
Use a nested class
No too bad, but with 3 significant drawbacks:
- no separate sources / test sources folders
- larger classes
- unit test code in production binaries
We can do better.
No thank you!
No thank you!
Change the visibility
This leaves us with the last option. Not perfect either, but by far the most pragmatic!
It trades a slight increase in visibility (to package-protected) for
greatly simplified calling (a regular method call, no less!), while
still preserving the valuable sources / test sources separation.
And with a simple documentation habit, it becomes clear to everyone why this design trade-off was made:
?
/* private -> testing */ void myMethodUnderTest() {
...
}
So the next time you face this problem, choose the pragmatic route. And
enjoy a coffee while everyone else is still trying to complicate things.
:-)
{{ parent.title || parent.header.title}}
{{ parent.tldr }}
{{ parent.linkDescription }}
{{ parent.urlSource.name }}