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

Question

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

Answer 1

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

Here is the main point of the test:

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

Here's the documentation for the gem: http://json.rubyforge.org/ . In addition, you can pretty easily play with the pearl of JSON in IRB .

Answer 2

Rails has built-in JSON support:

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

No plugin needed

Then you can do something like this:

 assert_equal "Mike", json_response['name'] 

Answer 3

If you are using RSpec, json_spec is worth a look

https://github.com/collectiveidea/json_spec

Answer 4

Also for short JSON responses, you can just map the JSON string to @ response.body. This does not allow relying on another stone.

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

Answer 5

Actually, you can use the JSON module implicitly:

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

Answer 6

As already noted, you use JSON.parse to test JSON, but where you execute this statement depends on how you display JSON.

If you create JSON in the controller, you parse JSON in the functional tests of the controller (as other answers show). If you are handling JSON using Jbuilder , rabl, or another gem that uses this approach, then parse the JSON in the view block tests , not the controller functional tests. Unit tests tend to be faster and easier to write — for example, you can create models in memory rather than create them in a database.

Answer 7

None of the answers provide a good supported way to validate a JSON response. I believe this is the best:

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

It provides a good implementation of the standard json schema

You can write a diagram, for example:

 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 })

The best way to test it against my Android client implementation.

Answer 8

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

The parsed_body call for the response analyzes the response body based on the MIME type of the last response.

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

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

Answer 9

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

Add the gem to your Gemfile :

 group :test do gem 'assert_json' end 

This is a quick example of what your functional / controller test might look like (an example is an adaptation from 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 need to include the AssertJson module in your test and use the assert_json block, where you can check the response to existing and nonexistent keys and values. Hint: it is not immediately visible in README , but to check the value (for example, 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