|John Fallows||May 10, 2006 5:23 pm|
|Adam Winer||May 10, 2006 5:43 pm|
|Dennis Byrne||May 10, 2006 6:29 pm|
|Adam Winer||May 10, 2006 9:44 pm|
|Craig McClanahan||May 10, 2006 10:09 pm|
|John Fallows||May 12, 2006 9:08 pm|
|Craig McClanahan||May 12, 2006 9:15 pm|
|John Fallows||May 12, 2006 9:16 pm|
|Craig McClanahan||May 12, 2006 9:24 pm|
|John Fallows||May 12, 2006 10:12 pm|
|Craig McClanahan||May 12, 2006 10:32 pm|
|John Fallows||May 12, 2006 11:43 pm|
|Adam Winer||May 13, 2006 9:08 am|
|Martin Marinschek||May 13, 2006 2:46 pm|
|John Fallows||May 13, 2006 3:44 pm|
|Craig McClanahan||May 13, 2006 4:49 pm|
|John Fallows||May 14, 2006 11:14 am|
|Adam Winer||May 14, 2006 12:35 pm|
|John Fallows||May 14, 2006 9:47 pm|
|Matthias Wessendorf||Jun 19, 2006 3:31 pm|
|Subject:||Re: Thoughts about unit testing and mock objects|
|From:||John Fallows (john...@gmail.com)|
|Date:||May 12, 2006 11:43:28 pm|
On 5/12/06, Craig McClanahan <crai...@apache.org> wrote:
On 5/12/06, John Fallows <john...@gmail.com> wrote:
On 5/10/06, Adam Winer <awi...@gmail.com> wrote:
I thought more about this over the last few hours. I think my basic gripe with easymock and mockobject approaches to JSF API objects is that most of the JSF tests I write rarely are concerned specifically with testing how my code is interacting with the JSF API; it's how my code is itself behaving. The former is where mock object suites pay dividends, but when your main concern is in your own code, mock suites seem to get in the way for more than they help. Basically, the Shale test framework seems like a better fit (yeah, handcoded, but that work's done and released...).
I don't understand your point. Shale test framework is founded on mock objects.
In addition, code we write in things like ADF Faces is going to assume certain behavior on the part of the JSF runtime -- I like to use a mock object framework that behaves enough like the "real thing" so that I can test the parts of my code that depend on that behavior too, not just static unit tests on individual methods.
Also, no one so far seems to have addressed the second question in the
original post about how we should provide mock objects for our own code in our unit tests.
It probably blurs the line between unit tests and system integration tests a bit, but I like to use the real objects, rather than mocks, whenever I can feasibly do so. Besides having to do less work (not building mocks for classes that can be used both at test time and runtime), this also reduces the risk that I will mistakenly program my own class to the possibly botched behavior of a badly written mock object, giving me a false sense of security when the tests pass ...
Well I definitely agree about not wanting to hand-craft mock object implementations!
Dynamic mock creation also seems to address that by not requiring an implementation and keeping the recipe for the behavior isolated to the unit test itself. This provides self-documenting tests which are especially useful for anyone trying to learn the semantics of the code.
IMHO, unit testing is about verifying the semantics of each codepath in each method, aiming for 100% coverage. This is most easily verified if each codepath is unit tested in isolation, preventing cascading failures and minimizing initialization overhead (only create the objects used by the method codepath).
The point about false positives is interesting. Let's assume that we don't have any reusable mock object implementations to possibly botch, instead we have a specification of expected behavior (to possibly botch!) inside each unit test method definition (using jMock). Then, the unit test reads as "setup expectations", "execute real object method", and "verify actual behavior".
The unit test verifies that the method behaves according to the expected semantics defined in the same method. With a minimal amount of expected behavior to specify in each unit test method, the general approach does not seem that error prone to me. Perhaps some of this setup just needs to be hoisted out of the unit test method in special cases, like Shale does for JSF specification objects.
Lastly, I think that the best way to verify in-container behavior is to run the code in the actual container and update the isolated behavior specifications in any unit test methods that need to be improved. When the tested codepaths are working, the unit tests will ensure that they keep working.
Thanks for any insights you can provide to help me figure out the pros and cons here. :-)
tc, -john. -- http://apress.com/book/bookDisplay.html?bID=10044 Author: Pro JSF and Ajax: Building Rich Internet Components, Apress