api_matchers 0.4.0 → 0.5.0

data/spec/api_matchers/response_body/have_json_spec.rb

@@ -1,37 +1,37 @@
 require 'spec_helper'
 
 describe APIMatchers::ResponseBody::HaveJson do
-  describe "actual.should have_json" do
+  describe "actual).to have_json" do
     context 'when pass' do
       it 'equal json' do
-        ['Petshop', 'Dogs'].to_json.should have_json(['Petshop', 'Dogs'])
+        expect(['Petshop', 'Dogs'].to_json).to have_json(['Petshop', 'Dogs'])
       end
 
       it 'compares with Hash too' do
-        { 'offers' => [10, 90] }.to_json.should have_json({ 'offers' => [10,90] })
+        expect({ 'offers' => [10, 90] }.to_json).to have_json({ 'offers' => [10,90] })
       end
     end
 
     context 'when fails' do
       it 'different json' do
         expect {
-          ['Petshop', 'Cats'].to_json.should have_json(['Petshop', 'Dogs'])
+          expect(['Petshop', 'Cats'].to_json).to 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
+  describe "actual).not_to have_json" do
     context 'when pass' do
       it 'different json' do
-        ['Petshop', 'Cats'].to_json.should_not have_json(['Petshop', 'Dogs'])
+        expect(['Petshop', 'Cats'].to_json).not_to 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'])
+          expect(['Petshop', 'Cats'].to_json).not_to have_json(['Petshop', 'Cats'])
         }.to fail_with(%Q{expect to NOT have json: '["Petshop","Cats"]'.})
       end
     end

data/spec/api_matchers/response_body/have_node_spec.rb

@@ -7,7 +7,7 @@ describe APIMatchers::ResponseBody::HaveNode do
     end
 
     it "should parse the matcher for json" do
-      { :product => 'chat' }.to_json.should have_node(:product).with('chat')
+      expect({ :product => 'chat' }.to_json).to have_node(:product).with('chat')
     end
   end
 
@@ -17,7 +17,7 @@ describe APIMatchers::ResponseBody::HaveNode do
     end
 
     it "should parse the matcher for xml" do
-      "<product>chat</product>".should have_node(:product).with('chat')
+      expect("<product>chat</product>").to have_node(:product).with('chat')
     end
 
     after do

data/spec/api_matchers/response_body/have_xml_node_spec.rb

@@ -1,130 +1,141 @@
 require 'spec_helper'
 
 describe APIMatchers::ResponseBody::HaveXmlNode do
-  describe "actual.should have_xml_node" do
+  describe "actual).to have_xml_node" do
     context 'expected key and value in top level' do
       it "should pass when the expected key exist" do
-        "<product>gateway</product>".should have_xml_node(:product)
+        expect("<product>gateway</product>").to have_xml_node(:product)
       end
 
       it "should fail when the expected key does not exist" do
         expect {
-          "<product>pabx</product>".should have_xml_node(:developers)
+          expect("<product>pabx</product>").to have_xml_node(:developers)
         }.to fail_with(%Q{expected to have node called: 'developers'. Got: '<product>pabx</product>'})
       end
 
       it "should pass when the expected key exist with the expected value" do
-        "<product>payment-gateway</product>".should have_xml_node(:product).with('payment-gateway')
+        expect("<product>payment-gateway</product>").to have_xml_node(:product).with('payment-gateway')
       end
 
       it "should fail when the expected key exist but the expected value don't exist" do
         expect {
-          "<product>payment-gateway</product>".should have_xml_node(:product).with('email-marketing')
+          expect("<product>payment-gateway</product>").to have_xml_node(:product).with('email-marketing')
         }.to fail_with(%Q{expected to have node called: 'product' with value: 'email-marketing'. Got: '<product>payment-gateway</product>'})
       end
 
       it "should not parse the matcher for xml when you pass a json" do
         expect {
-          { :name => 'webdesk'}.to_json.should have_xml_node(:name).with('webdesk')
+          expect({ :name => 'webdesk'}.to_json).to have_xml_node(:name).with('webdesk')
         }.to fail_with(%Q{expected to have node called: 'name' with value: 'webdesk'. Got: '{"name":"webdesk"}'})
       end
     end
 
     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)
+        expect("<transaction><id>150</id></transaction>").to have_xml_node(:id)
       end
 
       it "should pass when the expected key and expected value exist" do
-        "<transaction><error><code>999</code></error></transaction>".should have_xml_node(:code).with('999')
+        expect("<transaction><error><code>999</code></error></transaction>").to have_xml_node(:code).with('999')
       end
 
       it "should fail when the expected key does not exist" do
         expect {
-         "<transaction><error></error></transaction>".should have_xml_node(:code)
+         expect("<transaction><error></error></transaction>").to have_xml_node(:code)
         }.to fail_with(%Q{expected to have node called: 'code'. Got: '<transaction><error></error></transaction>'})
       end
 
       it "should fail when the expected key exist but don't exist the expected value" do
         expect {
-         "<transaction><error><code>999</code></error></transaction>".should have_xml_node(:code).with('001')
+         expect("<transaction><error><code>999</code></error></transaction>").to have_xml_node(:code).with('001')
         }.to fail_with(%Q{expected to have node called: 'code' with value: '001'. Got: '<transaction><error><code>999</code></error></transaction>'})
       end
     end
 
     context "including_text" do
       it "should pass when the expected is included in the actual" do
-        "<error><message>Transaction error: Name can't be blank</message></error>".should have_xml_node(:message).including_text("Transaction error")
+        expect("<error><message>Transaction error: Name can't be blank</message></error>").to have_xml_node(:message).including_text("Transaction error")
       end
 
       it "should fail when the expected is not included in the actual" do
         expect {
-          "<error><message>Transaction error: Name can't be blank</message></error>".should have_xml_node(:message).including_text("Fox on the run")
+          expect("<error><message>Transaction error: Name can't be blank</message></error>").to have_xml_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: '<error><message>Transaction error: Name can't be blank</message></error>'})
       end
     end
 
     context "find matching node when multiple records" do
       it "should pass when the expected is included in the actual (1 level)" do
-        %{<messages>
-          <message><id>4</id></message>
-          <message><id>2</id></message>
-        </messages>}.should have_xml_node(:id).with(2)
+        expect(%{
+          <messages>
+            <message><id>4</id></message>
+            <message><id>2</id></message>
+          </messages>
+        }).to have_xml_node(:id).with(2)
       end
+
       it "should fail when the expected is not included in the actual (1 level)" do
-        %{<messages>
-          <message><id>4</id></message>
-          <message><id>2</id></message>
-        </messages>}.should_not have_xml_node(:id).with(3)
+        expect(%{
+          <messages>
+            <message><id>4</id></message>
+            <message><id>2</id></message>
+          </messages>
+        }).not_to have_xml_node(:id).with(3)
       end
+
       it "should pass when the expected is included in the actual (2 levels)" do
-        %{<messages>
-          <message><header><id>4</id></header></message>
-          <message><header><id>2</id></header></message>
-        </messages>}.should have_xml_node(:id).with(2)
+        expect(%{
+          <messages>
+            <message><header><id>4</id></header></message>
+            <message><header><id>2</id></header></message>
+          </messages>
+        }).to have_xml_node(:id).with(2)
       end
+
       it "should fail when the expected is not included in the actual (2 levels)" do
-        %{<messages>
-          <message><header><id>4</id></header></message>
-          <message><header><id>2</id></header></message>
-        </messages>}.should_not have_xml_node(:id).with(3)
+        expect(%{
+          <messages>
+            <message><header><id>4</id></header></message>
+            <message><header><id>2</id></header></message>
+          </messages>
+        }).not_to have_xml_node(:id).with(3)
       end
     end
   end
 
-  describe "actual.should_not have_xml_node" do
+  describe "actual).not_to have_xml_node" do
     it "should pass when don't have the expected node in root level" do
-      "<product>gateway</product>".should_not have_xml_node(:status)
+      expect("<product>gateway</product>").not_to have_xml_node(:status)
     end
 
     it "should pass when don't have the expected node in any level" do
-      "<transaction><id>12</id><status>paid</status></transaction>".should_not have_xml_node(:error)
+      expect("<transaction><id>12</id><status>paid</status></transaction>").not_to have_xml_node(:error)
     end
 
     it "should fail when the expected key exist" do
       expect {
-       "<transaction><status>paid</status></transaction>".should_not have_xml_node(:status)
+       expect("<transaction><status>paid</status></transaction>").not_to have_xml_node(:status)
       }.to fail_with(%Q{expected to NOT have node called: 'status'. Got: '<transaction><status>paid</status></transaction>'})
     end
 
     it "should pass when have the expected key but have a different value" do
-      "<status>paid</status>".should_not have_xml_node(:status).with('not_authorized')
+      expect("<status>paid</status>").not_to have_xml_node(:status).with('not_authorized')
     end
 
     it "should fail when have the expected key and have the expected value" do
       expect {
-       "<transaction><status>paid</status></transaction>".should_not have_xml_node(:status).with('paid')
+       expect("<transaction><status>paid</status></transaction>").not_to have_xml_node(:status).with('paid')
       }.to fail_with(%Q{expected to NOT have node called: 'status' with value: 'paid'. Got: '<transaction><status>paid</status></transaction>'})
     end
 
     context "including_text" do
       it "should pass when the expected is included in the actual" do
-        "<error><message>Transaction error: Name can't be blank</message></error>".should_not have_xml_node(:message).including_text("Girls of Summer")
+        expect("<error><message>Transaction error: Name can't be blank</message></error>").not_to have_xml_node(:message).including_text("Girls of Summer")
       end
 
       it "should fail when the expected is not included in the actual" do
         expect {
-          "<error><message>Transaction error: Name can't be blank</message></error>".should_not have_xml_node(:message).including_text("Transaction error")
+          expect("<error><message>Transaction error: Name can't be blank</message></error>").not_to have_xml_node(:message).including_text("Transaction error")
         }.to fail_with(%Q{expected to NOT have node called: 'message' including text: 'Transaction error'. Got: '<error><message>Transaction error: Name can't be blank</message></error>'})
       end
     end
@@ -142,12 +153,14 @@ describe APIMatchers::ResponseBody::HaveXmlNode do
 
     it "should pass if the actual.http_status is equal to 400" do
       response = OpenStruct.new(:response_body => "<foo>bar</foo>")
-      response.should have_xml_node(:foo).with('bar')
+      expect(response).to have_xml_node(:foo).with('bar')
     end
 
     it "should fail if the actual.http_status is not equal to 400" do
       response = OpenStruct.new(:response_body => "<baz>bar</baz>")
-      expect { response.should have_xml_node(:bar) }.to fail_with(%Q{expected to have node called: 'bar'. Got: '<baz>bar</baz>'})
+      expect {
+        expect(response).to have_xml_node(:bar)
+      }.to fail_with(%Q{expected to have node called: 'bar'. Got: '<baz>bar</baz>'})
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_matchers
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Tomas D'Stefano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-12 00:00:00.000000000 Z
+date: 2014-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '2.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -60,6 +60,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - .rvmrc.example
 - .travis.yml
 - Gemfile
@@ -84,6 +85,7 @@ files:
 - lib/api_matchers/http_status_code/be_not_found.rb
 - lib/api_matchers/http_status_code/be_ok.rb
 - lib/api_matchers/http_status_code/be_unauthorized.rb
+- lib/api_matchers/http_status_code/be_unprocessable_entity.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
@@ -102,6 +104,7 @@ files:
 - spec/api_matchers/http_status_code/be_not_found_spec.rb
 - spec/api_matchers/http_status_code/be_ok_spec.rb
 - spec/api_matchers/http_status_code/be_unauthorized_spec.rb
+- spec/api_matchers/http_status_code/be_unprocessable_entity_spec.rb
 - 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
@@ -128,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.10
+rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
 summary: Collection of RSpec matchers for create your API.
@@ -144,6 +147,7 @@ test_files:
 - spec/api_matchers/http_status_code/be_not_found_spec.rb
 - spec/api_matchers/http_status_code/be_ok_spec.rb
 - spec/api_matchers/http_status_code/be_unauthorized_spec.rb
+- spec/api_matchers/http_status_code/be_unprocessable_entity_spec.rb
 - 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