Rails App Testing

Disclaimer: This is just my opinion on rails testing. It’s no way a “must follow guide for testing” Also this blog post is a work progress.

#Api Testing A good rule of thumb for writing tests for your api is: You should test every thing in your api documentation to make sure your endpoints, accepted params, and response body does what it says it does. With that being said, this makes sure your api documentation is tested and your clients can trust it. The clients depending on your api shouldn’t have to tell you when your api is broken because you’ve made changes to it. Your tests should let you know this ahead of time.

##Things you should test when writing API tests ###The serializer/response body This way you will know exactly what the serializer is returning and you can be confident when you have to make changes to your models or serializers that it won’t break the api.

At minimum you should be testing the keys. That way you know what keys you’re returning with the api.

You can write and test your response body in your controller tests or in your serializer tests.


If the documentation says that GET /user/:id will return:

   first_name: string,
   last_name: string
} Then you should at least have a test that does something along the lines of:

describe '#GET user/:id' do
   expected = {
      first_name: user.first_name,
      last_name: user.last_name,
   get :show, id: 1
   response.body.should eq expected

If you want to test the serializer you can do something like this:

These should go in the spec/serializers folder.

describe UserSerializer do
  it "should return the right attributes for a user" do
    serializer = 1, first_name: 'first', last_name: 'last')
    expect(serializer.to_json).to eql('{"user":{"id":1,"first_name":"first", "last_name":"last"}}')

The above can be harder to write and but it is more verbose. If you don’t like that option you can write controller tests and use the .all? block to test the keys of the json.


describe Api::UsersControllers do
  let!(:user){ Fabricate :user }
  before do
    get api_users_path
  it 'should have the correct attributes' do
    get :show, id: 1
    json = JSON.parse(response.body)
      user.attributes.all? do |key|
    }.to be

The code above checks to make sure that all the keys for the model are represented in the response body. If you need to add more attributes you can alway just give the .all? block a hash with all the keys that should be in there. This will not only check if all your keys are there but will fail if you add or remove a key from your serializer.

good sources and gems for testing can be found here:


You should check accepted params for the endpi. required and optional

These are easy test to write just because you’re just checking the model validations.

#####Examples models/user.rb

class User < ActiveRecord::Base
  validates :first_name, :last_name, presence

You should always tests your models validation code. This way you know that you’re validations are working properly.

#Model tests

##What should you be testing

  • Model validations

  • Instance and class methods

###Model Validations You should always start with a valid fixture.


  Fabricator(:user) do
    first_name { sequence(:first_name) { |n| "first#{n}" } }
    first_name { sequence(:last_name) { |n| "last#{n}" } }


describe User do
     let(:user){ :user }
     subject { user }
     it{ should be_valid }

This makes sure you have all the correct data in your fixture. It kinda tests your model validations as well but I still like to be more verbose about this. This is why I’ve found something very easy to do this as well. You can use shoulda-matchers to test your model validations. I’ll write 2 examples below, One with shoulda and one without.

Without shoulda-matchers

  describe User do
    describe 'must have first name' do
      before { subject.first_name = nil }
      it{ should be_invalid }

With shoulda-mathchers

  describe User do
    it { should validate_presence_of :first_name }

###Instance and class methods

You should be testing you model instance and class methods as well. This is important because I’ve seen a lot of times were people make instance methods for some view code and then someone comes along and changes it. Then this breaks ever where this instance code was used and no one knows about until it goes into production. Remember tests are to protect you and others from changing something that is being used somewhere else in code base. I’ll start out with something basic for testing instance methods


  class User < ActiveRecord::Base
    def to_s
      [first_name, last_name].join


  describe User do
    its(:to_s){ should eq [subject.first_name, subject.last_name].join }

This project is maintained by meatherly