api_matchers 0.2.0 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Mjc1NTQ2NTNjYTFlNTc1OWZhMmFlZTVlOTBjNTc3ODhjYzdmZGY1Mw==
+    YTM2MmZhOGZkNjQ4N2Q1M2ZjMTU0ODhmZjE1ZDBiMjljZTE1YTk4NA==
   data.tar.gz: !binary |-
-    MjlhYzlkMDRhZjA5YmU3YWExNTZlNTY3MTdhNzBhODFhOTA2OGJmOA==
+    ZGQzMDNiNTQ2YmI2YmU1YWQzZjlkZmZmODk2OTVkZGFmODE1NDc0MA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YjViMzY4MjgxNmI1NjI3MmI3MDAwZWNjMzQwYzJhMzhjNWU4MTc2YjNmYTVk
-    Y2JhMGZmNWRhYTRiN2Q0OTQ4NjdlZDlmNDMwNjEzMzU5NGY1NzNiOGU2MjE0
-    YThhZmZlM2U3NTNkNDcwNmMyZTJmM2U4NTI0ODViYzA4ZWMwNTc=
+    Y2RhNTE5NzdmYTkwMjE0ZTVlM2EwZmM0ZjY2Y2U3MWQ2ZjA5OWIwMjY2NGVh
+    MmMzNGZhYmE0MzA0OGQ2NjQxYTgyNTJkMDI4YjhmNDJhZmM0NGNmMjAxZjQw
+    ZTRjM2NlNjI4ZDc5ZjYwZTM2ZTY0ZWIwYTQ1MzRiNmNlOGQ2ZDg=
   data.tar.gz: !binary |-
-    NDYzYThkMzYwYzE2YTlkM2MzY2FiOWMyOWJlZGM2MGVjZTU4MmQ3OTYzM2Zm
-    ODgyY2NiMmMwNGJlY2Q3MWQyNTAzZWMxNTg2ZTIwYmU3YzYxNWI1NjNkMWY3
-    ODE0YTIwZjk2YjAzOGJjYTc0YmU5MDkwYmU2ODc0YmU4YTMzYWQ=
+    MzIyNmE0NmIwOGQxODRhMmJkN2ZmNmZkMTllOTFjMGJjMzc1MjQ3ZGY4MWZl
+    NWJjMGFiNjA3ZGRmYjZhMzBkOTAxNzgxM2JkOWQyNzUxNmI5NGRkYWRlMDA1
+    NTI4MWEzNDY1MGY0YzI2NzYzMGYxYzEwZDAwNDQyZGUyZTg3NjQ=

data/lib/api_matchers/core/parser.rb

@@ -0,0 +1,11 @@
+module APIMatchers
+  module Core
+    module Parser
+      def json
+        JSON.parse(response_body)
+      rescue JSON::ParserError => exception
+        raise ::APIMatchers::InvalidJSON.new("Invalid JSON: '#{response_body}'")
+      end
+    end
+  end
+end

data/lib/api_matchers/core/rspec_matchers.rb

@@ -46,6 +46,10 @@ module APIMatchers
       ::APIMatchers::ResponseBody::HaveXmlNode.new(expected_node: expected_node, setup: ::APIMatchers::Core::Setup)
     end
 
+    def have_json(expected_json)
+      ::APIMatchers::ResponseBody::HaveJson.new(expected_json)
+    end
+
     def have_node(expected_node)
       if ::APIMatchers::Core::Setup.have_node_matcher.equal?(:json)
         have_json_node(expected_node)

data/lib/api_matchers/response_body/have_json.rb

@@ -0,0 +1,27 @@
+module APIMatchers
+  module ResponseBody
+    class HaveJson
+      include APIMatchers::Core::Parser
+      attr_reader :expected_json, :response_body
+
+      def initialize(expected_json)
+        @expected_json = expected_json
+      end
+
+      def matches?(actual)
+        @response_body = actual
+
+        @expected_json == json
+      end
+
+      def failure_message_for_should
+        "expect to have json: '#{response_body}'. Got: '#{json}'."
+      end
+
+      def failure_message_for_should_not
+        "expect to NOT have json: '#{response_body}'."
+      end
+    end
+  end
+end
+

data/lib/api_matchers/response_body/have_json_node.rb

@@ -4,6 +4,8 @@ require 'active_support/core_ext/hash'
 module APIMatchers
   module ResponseBody
     class HaveJsonNode < Base
+      include APIMatchers::Core::Parser
+
       def matches?(actual)
         @actual = actual
 
@@ -19,12 +21,6 @@ module APIMatchers
           false # the key was not found
         end
       end
-
-      def json
-        JSON.parse(response_body)
-      rescue JSON::ParserError => exception
-        raise ::APIMatchers::InvalidJSON.new("Invalid JSON: '#{response_body}'")
-      end
     end
   end
 end

data/lib/api_matchers/version.rb

@@ -1,3 +1,3 @@
 module APIMatchers
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/api_matchers.rb

@@ -30,6 +30,7 @@ module APIMatchers
   module ResponseBody
     autoload :Base, 'api_matchers/response_body/base'
     autoload :HaveJsonNode, 'api_matchers/response_body/have_json_node'
+    autoload :HaveJson, 'api_matchers/response_body/have_json'
     autoload :HaveXmlNode,  'api_matchers/response_body/have_xml_node'
     autoload :HaveNode, 'api_matchers/response_body/have_node'
   end
@@ -38,6 +39,7 @@ module APIMatchers
   #
   module Core
     autoload :FindInJSON, 'api_matchers/core/find_in_json'
+    autoload :Parser, 'api_matchers/core/parser'
     autoload :Setup, 'api_matchers/core/setup'
     autoload :Exceptions, 'api_matchers/core/exceptions'
   end

data/spec/api_matchers/response_body/have_json_node_spec.rb

@@ -3,62 +3,62 @@ require 'spec_helper'
 describe APIMatchers::ResponseBody::HaveJsonNode do
   describe "actual.should have_json_node" do
     context 'expected key and value in top level' do
-      it "should pass when the expected key exist" do
+      it "pass when the expected key exist" do
         { :product => 'gateway' }.to_json.should have_json_node(:product)
       end
 
-      it "should fail when the expected key does not exist" do
+      it "fail when the expected key does not exist" do
         expect {
           { :product => 'pabx' }.to_json.should have_json_node(:developers)
         }.to fail_with(%Q{expected to have node called: 'developers'. Got: '{"product":"pabx"}'})
       end
 
-      it "should pass when the expected key exist with the expected value" do
+      it "pass when the expected key exist with the expected value" do
         { :product => 'payment-gateway' }.to_json.should have_json_node(:product).with('payment-gateway')
       end
 
-      it "should pass when the expected key exist with the expected value (as integer)" do
+      it "pass when the expected key exist with the expected value (as integer)" do
         { :number => 1 }.to_json.should have_json_node(:number).with(1)
       end
 
-      it "should pass when the expected key exist with the expected value (as boolean, true)" do
+      it "pass when the expected key exist with the expected value (as boolean, true)" do
         { :number => true }.to_json.should have_json_node(:number).with(true)
       end
 
-      it "should pass when the expected key exist with the expected value (as boolean, false)" do
+      it "pass when the expected key exist with the expected value (as boolean, false)" do
         { :number => false }.to_json.should have_json_node(:number).with(false)
       end
 
-      it "should pass when the expected key exist but the expected value is wrong (as boolean, true)" do
+      it "pass when the expected key exist but the expected value is wrong (as boolean, true)" do
         { :number => true }.to_json.should_not have_json_node(:number).with(false)
       end
 
-      it "should pass when the expected key exist but the expected value is wrong (as boolean, false)" do
+      it "pass when the expected key exist but the expected value is wrong (as boolean, false)" do
         { :number => false }.to_json.should_not have_json_node(:number).with(true)
       end
 
-      it "should pass when the expected key exists with the expected value (as DateTime)" do
+      it "pass when the expected key exists with the expected value (as DateTime)" do
         now = DateTime.now
         { :date => now }.to_json.should have_json_node(:date).with(now)
       end
 
-      it "should pass when the expected key exists with the expected value (as Date)" do
+      it "pass when the expected key exists with the expected value (as Date)" do
         now = Date.today
         { :date => now }.to_json.should have_json_node(:date).with(now)
       end
 
-      it "should pass when the expected key exists with the expected value (as Time)" do
+      it "pass when the expected key exists with the expected value (as Time)" do
         now = Time.now
         { :time => now }.to_json.should have_json_node(:time).with(now)
       end
 
-      it "should fail when the expected key exist but the expected value don't exist" do
+      it "fail when the expected key exist but the expected value don't exist" do
         expect {
           { :product => 'payment-gateway' }.to_json.should have_json_node(:product).with('email-marketing')
         }.to fail_with(%Q{expected to have node called: 'product' with value: 'email-marketing'. Got: '{"product":"payment-gateway"}'})
       end
 
-      it "should not parse the matcher for json when you pass a xml" do
+      it "not parse the matcher for json when you pass a xml" do
         expect {
           "<product><name>webdesk</name></product>".should have_json_node(:name).with('webdesk')
         }.to raise_error(APIMatchers::InvalidJSON, "Invalid JSON: '<product><name>webdesk</name></product>'")
@@ -66,15 +66,15 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
     end
 
     context 'expected key and nil value' do
-      it "should pass when the expected key exists" do
+      it "pass when the expected key exists" do
         { :product => nil }.to_json.should have_json_node(:product)
       end
 
-      it "should pass when the expected key exists and the expected value is nil" do
+      it "pass when the expected key exists and the expected value is nil" do
         { :product => nil }.to_json.should have_json_node(:product).with( nil )
       end
 
-      it "should fail when the expected key exist but the expected value don't exist" do
+      it "fail when the expected key exist but the expected value don't exist" do
         expect {
           { :product => nil }.to_json.should have_json_node(:product).with('email-marketing')
         }.to fail_with(%Q{expected to have node called: 'product' with value: 'email-marketing'. Got: '{"product":null}'})
@@ -83,89 +83,89 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
 
     context 'expected key and value in more deep in the JSON' do
       context '.to_json used' do
-        it "should pass when the expected key exist" do
+        it "pass when the expected key exist" do
           { :transaction => { :id => 150 } }.to_json.should have_json_node(:id)
         end
 
-        it "should pass when the expected key and expected value exist" do
+        it "pass when the expected key and expected value exist" do
           { :transaction => { :error => { :code => '999' } } }.to_json.should have_json_node(:code).with('999')
         end
 
-        it "should pass when the expected key and expected value exist in very deep" do
+        it "pass when the expected key and expected value exist in very deep" do
           { :first=>"A", :second=>nil, :third=>{ :stuff => { :first_stuff=>{ :color=>"green", :size=>"small", :shape=>"circle", :uid=>"first_stuff"}, :second_stuff=>{ :color=>"blue", :size=>"large", :shape=>"square", :uid=>"second_stuff"}}, :junk=>[{"name"=>"junk_one", :uid=>"junk_one", :stuff_uid=>"first_stuff"}, { :name=>"junk_two", :uid=>"junk_two", :stuff_uid=>"second_stuff"}]}}.to_json.should have_json_node( :junk )
         end
 
-        it "should pass when the expected key and expected value exist in very deep" do
+        it "pass when the expected key and expected value exist in very deep" do
           { :first=>"A", :second=>nil, :third=>{ :stuff => { :first_stuff=>{ :color=>"green", :size=>"small", :shape=>"circle", :uid=>"first_stuff"}, :second_stuff=>{ :color=>"blue", :size=>"large", :shape=>"square", :uid=>"second_stuff"}}, :junk=>[{"name"=>"junk_one", :uid=>"junk_one", :stuff_uid=>"first_stuff"}, { :name=>"junk_two", :uid=>"junk_two", :stuff_uid=>"second_stuff"}]}}.to_json.should have_json_node( :name ).with( "junk_two" )
         end
 
-        it "should fail when the expected key does not exist" do
+        it "fail when the expected key does not exist" do
           expect {
             { :transaction => { :id => 150, :error => {} } }.to_json.should have_json_node(:code)
           }.to fail_with(%Q{expected to have node called: 'code'. Got: '{"transaction":{"id":150,"error":{}}}'})
         end
 
-        it "should fail when the expected key exist but don't exist the expected value" do
+        it "fail when the expected key exist but don't exist the expected value" do
           expect {
             { :transaction => { :id => 150, :error => { :code => '999' } } }.to_json.should have_json_node(:code).with('001')
           }.to fail_with(%Q{expected to have node called: 'code' with value: '001'. Got: '{"transaction":{"id":150,"error":{"code":"999"}}}'})
         end
       end
       context 'json string used' do
-        it "should pass when the expected key exist" do
+        it "pass when the expected key exist" do
           '{ "transaction": {"id": 150 } }'.should have_json_node(:id)
         end
 
-        it "should pass when the expected key and expected value exist" do
+        it "pass when the expected key and expected value exist" do
           '{ "transaction": {"error": { "code": "999" } } }'.should have_json_node(:code).with('999')
         end
 
-        it "should pass when the expected key exist with the expected value (as integer)" do
+        it "pass when the expected key exist with the expected value (as integer)" do
           '{"number":1 }'.should have_json_node(:number).with(1)
         end
 
-        it "should pass when the expected key exist with the expected value (as boolean)" do
+        it "pass when the expected key exist with the expected value (as boolean)" do
           '{"boolean":true}'.should have_json_node(:boolean).with(true)
         end
 
-        it "should pass when the expected key exists with the expected value (as DateTime)" do
+        it "pass when the expected key exists with the expected value (as DateTime)" do
           now = DateTime.parse( "2012-09-18T15:42:12-07:00" )
           '{"date": "2012-09-18T15:42:12-07:00"}'.should have_json_node(:date).with(now)
         end
 
-        it "should pass when the expected key exists with the expected value (as Date)" do
+        it "pass when the expected key exists with the expected value (as Date)" do
           now = Date.parse( "2012-09-18" )
           '{"date": "2012-09-18"}'.should have_json_node(:date).with(now)
         end
 
-        it "should pass when the expected key exists with the expected value (as Time)" do
+        it "pass when the expected key exists with the expected value (as Time)" do
           now = Time.parse("2012-09-18T15:42:12Z")
           '{"time": "2012-09-18T15:42:12+00:00"}'.should have_json_node(:time).with(now)
         end
 
-        it "should pass when the expected key exist with the expected value (as boolean) in a multi node" do
+        it "pass when the expected key exist with the expected value (as boolean) in a multi node" do
           '{"uid":"123456","boolean":true}'.should have_json_node(:boolean).with(true)
         end
 
-        it "should pass when the expected key and expected value exist in very deep" do
+        it "pass when the expected key and expected value exist in very deep" do
           '{"first":"A","second":null,"third":{"stuff":{"first_stuff":{"color":"green","size":"small","shape":"circle","uid":"first_stuff"},"second_stuff":{"color":"blue","size":"large","shape":"square","uid":"second_stuff"}},"junk":[{"name":"junk_one","uid":"junk_one","stuff_uid":"first_stuff"},{"name":"junk_two","uid":"junk_two","stuff_uid":"second_stuff"}]}}'.should have_json_node( :junk )
         end
 
-        it "should pass when the expected key and expected value exist in very deep" do
+        it "pass when the expected key and expected value exist in very deep" do
           '{"first":"A","second":null,"third":{"stuff":{"first_stuff":{"color":"green","size":"small","shape":"circle","uid":"first_stuff"},"second_stuff":{"color":"blue","size":"large","shape":"square","uid":"second_stuff"}},"junk":[{"name":"junk_one","uid":"junk_one","stuff_uid":"first_stuff"},{"name":"junk_two","uid":"junk_two","stuff_uid":"second_stuff"}]}}'.should have_json_node( :name ).with( "junk_two" )
         end
 
-        it "should pass when the expected key and including text exist" do
+        it "pass when the expected key and including text exist" do
           '{"Key":"A=123456-abcdef-09876-ghijkl; path=/; expires=Sun, 05-Sep-2032 05:50:39 GMT\nB=ABCDEF123456; path=/; expires=Sun, 05-Sep-2032 05:50:39 GMT", "Content-Type":"application/json; charset=utf-8"}'.should have_json_node( "Key" ).including_text( "123456-abcdef-09876-ghijkl" )
         end
 
-        it "should fail when the expected key does not exist" do
+        it "fail when the expected key does not exist" do
           expect {
             '{"transaction":{"id":150,"error":{}}}'.should have_json_node(:code)
           }.to fail_with(%Q{expected to have node called: 'code'. Got: '{"transaction":{"id":150,"error":{}}}'})
         end
 
-        it "should fail when the expected key exist but don't exist the expected value" do
+        it "fail when the expected key exist but don't exist the expected value" do
           expect {
             '{"transaction":{"id":150,"error":{"code":"999"}}}'.should have_json_node(:code).with('001')
           }.to fail_with(%Q{expected to have node called: 'code' with value: '001'. Got: '{"transaction":{"id":150,"error":{"code":"999"}}}'})
@@ -174,11 +174,11 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
     end
 
     context "including_text" do
-      it "should pass when the expected is included in the actual" do
+      it "pass when the expected is included in the actual" do
         { :transaction => { :error => { :message => "Transaction error: Name can't be blank" } } }.to_json.should have_json_node(:message).including_text("Transaction error")
       end
 
-      it "should fail when the expected is not included in the actual" do
+      it "fail when the expected is not included in the actual" do
         expect {
           { :transaction => { :error => { :message => "Transaction error: Name can't be blank" } } }.to_json.should have_json_node(:message).including_text("Fox on the run")
         }.to fail_with(%Q{expected to have node called: 'message' including text: 'Fox on the run'. Got: '{"transaction":{"error":{"message":"Transaction error: Name can't be blank"}}}'})
@@ -187,36 +187,36 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
   end
 
   describe "actual.should_not have_json_node" do
-    it "should pass when don't have the expected node in root level" do
+    it "pass when don't have the expected node in root level" do
       { :product => 'gateway' }.to_json.should_not have_json_node(:status)
     end
 
-    it "should pass when don't have the expected node in any level" do
+    it "pass when don't have the expected node in any level" do
       { :transaction => { :id => 12, :status => 'paid' } }.to_json.should_not have_json_node(:error)
     end
 
-    it "should fail when the expected key exist" do
+    it "fail when the expected key exist" do
       expect {
         { :status => 'paid' }.to_json.should_not have_json_node(:status)
       }.to fail_with(%Q{expected to NOT have node called: 'status'. Got: '{"status":"paid"}'})
     end
 
-    it "should pass when have the expected key but have a different value" do
+    it "pass when have the expected key but have a different value" do
       { :status => 'paid' }.to_json.should_not have_json_node(:status).with('not_authorized')
     end
 
-    it "should fail when have the expected key and have the expected value" do
+    it "fail when have the expected key and have the expected value" do
       expect {
         { :status => 'paid' }.to_json.should_not have_json_node(:status).with('paid')
       }.to fail_with(%Q{expected to NOT have node called: 'status' with value: 'paid'. Got: '{"status":"paid"}'})
     end
 
     context "including_text" do
-      it "should pass when the expected is NOT included in the actual" do
+      it "pass when the expected is NOT included in the actual" do
         { :transaction => { :error => { :message => "Transaction error: Name can't be blank" } } }.to_json.should_not have_json_node(:message).including_text("Love gun")
       end
 
-      it "should fail when the expected is included in the actual" do
+      it "fail when the expected is included in the actual" do
         expect {
           { :transaction => { :error => { :message => "Transaction error: Name can't be blank" } } }.to_json.should_not have_json_node(:message).including_text("Transaction error")
         }.to fail_with(%Q{expected to NOT have node called: 'message' including text: 'Transaction error'. Got: '{"transaction":{"error":{"message":"Transaction error: Name can't be blank"}}}'})
@@ -225,11 +225,11 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
   end
 
   describe "some assumptions" do
-    it "shouldn't fail" do
+    it "pass when have the json node name" do
       '{ "transaction": { "id": 54, "status": "paid" } }'.should have_json_node(:transaction)
     end
 
-    it "also shouldn't fail" do
+    it "pass when have json node with integer value" do
       '{ "transaction": { "id": 54, "status": "paid" } }'.should have_json_node(:id).with(54)
     end
 
@@ -237,15 +237,15 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
       '{"error": "Transaction error: Name cant be blank"}'.should have_json_node(:error).including_text("Transaction error")
     end
 
-    it "should have json node with boolean value" do
+    it "pass have json node with boolean value" do
       '{"creditcard": true}'.should have_json_node(:creditcard).with(true)
     end
 
-    it "should have json node with value" do
+    it "pass have json node with string" do
       '{ "error": "not_authorized", "transaction": { "id": "55" } }'.should have_node(:error).with('not_authorized')
     end
 
-    it "should have json node with integer" do
+    it "pass have json node with integer" do
       '{"parcels": 1 }'.should have_node(:parcels).with(1)
     end
   end
@@ -259,12 +259,12 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
       APIMatchers.setup { |config| config.response_body_method = nil }
     end
 
-    it "should pass if the actual.http_status is equal to 400" do
+    it "pass if the actual.http_status is equal to 400" do
       response = OpenStruct.new(:response_body => { :foo => :bar }.to_json)
       response.should have_json_node(:foo).with('bar')
     end
 
-    it "should fail if the actual.http_status is not equal to 400" do
+    it "fail if the actual.http_status is not equal to 400" do
       response = OpenStruct.new(:response_body => { :baz => :foo}.to_json)
       expect { response.should have_json_node(:bar) }.to fail_with(%Q{expected to have node called: 'bar'. Got: '{"baz":"foo"}'})
     end

data/spec/api_matchers/response_body/have_json_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe APIMatchers::ResponseBody::HaveJson do
+  describe "actual.should have_json" do
+    context 'when pass' do
+      it 'equal json' do
+        ['Petshop', 'Dogs'].to_json.should have_json(['Petshop', 'Dogs'])
+      end
+    end
+
+    context 'when fails' do
+      it 'different json' do
+        expect {
+          ['Petshop', 'Cats'].to_json.should have_json(['Petshop', 'Dogs'])
+        }.to fail_with(%Q{expect to have json: '["Petshop","Cats"]'. Got: '["Petshop", "Cats"]'.})
+      end
+    end
+  end
+
+  describe "actual.should_not have_json" do
+    context 'when pass' do
+      it 'different json' do
+        ['Petshop', 'Cats'].to_json.should_not have_json(['Petshop', 'Dogs'])
+      end
+    end
+
+    context 'when fails' do
+      it 'equal json' do
+        expect {
+          ['Petshop', 'Cats'].to_json.should_not have_json(['Petshop', 'Cats'])
+        }.to fail_with(%Q{expect to NOT have json: '["Petshop","Cats"]'.})
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_matchers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tomas D'Stefano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-24 00:00:00.000000000 Z
+date: 2013-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -71,6 +71,7 @@ files:
 - lib/api_matchers.rb
 - lib/api_matchers/core/exceptions.rb
 - lib/api_matchers/core/find_in_json.rb
+- lib/api_matchers/core/parser.rb
 - lib/api_matchers/core/rspec_matchers.rb
 - lib/api_matchers/core/setup.rb
 - lib/api_matchers/headers/base.rb
@@ -84,6 +85,7 @@ files:
 - lib/api_matchers/http_status_code/be_unauthorized.rb
 - lib/api_matchers/http_status_code/create_resource.rb
 - lib/api_matchers/response_body/base.rb
+- lib/api_matchers/response_body/have_json.rb
 - lib/api_matchers/response_body/have_json_node.rb
 - lib/api_matchers/response_body/have_node.rb
 - lib/api_matchers/response_body/have_xml_node.rb
@@ -102,6 +104,7 @@ files:
 - spec/api_matchers/http_status_code/create_resource_spec.rb
 - spec/api_matchers/response_body/base_spec.rb
 - spec/api_matchers/response_body/have_json_node_spec.rb
+- spec/api_matchers/response_body/have_json_spec.rb
 - spec/api_matchers/response_body/have_node_spec.rb
 - spec/api_matchers/response_body/have_xml_node_spec.rb
 - spec/spec_helper.rb
@@ -143,6 +146,7 @@ test_files:
 - spec/api_matchers/http_status_code/create_resource_spec.rb
 - spec/api_matchers/response_body/base_spec.rb
 - spec/api_matchers/response_body/have_json_node_spec.rb
+- spec/api_matchers/response_body/have_json_spec.rb
 - spec/api_matchers/response_body/have_node_spec.rb
 - spec/api_matchers/response_body/have_xml_node_spec.rb
 - spec/spec_helper.rb