CODEWITHSUNDEEP
ruby-on-railsjsontdd
William Yeung
William Yeung

Reputation: 10566

How to test JSON result from Ruby on Rails functional tests?

How can I assert my Ajax request and test the JSON output from Ruby on Rails functional tests?

Upvotes: 81

Views: 43422

Answers (9)

nicholaides
nicholaides

Reputation: 19489

In Rails >= 5

Use ActionDispatch::TestResponse#parsed_body.

Example:

user = @response.parsed_body
assert_equal "Mike", user['name']

In Rails up to 4.x

Use JSON.parse, which takes a string as input and returns a Ruby hash that the JSON represents.

Example:

user = JSON.parse(@response.body)
assert_equal "Mike", user['name']

Upvotes: 100

Mark G.
Mark G.

Reputation: 3260

In newer versions of rails, you can leverage parsed_body to get access to this in your tests without any work.

Calling parsed_body on the response parses the response body based on the last response MIME type.

Out of the box, only :json is supported. But for any custom MIME types you've registered, you can add your own encoders...

https://api.rubyonrails.org/v5.2.1/classes/ActionDispatch/IntegrationTest.html

Upvotes: 3

Vedant Agarwala
Vedant Agarwala

Reputation: 18819

None of the answers provides a nice maintainable way to verify a JSON response. I find this one to be the best:

https://github.com/ruby-json-schema/json-schema

It provides a nice implementation for the standard json schema

You can write a schema like:

schema = {
    "type"=>"object",
    "required" => ["a"],
    "properties" => {
        "a" => {
            "type" => "integer",
            "default" => 42
        },
        "b" => {
            "type" => "object",
            "properties" => {
                "x" => {
                    "type" => "integer"
                }
            }
        }
    }
}

and use it like: JSON::Validator.validate(schema, { "a" => 5 })

Best way to verify it against my android client implementation.

Upvotes: 3

Jay Mitchell
Jay Mitchell

Reputation: 1240

As noted, you use JSON.parse to test the JSON, but where you perform that assertion depends on how you are rendering the JSON.

If you are generating the JSON in the controller, you parse the JSON in controller functional tests (as the other answers are showing). If you are rendering JSON, with a view using Jbuilder, rabl or another gem that takes this approach, then parse the JSON in the view unit tests not the controller functional tests. Unit tests are generally faster to execute and easier to write - e.g., you can build models in-memory rather than create them in the database.

Upvotes: 1

rkallensee
rkallensee

Reputation: 2024

You can use the AssertJson gem for a nice DSL which allows you to check for keys and values which should exist in your JSON response.

Add the gem to your Gemfile:

group :test do
  gem 'assert_json'
end

This is a quick example how your functional/controller test could look like (the example is an adaption from their README):

class ExampleControllerTest < ActionController::TestCase
  include AssertJson

  def test_my_action
    get :my_action, :format => 'json'
    # => @response.body= '{"key":[{"inner_key":"value1"}]}'

    assert_json(@response.body) do
      has 'key' do
        has 'inner_key', 'value1'
      end
      has_not 'key_not_included'
    end
  end

end

You just have to include the AssertJson module in your test and use the assert_json block where you can check the response for existent and non-existant keys and values. Hint: it's not immediately visible in the README, but to check for a value (e.g. if your action just returns an array of strings) you can do

  def test_my_action
    get :my_action, :format => 'json'
    # => @response.body= '["value1", "value2"]'

    assert_json(@response.body) do
      has 'value1'
      has 'value2'
      has_not 'value3'
    end
  end

Upvotes: -1

Damien
Damien

Reputation: 27473

Actually, you can use implicitly the JSON module:

assert_equal assigns(:user).to_json, @response.body

Upvotes: 1

acw
acw

Reputation: 1093

If you are using RSpec, json_spec is worth a look

https://github.com/collectiveidea/json_spec

Upvotes: 7

Josh
Josh

Reputation: 8586

Rails has JSON support built in:

def json_response
    ActiveSupport::JSON.decode @response.body
end

No need for a plugin

Then you can do something like this:

assert_equal "Mike", json_response['name']

Upvotes: 91

Eric
Eric

Reputation: 57

Also for short JSON responses you can simply match a string of the JSON to @response.body. This prevents having to rely on yet another gem.

assert_equal '{"total_votes":1}', @response.body

Upvotes: 4

Related Questions