Question

I’ve been writing tests for a while now and I’m starting to get the hang of things. But I’ve got some questions concerning how much test coverage is really necessary. The consensus seems pretty clear: more coverage is always better. But, from a beginner’s perspective at least, I wonder if this is really true.

Take this totally vanilla controller action for example:

def create
  @event = Event.new(params[:event])
  if @event.save
    flash[:notice] = "Event successfully created."
    redirect_to events_path
  else
    render :action => 'new'
  end
end

Just the generated scaffolding. We’re not doing anything unusual here. Why is it important to write controller tests for this action? After all, we didn’t even write the code – the generator did the work for us. Unless there’s a bug in rails, this code should be fine. It seems like testing this action is not all too different from testing, say, collection_select – and we wouldn’t do that. Furthermore, assuming we’re using cucumber, we should already have the basics covered (e.g. where it redirects).

The same could even be said for simple model methods. For example:

def full_name
  "#{first_name} #{last_name}"
end

Do we really need to write tests for such simple methods? If there’s a syntax error, you’ll catch it on page refresh. Likewise, cucumber would catch this so long as your features hit any page that called the full_name method. Obviously, we shouldn’t be relying on cucumber for anything too complex. But does full_name really need a unit test?

You might say that because the code is simple the test will also be simple. So you might as well write a test since it’s only going to take a minute. But it seems that writing essentially worthless tests can do more harm than good. For example, they clutter up your specs making it more difficult to focus on the complex tests that actually matter. Also, they take time to run (although probably not much).

But, like I said, I’m hardly an expert tester. I’m not necessarily advocating less test coverage. Rather, I’m looking for some expert advice. Is there actually a good reason to be writing such simple tests?

Answer 1

My experience in this is that you shouldn’t waste your time writing tests for code that is trivial, unless you have a lot of complex stuff riding on the correctness of that triviality. I, for one, think that testing stuff like getters and setters is a total waste of time, but I’m sure that there’ll be more than one coverage junkie out there who’ll be willing to oppose me on this.

For me tests facilitate three things:

1. They garantuee unbroken old functionality If I can check that
   nothing new that I put in has broken
   my old things by running tests, it’s
   a good thing.

2. They make me feel secure when I rewrite old stuff The code I
   refactor is very rarely the trivial
   one. If, however, I want to refactor
   untrivial code, having tests to
   ensure that my refactorings have not
   broken any behavior is a must.

3. They are the documentation of my work Untrivial code needs to be
   documented. If, however, you agree
   with me that comments in code is the
   work of the devil, having clear and
   concise unit tests that make you
   understand what the correct behavior
   of something is, is (again) a must.

Anything I’m sure I won’t break, or that I feel is unnessecary to document, I simply don’t waste time testing. Your generated controllers and model methods, then, I would say are all fine even without unit tests.