pacto 0.3.0.pre → 0.3.0

data/spec/unit/pacto/{request_spec.rb → request_clause_spec.rb}

@@ -1,19 +1,22 @@
 module Pacto
-  describe Request do
+  describe RequestClause do
     let(:host)           { 'http://localhost' }
     let(:method)         { 'GET' }
     let(:path)           { '/hello_world' }
     let(:headers)        { {'accept' => 'application/json'} }
     let(:params)         { {'foo' => 'bar'} }
+    let(:body)           { double :body }
     let(:params_as_json) { "{\"foo\":\"bar\"}" }
     let(:absolute_uri)   { "#{host}#{path}" }
     subject(:request) do
-      described_class.new(host, {
+      RequestClause.new(
+        host,
         'method'  => method,
         'path'    => path,
         'headers' => headers,
-        'params'  => params
-      })
+        'params'  => params,
+        'body'    => body
+      )
     end
 
     it 'has a host' do
@@ -34,6 +37,20 @@ module Pacto
       end
     end
 
+    describe '#schema' do
+      it 'delegates to definition\'s body' do
+        expect(request.schema).to eq body
+      end
+
+      describe 'when definition does not have body' do
+        let(:body) { nil }
+
+        it 'returns an empty empty hash' do
+          expect(request.schema).to eq({})
+        end
+      end
+    end
+
     describe '#path' do
       it 'delegates to definition' do
         expect(request.path).to eq path
@@ -58,30 +75,24 @@ module Pacto
       let(:adapted_response) { double 'adapted response' }
 
       before do
-        HTTParty.stub(:get => response)
-        HTTParty.stub(:post => response)
-        ResponseAdapter.stub(:new => adapted_response)
+        WebMock.stub_request(:get, 'http://localhost/hello_world?foo=bar').
+          to_return(:status => 200, :body => '', :headers => {})
+        WebMock.stub_request(:post, 'http://localhost/hello_world?foo=bar').
+          to_return(:status => 200, :body => '', :headers => {})
+        # TODO: Should we just use WebMock?
       end
 
       context 'for any request' do
-        it 'processes the response with an ResponseAdapter' do
-          ResponseAdapter.should_receive(:new).
-            with(response).
-            and_return(adapted_response)
-          request.execute
-        end
-
-        it 'returns the adapted response' do
-          expect(request.execute).to be adapted_response
+        it 'returns the a Faraday response' do
+          expect(request.execute).to be_a Faraday::Response
         end
       end
 
       context 'for a GET request' do
         it 'makes the request thru the http client' do
-          HTTParty.should_receive(:get).
-            with(absolute_uri, {:query => params, :headers => headers}).
-            and_return(response)
           request.execute
+          expect(WebMock).to have_requested(:get, 'http://localhost/hello_world?foo=bar').
+            with(:headers => headers)
         end
       end
 
@@ -89,32 +100,9 @@ module Pacto
         let(:method)  { 'POST' }
 
         it 'makes the request thru the http client' do
-          HTTParty.should_receive(:post).
-            with(absolute_uri, {:body => params_as_json, :headers => headers}).
-            and_return(response)
           request.execute
-        end
-      end
-    end
-
-    describe '#absolute_uri' do
-      it 'returns the host followed by the path' do
-        expect(request.absolute_uri).to eq absolute_uri
-      end
-    end
-
-    describe '#full_uri' do
-      context 'when the request has a query' do
-        it 'returns the host followed by the path and the query' do
-          expect(request.full_uri).to eq 'http://localhost/hello_world?foo=bar'
-        end
-      end
-
-      context 'when the query does not have a query' do
-        let(:params) { {} }
-
-        it 'returns the host followed by the path' do
-          expect(request.absolute_uri).to eq 'http://localhost/hello_world'
+          expect(WebMock).to have_requested(:post, 'http://localhost/hello_world?foo=bar').
+            with(:headers => headers)
         end
       end
     end

data/spec/unit/pacto/request_pattern_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Pacto
+  describe RequestPattern do
+    let(:method) { :get  }
+    let(:uri_pattern) { double }
+    let(:request_pattern) { double }
+    let(:request) { double(method: method) }
+
+    it 'returns a pattern that combines the contracts method and uri_pattern' do
+      expect(UriPattern).to receive(:for).
+        with(request).
+        and_return(uri_pattern)
+
+      expect(WebMock::RequestPattern).to receive(:new).
+        with(method, uri_pattern).
+        and_return(request_pattern)
+
+      expect(RequestPattern.for(request)).to eq request_pattern
+    end
+  end
+end

data/spec/unit/pacto/response_clause_spec.rb

@@ -0,0 +1,54 @@
+module Pacto
+  describe ResponseClause do
+    let(:body_definition) do
+      {
+        :type => 'object',
+        :required => true,
+        :properties => double('body definition properties')
+      }
+    end
+
+    let(:definition) do
+      {
+        'status' => 200,
+        'headers' => {
+          'Content-Type' => 'application/json'
+        },
+        'body' => body_definition
+      }
+    end
+
+    subject(:response) { ResponseClause.new(definition) }
+
+    it 'has a status' do
+      expect(response.status).to eq(200)
+    end
+
+    it 'has a headers hash' do
+      expect(response.headers).to eq(
+        'Content-Type' => 'application/json'
+      )
+    end
+
+    it 'has a schema' do
+      expect(response.schema).to eq(body_definition)
+    end
+
+    it 'has a default value for the schema' do
+      response = ResponseClause.new(definition.merge('body' => nil))
+      expect(response.schema).to eq(Hash.new)
+    end
+
+    describe 'the response body' do
+      let(:generated_body) { double }
+
+      it 'is the json generated from the schema' do
+        JSON::Generator.should_receive(:generate).
+          with(definition['body']).
+          and_return(generated_body)
+
+        expect(response.body).to eq(generated_body)
+      end
+    end
+  end
+end

data/spec/unit/pacto/stubs/uri_pattern_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Pacto
+  describe UriPattern do
+    context 'with non-strict matchers' do
+      it 'returns a regex containing the host and path' do
+        Pacto.configuration.strict_matchers = false
+        request = double(host: 'myhost.com', path: '/stuff')
+        expect(UriPattern.for(request).to_s).to eq(/myhost\.com\/stuff/.to_s)
+      end
+
+      it 'turns segments preceded by : into wildcards' do
+        Pacto.configuration.strict_matchers = false
+        request = double(host: 'myhost.com', path: '/:id')
+        wildcard = '[^\/\?#]+'
+        expect(UriPattern.for(request).to_s).to eq(/myhost\.com\/#{wildcard}/.to_s)
+      end
+    end
+
+    context 'with strict matchers' do
+      it 'returns a string with the host and path' do
+        Pacto.configuration.strict_matchers = true
+        request = double(host: 'myhost.com', path: '/stuff')
+        expect(UriPattern.for(request)).to eq('myhost.com/stuff')
+      end
+    end
+  end
+end

data/spec/unit/pacto/stubs/webmock_adapter_spec.rb

@@ -0,0 +1,205 @@
+module Pacto
+  module Stubs
+    describe WebMockAdapter do
+      let(:request) do
+        double(
+          :host => 'http://localhost',
+          :method => method,
+          :path => '/hello_world',
+          :headers => {'Accept' => 'application/json'},
+          :params => {'foo' => 'bar'}
+        )
+      end
+
+      let(:method) { :get }
+
+      let(:response) do
+        double(
+          :status => 200,
+          :headers => {},
+          :body => body
+        )
+      end
+
+      let(:body) do
+        {'message' => 'foo'}
+      end
+
+      let(:stubbed_request) do
+        {
+          :path => nil
+        }
+      end
+
+      let(:request_pattern) { double('request_pattern') }
+
+      subject(:built_in) { WebMockAdapter.new }
+
+      before(:each) do
+        stubbed_request.stub(:to_return).with(
+          :status => response.status,
+          :headers => response.headers,
+          :body => response.body.to_json,
+        )
+        stubbed_request.stub(:request_pattern).and_return request_pattern
+      end
+
+      describe '#initialize' do
+        it 'sets up a hook' do
+          WebMock.should_receive(:after_request) do | arg, &block |
+            expect(block.parameters).to have(2).items
+          end
+
+          WebMockAdapter.new
+        end
+      end
+
+      describe '#process_hooks' do
+        let(:request_signature) { double('request_signature') }
+
+        before do
+          Pacto.configuration.hook.stub(:process)
+        end
+
+        it 'calls the registered hook' do
+          Pacto.configuration.hook.should_receive(:process)
+            .with(anything, request_signature, response)
+          built_in.process_hooks request_signature, response
+        end
+
+        it 'calls generate when generate is enabled' do
+          Pacto.generate!
+          WebMockHelper.should_receive(:generate).with(request_signature, response)
+          built_in.process_hooks request_signature, response
+        end
+
+        it 'calls validate when validate mode is enabled' do
+          Pacto.validate!
+          WebMockHelper.should_receive(:validate).with(request_signature, response)
+          built_in.process_hooks request_signature, response
+        end
+      end
+
+      describe '#stub_request!' do
+        before(:each) do
+          WebMock.should_receive(:stub_request) do | method, url |
+            stubbed_request[:path] = url
+            stubbed_request
+          end
+        end
+
+        context 'when the response body is an object' do
+          let(:body) do
+            {'message' => 'foo'}
+          end
+
+          it 'stubs the response body with a json representation' do
+            stubbed_request.should_receive(:to_return).with(
+              :status => response.status,
+              :headers => response.headers,
+              :body => response.body.to_json
+            )
+
+            request_pattern.stub(:with)
+
+            built_in.stub_request! request, response
+          end
+
+          context 'when the response body is an array' do
+            let(:body) do
+              [1, 2, 3]
+            end
+
+            it 'stubs the response body with a json representation' do
+              stubbed_request.should_receive(:to_return).with(
+                :status => response.status,
+                :headers => response.headers,
+                :body => response.body.to_json
+              )
+
+              request_pattern.stub(:with)
+
+              built_in.stub_request! request, response
+            end
+          end
+
+          context 'when the response body is not an object or an array' do
+            let(:body) { nil }
+
+            it 'stubs the response body with the original body' do
+              stubbed_request.should_receive(:to_return).with(
+                :status => response.status,
+                :headers => response.headers,
+                :body => response.body
+              )
+
+              request_pattern.stub(:with)
+
+              built_in.stub_request! request, response
+            end
+          end
+
+          context 'a GET request' do
+            let(:method) { :get }
+
+            it 'uses WebMock to stub the request' do
+              request_pattern.should_receive(:with).
+                with(:headers => request.headers, :query => request.params).
+                and_return(stubbed_request)
+              built_in.stub_request! request, response
+            end
+          end
+
+          context 'a POST request' do
+            let(:method) { :post }
+
+            it 'uses WebMock to stub the request' do
+              request_pattern.should_receive(:with).
+                with(:headers => request.headers, :body => request.params).
+                and_return(stubbed_request)
+              built_in.stub_request! request, response
+            end
+          end
+
+          context 'a request with no headers' do
+            let(:request) do
+              double(
+                :host => 'http://localhost',
+                :method => :get,
+                :path => '/hello_world',
+                :headers => {},
+                :params => {'foo' => 'bar'}
+              )
+            end
+
+            it 'uses WebMock to stub the request' do
+              request_pattern.should_receive(:with).
+                with(:query => request.params).
+                and_return(stubbed_request)
+              built_in.stub_request! request, response
+            end
+          end
+
+          context 'a request with no params' do
+            let(:request) do
+              double(
+                :host => 'http://localhost',
+                :method => :get,
+                :path => '/hello_world',
+                :headers => {},
+                :params => {}
+              )
+            end
+
+            it 'uses WebMock to stub the request' do
+              request_pattern.should_receive(:with).
+                with({}).
+                and_return(stubbed_request)
+              built_in.stub_request! request, response
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/stubs/webmock_helper_spec.rb

@@ -0,0 +1,20 @@
+module Pacto
+  module Stubs
+    describe WebMockHelper do
+      before do
+        WebMock.stub_request(:get, 'www.example.com').to_return(:body => 'pacto')
+        WebMock.after_request do |request_signature, response|
+          @request_signature = request_signature
+          @response = response
+        end
+        Faraday.get 'http://www.example.com'
+      end
+
+      describe '#validate' do
+        it 'validates a WebMock request/response pair' do
+          described_class.validate @request_signature, @response
+        end
+      end
+    end
+  end
+end