api_matchers 0.0.1

data/spec/api_matchers/core/find_in_json_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module APIMatchers::Core
+  describe FindInJSON do
+    describe "#find" do
+      context 'when node exists' do
+        it "should return the value of the expected key" do
+          FindInJSON.new('product' => 'gateway').find(node: 'product').should eql 'gateway'
+        end
+
+        it "should return the value of the deep expected key in the json" do
+          FindInJSON.new('transaction' => { 'error' => { 'code' => '999' } }).find(node: 'code').should eql '999'
+        end
+      end
+
+      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
+        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
+        end
+      end
+    end
+  end
+end

data/spec/api_matchers/core/setup_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe APIMatchers::Core::Setup do
+end

data/spec/api_matchers/headers/base_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe APIMatchers::Headers::Base do
+  let(:setup) { OpenStruct.new }
+  subject { APIMatchers::Headers::Base.new(setup) }
+
+  describe "#matches?" do
+    it "should raise Not Implement Exception" do
+      expect { subject.matches?('application/xml') }.to raise_error(NotImplementedError, "not implemented on #{subject}")
+    end
+  end
+end

data/spec/api_matchers/headers/be_json_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe APIMatchers::Headers::BeJSON do
+  describe "actual.should be_json" do
+    it "should pass when the actual is json response" do
+      "application/json; charset=utf-8".should be_json
+    end
+
+    it "should not pass when the actual is not a json response" do
+      expect { "application/xml; charset=utf-8".should be_json }.to fail_with(%Q{expected a JSON response with 'application/json; charset=utf-8'. Got: 'application/xml; charset=utf-8'.})
+    end
+  end
+
+  describe "actual.should_not be_json" do
+    it "should pass when the actual is not a json response" do
+      "application/xml; charset=utf-8".should_not be_json
+    end
+
+    it "should not pass when the actual is a json response" do
+      expect { "application/json; charset=utf-8".should_not be_json }.to fail_with(%Q{expected to not be a JSON response. Got: 'application/json; charset=utf-8'.})
+    end
+  end
+end

data/spec/api_matchers/headers/be_xml_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe APIMatchers::Headers::BeXML do
+  describe "actual.should be_xml" do
+    it "should pass when the actual is json response" do
+      "application/xml; charset=utf-8".should be_xml
+    end
+
+    it "should not pass when the actual is not a json response" do
+      expect {
+        "application/json; charset=utf-8".should be_xml
+      }.to fail_with(%Q{expected a XML response with 'application/xml; charset=utf-8'. Got: 'application/json; charset=utf-8'.})
+    end
+  end
+
+  describe "actual.should_not be_xml" do
+    it "should pass when the actual is not a json response" do
+      "application/json; charset=utf-8".should_not be_xml
+    end
+
+    it "should not pass when the actual is a json response" do
+      expect {
+        "application/xml; charset=utf-8".should_not be_xml
+      }.to fail_with(%Q{expected to not be a XML response. Got: 'application/xml; charset=utf-8'.})
+    end
+  end
+end

data/spec/api_matchers/http_status_code/base_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe APIMatchers::HTTPStatusCode::Base do
+  let(:setup) { OpenStruct.new }
+  subject { APIMatchers::HTTPStatusCode::Base.new(setup) }
+
+  describe "#matches?" do
+    it "should raise Not Implement Exception" do
+      expect { subject.matches?(302) }.to raise_error(NotImplementedError, "not implemented on #{subject}")
+    end
+  end
+end

data/spec/api_matchers/http_status_code/be_bad_request_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe APIMatchers::HTTPStatusCode::BeBadRequest do
+  describe "should be_bad_request" do
+    it "should passes if the actual is equal to 400" do
+      400.should be_bad_request
+    end
+
+    it "should fails if the actual is not equal to 400" do
+      expect { 401.should be_bad_request }.to fail_with(%Q{expected that '401' to be a Bad Request with the status '400'.})
+    end
+  end
+
+  describe "should_not be_bad_request" do
+    it "should passes if the actual is not equal to 400" do
+      401.should_not be_bad_request
+    end
+
+    it "should fail if the actual is equal to 400" do
+      expect { 400.should_not be_bad_request }.to fail_with(%Q{expected that '400' to NOT be a Bad Request with the status '400'.})
+    end
+  end
+
+  describe "with change configuration" do
+    before do
+      APIMatchers.setup { |config| config.http_status_method = :http_status }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.http_status_method = nil }
+    end
+
+    it "should pass if the actual.http_status is equal to 400" do
+      response = OpenStruct.new(:http_status => 400)
+      response.should be_bad_request
+    end
+
+    it "should fail if the actual.http_status is not equal to 400" do
+      response = OpenStruct.new(:http_status => 500)
+      expect { response.should be_bad_request }.to fail_with(%Q{expected that '500' to be a Bad Request with the status '400'.})
+    end
+  end
+end

data/spec/api_matchers/http_status_code/be_internal_server_error_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe APIMatchers::HTTPStatusCode::BeInternalServerError do
+  describe "should be_internal_server_error" do
+    it "should passes if the actual is equal to 500" do
+      500.should be_internal_server_error
+    end
+
+    it "should fails if the actual is not equal to 500" do
+      expect { 401.should be_internal_server_error }.to fail_with(%Q{expected that '401' to be Internal Server Error with the status '500'.})
+    end
+  end
+
+  describe "should_not be_internal_server_error" do
+    it "should passes if the actual is not equal to 500" do
+      400.should_not be_internal_server_error
+    end
+
+    it "should fail if the actual is equal to 500" do
+      expect { 500.should_not be_internal_server_error }.to fail_with(%Q{expected that '500' to NOT be Internal Server Error.})
+    end
+  end
+
+  describe "with change configuration" do
+    before do
+      APIMatchers.setup { |config| config.http_status_method = :http_status }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.http_status_method = nil }
+    end
+
+    it "should pass if the actual.http_status is equal to 500" do
+      response = OpenStruct.new(:http_status => 500)
+      response.should be_internal_server_error
+    end
+
+    it "should fail if the actual.http_status is not equal to 500" do
+      response = OpenStruct.new(:http_status => 402)
+      expect { response.should be_internal_server_error }.to fail_with(%Q{expected that '402' to be Internal Server Error with the status '500'.})
+    end
+  end
+end

data/spec/api_matchers/http_status_code/be_unauthorized_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe APIMatchers::HTTPStatusCode::BeUnauthorized do
+  describe "should be_unauthorized" do
+    it "should passes if the actual is equal to 401" do
+      401.should be_unauthorized
+    end
+
+    it "should fails if the actual is not equal to 401" do
+      expect { 400.should be_unauthorized }.to fail_with(%Q{expected that '400' to be Unauthorized with the status '401'.})
+    end
+  end
+
+  describe "should_not be_unauthorized" do
+    it "should passes if the actual is not equal to 401" do
+      201.should_not be_unauthorized
+    end
+
+    it "should fail if the actual is equal equal to 401" do
+      expect { 401.should_not be_unauthorized }.to fail_with(%Q{expected that '401' to NOT be Unauthorized.})
+    end
+  end
+
+  describe "with change configuration" do
+    before do
+      APIMatchers.setup { |config| config.http_status_method = :http_status }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.http_status_method = nil }
+    end
+
+    it "should pass if the actual.http_status is equal to 401" do
+      response = OpenStruct.new(:http_status => 401)
+      response.should be_unauthorized
+    end
+
+    it "should fail if the actual.http_status is not equal to 401" do
+      response = OpenStruct.new(:http_status => 402)
+      expect { response.should be_unauthorized }.to fail_with(%Q{expected that '402' to be Unauthorized with the status '401'.})
+    end
+  end
+end

data/spec/api_matchers/http_status_code/create_resource_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe APIMatchers::HTTPStatusCode::CreateResource do
+  describe "should create_resource" do
+    it "should passes if the actual is equal to 201" do
+      201.should create_resource
+    end
+
+    it "should fails if the actual is not equal to 201" do
+      expect { 200.should create_resource }.to fail_with(%Q{expected that '200' to be Created Resource with the status '201'.})
+    end
+  end
+
+  describe "should_not create_resource" do
+    it "should passes if the actual is not equal to 201" do
+      401.should_not create_resource
+    end
+
+    it "should fail if the actual is equal equal to 201" do
+      expect { 201.should_not create_resource }.to fail_with(%Q{expected that '201' to NOT be Created Resource.})
+    end
+  end
+
+  describe "with change configuration" do
+    before do
+      APIMatchers.setup { |config| config.http_status_method = :http_status }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.http_status_method = nil }
+    end
+
+    it "should pass if the actual.http_status is equal to 201" do
+      response = OpenStruct.new(:http_status => 201)
+      response.should create_resource
+    end
+
+    it "should fail if the actual.http_status is not equal to 201" do
+      response = OpenStruct.new(:http_status => 402)
+      expect { response.should create_resource }.to fail_with(%Q{expected that '402' to be Created Resource with the status '201'.})
+    end
+  end
+end

data/spec/api_matchers/response_body/base_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe APIMatchers::ResponseBody::Base do
+  let(:setup) { OpenStruct.new(:response_body_method => :body) }
+  subject { APIMatchers::ResponseBody::Base.new(setup: setup, expected_node: :status) }
+
+  describe "#matches?" do
+    it "should raise Not Implemented Error" do
+      expect {
+        subject.matches?("foo")
+      }.to raise_error(NotImplementedError, "not implemented on #{subject}")
+    end
+  end
+
+  describe "#setup" do
+    it "should read from the initialize" do
+      subject.setup.should equal setup
+    end
+  end
+
+  describe "#expected_node" do
+    it "should read from the initialize" do
+      subject.expected_node.should equal :status
+    end
+  end
+
+  describe "#response_body" do
+    let(:body) { { :foo => :bar}.to_json }
+
+    context 'when have configuration' do
+      it "should call the method when is config" do
+        subject.actual = OpenStruct.new(:body => body)
+        subject.response_body.should eql body
+      end
+    end
+
+    context 'when dont have configuration' do
+      let(:setup) { OpenStruct.new(:response_body_method => nil) }
+      subject { APIMatchers::ResponseBody::Base.new(setup: setup, expected_node: :status) }
+
+      it "should return the actual when do not have config" do
+        subject.actual = body
+        subject.response_body.should eql body
+      end
+    end
+  end
+end

data/spec/api_matchers/response_body/have_json_node_spec.rb

@@ -0,0 +1,101 @@
+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
+        { :product => 'gateway' }.to_json.should have_json_node(:product)
+      end
+
+      it "should 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
+        { :product => 'payment-gateway' }.to_json.should have_json_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' }.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
+        expect {
+          "<product><name>webdesk</name></product>".should have_json_node(:name).with('webdesk')
+        }.to fail_with(%Q{expected to have node called: 'name' with value: 'webdesk'. Got: '<product><name>webdesk</name></product>'})
+      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)
+      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 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
+  end
+
+  describe "actual.should_not have_json_node" do
+    it "should 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
+      { :transaction => { :id => 12, :status => 'paid' } }.to_json.should_not have_json_node(:error)
+    end
+
+    it "should 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
+      { :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
+      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
+  end
+
+  describe "with change configuration" do
+    before do
+      APIMatchers.setup { |config| config.response_body_method = :response_body }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.response_body_method = nil }
+    end
+
+    it "should 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
+      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
+  end
+end

data/spec/api_matchers/response_body/have_node_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe APIMatchers::ResponseBody::HaveNode do
+  describe "in json" do
+    before do
+      APIMatchers.setup { |config| config.have_node_matcher = :json }
+    end
+
+    it "should parse the matcher for json" do
+      { :product => 'chat' }.to_json.should have_node(:product).with('chat')
+    end
+  end
+
+  describe "in xml" do
+    before do
+      APIMatchers.setup { |config| config.have_node_matcher = :xml }
+    end
+
+    it "should parse the matcher for xml" do
+      "<product>chat</product>".should have_node(:product).with('chat')
+    end
+
+    after do
+      APIMatchers.setup { |config| config.have_node_matcher = :json }
+    end
+  end
+end

data/spec/api_matchers/response_body/have_xml_node_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe APIMatchers::ResponseBody::HaveXmlNode do
+  describe "actual.should 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)
+      end
+
+      it "should fail when the expected key does not exist" do
+        expect {
+          "<product>pabx</product>".should 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')
+      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')
+        }.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')
+        }.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 JSON' do
+      it "should pass when the expected key exist" do
+        "<transaction><id>150</id></transaction>".should 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')
+      end
+
+      it "should fail when the expected key does not exist" do
+        expect {
+         "<transaction><error></error></transaction>".should 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')
+        }.to fail_with(%Q{expected to have node called: 'code' with value: '001'. Got: '<transaction><error><code>999</code></error></transaction>'})
+      end
+    end
+  end
+
+  describe "actual.should_not 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)
+    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)
+    end
+
+    it "should fail when the expected key exist" do
+      expect {
+       "<transaction><status>paid</status></transaction>".should_not 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')
+    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')
+      }.to fail_with(%Q{expected to NOT have node called: 'status' with value: 'paid'. Got: '<transaction><status>paid</status></transaction>'})
+    end
+  end
+
+
+  describe "with change configuration" do
+    before do
+      APIMatchers.setup { |config| config.response_body_method = :response_body }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.response_body_method = nil }
+    end
+
+    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')
+    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>'})
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'api_matchers'
+require 'ostruct'
+
+RSpec.configure do |config|
+  config.include APIMatchers::RSpecMatchers
+
+  def fail_with(message)
+    raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+  end
+end