api_matchers 0.1.0 → 0.1.1

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.DS_Store

data/History.markdown

@@ -1,3 +1,8 @@
+## v0.1.1
+
+1) Support Datetime, Date and Time comparison (Thanks to Stephen Orens).
+2) The have_node should accept boolean values (Thanks to Stephen Orens).
+
 ## v0.1.0
 
 1) Add the #including_text for have_json_node and have_xml_node matcher:

data/README.markdown

@@ -26,94 +26,165 @@ Collection of RSpec matchers for create your API.
 
 To include all this matchers you need to include the APIMatchers::RSpecMatchers module:
 
+```ruby
     RSpec.configure do |config|
       config.include APIMatchers::RSpecMatchers
     end
+```
 
 ### Have Node Matcher
 
 The have_node matcher parse the actual and see if have the expcted node with the expected value.
 **The default that have_node will parse is JSON.**
 
+You can verify if node exists:
+
+```ruby
       "{ 'transaction': { 'id': '54', 'status': 'paid' } }".should have_node(:transaction)
+```
+
+Or if node exist with a value:
+
+```ruby
+    "{ 'transaction': { 'id': '54', 'status': 'paid' } }".should have_node(:id).with(54)
+```
+
+```ruby
+    "{ 'error': 'not_authorized', 'transaction': { 'id': '55' } }".should have_node(:error).with('not_authorized')
+```
 
-      "{ 'transaction': { 'id': '54', 'status': 'paid' } }".should have_node(:id).with(54)
+```ruby
+   '{"parcels":1 }'.should have_node(:parcels).with(1)
+```
 
-      "{ 'error': 'not_authorized', 'transaction': { 'id': '55' } }".should have_node(:error).with('not_authorized')
+To see the json node and see if include a text, you can do this:
+
+```ruby
+    '{"error": "Transaction error: Name cant be blank"}'.should have_node(:error).including_text("Transaction error")
+```
+
+You can verify boolean values too:
+
+```ruby
+   '{"creditcard":true}'.should have_node(:creditcard).with(true)
+```
 
 ### HAVE NODE Matcher Configuration
 
 You can configure if you want xml(**JSON is the default**):
 
+```ruby
       APIMatchers.setup do |config|
         config.content_type = :xml
       end
+```ruby
+
+```ruby
+    '<transaction><id>200</id><status>paid</status></transaction>'.should have_node(:status)
+```
 
-      '<transaction><id>200</id><status>paid</status></transaction>'.should have_node(:status).with('paid')
+Using the with method:
+
+```ruby
+    '<transaction><id>200</id><status>paid</status></transaction>'.should have_node(:status).with('paid')
+```
+
+Or you can use the **have_xml_node** matcher:
+
+```ruby
+    "<error>Transaction error: Name can't be blank</error>".should have_xml_node(:error).with("Transaction error: Name can't be blank")
+```
+
+To see the xml node and see if include a text, you can do this:
+
+```ruby
+    "<error>Transaction error: Name can't be blank</error>".should have_xml_node(:error).including_text("Transaction error")
+```
 
 **If you work with xml and json in the same API, I recommend that you check the have_json_node and have_xml_node matchers.**
 
 You can configure the name of the method for example:
 
+```ruby
       ## Instead of this
       response.body.should have_node(:foo)
+```
 
+```ruby
       ## YOU can do this
       APIMatchers.setup do |config|
         config.body_method = :body
       end
+```
 
-Then you can use without call the **#body** method:
+Then you can use *without* call the **#body** method:
 
+```ruby
       response.should have_node(:foo).with('bar')
+```
 
 ### Have JSON Node Matcher
 
+```ruby
     "{ 'transaction': { 'id': '54', 'status': 'paid' } }".should have_json_node(:id).with(54)
+```
 
 ### Have XML Node Matcher
 
+```ruby
     "<product><name>gateway</name></product>".should have_xml_node(:name).with('gateway')
-
+```
 
 ### Create Resource Matcher
 
 This matchers see the HTTP STATUS CODE is equal to 201.
 
+```ruby
      response.status.should create_resource
+```
 
 ### BAD REQUEST Matcher
 
 This BAD REQUEST is a matcher that see if the HTTP STATUS code is equal to 400.
 
+```ruby
     response.status.should be_a_bad_request
     response.status.should be_bad_request
+```
 
 ### UNAUTHORIZED Matcher
 
 This UNAUTHORIZED is a matcher that see if the HTTP STATUS code is equal to 401.
 
+```ruby
     response.status.should be_unauthorized
     response.body.should have_node(:message).with('Invalid Credentials')
+```
 
 ### INTERNAL SERVER ERROR Matcher
 
 This INTERNAL SERVER Error is a matcher that see if the HTTP STATUS code is equal to 500.
 
+```ruby
     response.status.should be_internal_server_error
     response.body.should have_node(:message).with('An Internal Error Occurs in our precious app. :S')
+```
 
 ### HTTP STATUS CODE Configuration
 
 You can configure the name method to call the http status code:
 
+```ruby
      APIMatchers.setup do |config|
        config.http_status_method = :status
      end
+```
 
 Then you can use without call the **#status** method:
 
+```ruby
     response.should create_resource
+```
 
 This configurations affects this matchers:
 
@@ -126,28 +197,40 @@ This configurations affects this matchers:
 
 This is a matcher that see if the content type is xml:
 
+```ruby
     response.headers['Content-Type'].should be_in_xml
+```
 
 ### Be in JSON Matcher
 
 This is a matcher that see if the content type is in JSON:
 
+```ruby
     response.headers['Content-Type'].should be_in_json
+```
 
 ### Headers Configuration
 
 You can configure the name method to call the headers and content type:
 
+```ruby
     APIMatchers.setup do |config|
       config.header_method           = :headers
       config.header_content_type_key = 'Content-Type'
     end
+```
 
 Then you can use without call the **#headers** calling the **#['Content-Type']** method:
 
+```ruby
     response.should be_in_json
     response.should be_in_xml
+```
 
 ### Acknowlegments
 
-* Special thanks to Daniel Konishi to contribute in the product that I extracted the matchers to this gem.
+* Special thanks to Daniel Konishi to contribute in the product that I extracted the matchers to this gem.
+
+### Contributors
+
+* Stephen Orens

data/lib/api_matchers.rb

@@ -37,6 +37,7 @@ module APIMatchers
   module Core
     autoload :FindInJSON, 'api_matchers/core/find_in_json'
     autoload :Setup, 'api_matchers/core/setup'
+    autoload :Exceptions, 'api_matchers/core/exceptions'
   end
 
   def self.setup

data/lib/api_matchers/core/exceptions.rb

@@ -0,0 +1,8 @@
+module APIMatchers
+  module Core
+  	module Exceptions
+		class KeyNotFound < StandardError
+  		end
+  	end
+  end
+end

data/lib/api_matchers/core/find_in_json.rb

@@ -9,16 +9,39 @@ module APIMatchers
 
       def find(options={})
         expected_key = options.fetch(:node).to_s
+        expected_value = options[:value]
 
         @json.each do |key, value|
           if key == expected_key
-            return value
+            unless expected_value.nil?
+              if expected_value.is_a? DateTime or expected_value.is_a? Date
+                expected_value = expected_value.to_s
+              elsif expected_value.is_a? Time
+                expected_value = expected_value.to_datetime.to_s
+              end
+            end
+
+            return value if value == expected_value or expected_value.nil?
+          end
+          # do we have more to recurse through?
+          keep_going = nil
+          if value.is_a? Hash or value.is_a? Array
+            keep_going = value                  # hash or array, keep going
+          elsif value.nil? and key.is_a? Hash
+            keep_going = key                    # the array was passed in and now in the key, keep going
           end
-          if value.is_a? Hash
-            return FindInJSON.new(value).find(node: expected_key)
+
+          if keep_going
+            begin
+              # ignore nodes where the key doesn't match
+              return FindInJSON.new(keep_going).find(node: expected_key, value: expected_value)
+            rescue ::APIMatchers::Core::Exceptions::KeyNotFound
+            end
           end
+
         end
-        nil # Don't find anything!
+         # we did not find the requested key
+        raise ::APIMatchers::Core::Exceptions::KeyNotFound.new("key was not found")
       end
     end
   end

data/lib/api_matchers/response_body/have_json_node.rb

@@ -12,14 +12,24 @@ module APIMatchers
           {}
         end
 
-        node = Core::FindInJSON.new(json).find(node: @expected_node.to_s)
+        begin
+          options = {}
+          options[:node] = @expected_node.to_s
+          unless @with_value.nil?
+            options[:value] = @with_value
+          end
 
-        if @with_value
-          node.to_s == @with_value.to_s
-        elsif @expected_including_text
-          node.to_s.include?(@expected_including_text)
-        else
-          node.present?
+          node = Core::FindInJSON.new(json).find( options )
+
+          if @expected_including_text
+            node.to_s.include?(@expected_including_text)
+          else
+            # the node is present
+            true
+          end
+        rescue ::APIMatchers::Core::Exceptions::KeyNotFound
+          # the key was not found
+          false
         end
       end
     end

data/lib/api_matchers/version.rb

@@ -1,3 +1,3 @@
 module APIMatchers
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/api_matchers/core/find_in_json_spec.rb

@@ -15,11 +15,11 @@ module APIMatchers::Core
 
       context 'when node do not exists' do
         it "should return nil if don't find the expected node" do
-          FindInJSON.new('product' => 'pabx').find(node: 'developers').should be nil
+          expect{ FindInJSON.new('product' => 'pabx').find(node: 'developers').should raise_error( ::APIMatchers::Core::Exceptions::KeyNotFound ) }
         end
 
         it "should return nil if don't find the expected node in the deep JSON" do
-          FindInJSON.new('transaction' => { 'id' => 150, 'error' => {} }).find(node: 'code').should be nil
+          expect{ FindInJSON.new('transaction' => { 'id' => 150, 'error' => {} }).find(node: 'code').should raise_error( ::APIMatchers::Core::Exceptions::KeyNotFound ) }
         end
       end
     end

data/spec/api_matchers/response_body/have_json_node_spec.rb

@@ -9,7 +9,7 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
 
       it "should fail when the expected key does not exist" do
         expect {
-         { :product => 'pabx' }.to_json.should have_json_node(:developers)
+          { :product => 'pabx' }.to_json.should have_json_node(:developers)
         }.to fail_with(%Q{expected to have node called: 'developers'. Got: '{"product":"pabx"}'})
       end
 
@@ -17,9 +17,44 @@ describe APIMatchers::ResponseBody::HaveJsonNode 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
+        { :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
+        { :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
+        { :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
+        { :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
+        { :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
+        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
+        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
+        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
         expect {
-         { :product => 'payment-gateway' }.to_json.should have_json_node(:product).with('email-marketing')
+          { :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
 
@@ -30,25 +65,111 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
       end
     end
 
-    context 'expected key and value in more deep in the JSON' do
-      it "should pass when the expected key exist" do
-        { :transaction => { :id => 150 } }.to_json.should have_json_node(:id)
+    context 'expected key and nil value' do
+      it "should pass when the expected key exists" do
+        { :product => nil }.to_json.should have_json_node(:product)
       end
 
-      it "should pass when the expected key and expected value exist" do
-        { :transaction => { :error => { :code => '999' } } }.to_json.should have_json_node(:code).with('999')
+      it "should 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 does not exist" do
+      it "should fail when the expected key exist but the expected value don't 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":{}}}'})
+          { :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}'})
       end
+    end
 
-      it "should 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"}}}'})
+    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
+          { :transaction => { :id => 150 } }.to_json.should have_json_node(:id)
+        end
+
+        it "should 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
+          { :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
+          { :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
+          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
+          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
+          '{ "transaction": {"id": 150 } }'.should have_json_node(:id)
+        end
+
+        it "should 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
+          '{"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
+          '{"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
+          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
+          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
+          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
+          '{"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
+          '{"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
+          '{"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
+          '{"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
+          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
+          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"}}}'})
+        end
       end
     end
 
@@ -76,7 +197,7 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
 
     it "should fail when the expected key exist" do
       expect {
-       { :status => 'paid' }.to_json.should_not have_json_node(:status)
+        { :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
 
@@ -86,7 +207,7 @@ describe APIMatchers::ResponseBody::HaveJsonNode do
 
     it "should 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')
+        { :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
 

data/spec/api_matchers/response_body/have_xml_node_spec.rb

@@ -30,7 +30,7 @@ describe APIMatchers::ResponseBody::HaveXmlNode do
       end
     end
 
-    context 'expected key and value in more deep in the JSON' do
+    context 'expected key and value in more deep in the XML' do
       it "should pass when the expected key exist" do
         "<transaction><id>150</id></transaction>".should have_xml_node(:id)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: api_matchers
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-02 00:00:00.000000000Z
+date: 2012-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2160643300 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: 2.10.0
   type: :runtime
   prerelease: false
-  version_requirements: *2160643300
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.10.0
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2160642800 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: 3.2.5
   type: :runtime
   prerelease: false
-  version_requirements: *2160642800
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.5
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &2160642340 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +53,12 @@ dependencies:
         version: 1.5.2
   type: :runtime
   prerelease: false
-  version_requirements: *2160642340
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.2
 description: Collection of RSpec matchers for create your API.
 email:
 - tomas_stefano@successoft.com
@@ -61,6 +76,7 @@ files:
 - Rakefile
 - api_matchers.gemspec
 - lib/api_matchers.rb
+- lib/api_matchers/core/exceptions.rb
 - lib/api_matchers/core/find_in_json.rb
 - lib/api_matchers/core/rspec_matchers.rb
 - lib/api_matchers/core/setup.rb
@@ -112,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Collection of RSpec matchers for create your API.