Question

I have a method called save_title:

def save_title (data)
  ...  
  [ if the record exists, update, return 0] 
  [ if the record is new, create, return 1] 
end  

All fine, until I stubbed it:

saved_rows = []
 proc.stub(:save_title) do |arg|
  saved_rows << arg
 end

The bug here is that I was using the integer returned from the real method to determine how many records were created vs. updated. The stub doesn’t return an integer. Oooops. So the code worked fine in reality, but appeared broken in the test. A while later (more than I care to admit, cursing included) I realize the stub and the real method don’t behave the same. Such are the pitfalls of dynamic languages I suppose.

Questions:

1. Can I tell rspec to warn me if the stub doesn’t return the same sort of thing as the real method?
2. Is there an analyzer gem that I can use to warn about this sort of thing?
3. Is there some sort of best practice that I don’t know about with returning values from methods?

Answer 1

1) There is no way that rspec can know what type of object the method is supposed to return, that’s for you to tell it, however…

2) There is something you can look into. Instead of using a stub, try using a mock instead as your test double. It is basically the same thing as a stub, however, you can do many more validations on it (check out the documentation here). Things like how many times the specific method was called, the arguments it should be called with and what the return value should be as well. Your test will fail if any of those validations don’t pass.

3) The best practice would be the method name itself. For example, methods ending in ? like object.exists? should always return a boolean value. In your case, I would suggest a refactoring of your method, maybe divide it in two, one for updating and one for creating and have another method to tell you if an object exists or not. It is not good practice to have a method behave in two different ways depending on the input (see separation of concerns)

Good luck! hope this helps.