pacto 0.3.1 → 0.4.0.rc1

data/spec/unit/pacto/stubs/observers/stenographer_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+module Pacto
+  module Observers
+    describe Stenographer do
+      let(:pacto_request) { Fabricate(:pacto_request) }
+      let(:pacto_response) { Fabricate(:pacto_response) }
+      let(:contract) { Fabricate(:contract) }
+      let(:citations) { %w(one two) }
+      let(:investigation) { Pacto::Investigation.new(pacto_request, pacto_response, contract, citations) }
+
+      subject(:stream) { StringIO.new }
+
+      subject { described_class.new stream }
+
+      it 'writes to the stenographer log stream' do
+        subject.log_investigation investigation
+        expected_log_line = "request #{contract.name.inspect}, values: {}, response: {status: #{pacto_response.status}} # #{citations.size} contract violations\n"
+        expect(stream.string).to eq expected_log_line
+      end
+
+      context 'when the stenographer log stream is nil' do
+        let(:stream) { nil }
+
+        it 'does nothing' do
+          # Would raise an error if it tried to write to stream
+          subject.log_investigation investigation
+        end
+      end
+    end
+  end
+end

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

@@ -1,27 +1,55 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 module Pacto
   describe UriPattern do
     context 'with non-strict matchers' do
-      it 'returns a regex containing the host and path' do
+      before(:each) 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)
+      it 'appends host if path is an Addressable::Template' do
+        path_pattern = '/{account}/data{.format}{?page,per_page}'
+        path = Addressable::Template.new path_pattern
+        request = Fabricate(:request_clause, host: 'https://www.example.com', path: path)
+        expect(UriPattern.for(request).pattern).to include(Addressable::Template.new("https://www.example.com#{path_pattern}").pattern)
+      end
+
+      it 'returns a URITemplate containing the host and path and wildcard vars' do
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/stuff')
+        uri_pattern = UriPattern.for(request)
+        expect(uri_pattern.pattern).to eql('{scheme}://myhost.com/stuff{?anyvars*}')
+      end
+
+      it 'convers segments preceded by : into variables', :deprecated do
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
+        uri_pattern = UriPattern.for(request)
+        expect(uri_pattern.keys).to include('id')
+        expect(uri_pattern.pattern).to_not include(':id')
+      end
+
+      it 'creates a regex that does not allow additional path elements' do
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
+        pattern = UriPattern.for(request)
+        expect(pattern).to match('http://myhost.com/foo')
+        expect(pattern).to_not match('http://myhost.com/foo/bar')
+      end
+
+      it 'creates a regex that does allow query parameters', :deprecated do
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
+        pattern = UriPattern.for(request)
+        expect(pattern.match('http://myhost.com/foo?a=b')). to be_truthy
+        expect(pattern.match('http://myhost.com/foo?a=b&c=d')).to be_truthy
       end
     end
 
-    context 'with strict matchers' do
+    # Strict/relaxed matching should be done against the full URI or path only
+    context 'with strict matchers', deprecated: true 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')
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/stuff')
+        uri_pattern = UriPattern.for(request)
+        expect(uri_pattern.pattern).to eq('{scheme}://myhost.com/stuff')
       end
     end
   end

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

@@ -1,89 +1,85 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   module Stubs
+    # FIXME: Review this test and see which requests are Pacto vs WebMock, then use Fabricate
     describe WebMockAdapter do
+      let(:middleware) { double('middleware') }
+
       let(:request) do
-        double(
-          :host => 'http://localhost',
-          :method => method,
-          :path => '/hello_world',
-          :headers => {'Accept' => 'application/json'},
-          :params => {'foo' => 'bar'}
+        Fabricate(:request_clause,
+                  host: 'http://localhost',
+                  http_method: http_method,
+                  path: '/hello_world',
+                  headers: { 'Accept' => 'application/json' },
+                  params: { 'foo' => 'bar' }
         )
       end
 
-      let(:method) { :get }
+      let(:http_method) { :get }
 
       let(:response) do
-        double(
-          :status => 200,
-          :headers => {},
-          :body => body
+        Fabricate(
+          :response_clause,
+          status: 200,
+          headers: {},
+          schema: {
+            type: 'object',
+            required: ['message'],
+            properties: {
+              message: {
+                type: 'string',
+                default: 'foo'
+              }
+            }
+          }
         )
       end
 
+      let(:contract) do
+        Fabricate(:contract, request: request, response: response)
+      end
+
       let(:body) do
-        {'message' => 'foo'}
+        { 'message' => 'foo' }
       end
 
       let(:stubbed_request) do
         {
-          :path => nil
+          path: nil
         }
       end
 
       let(:request_pattern) { double('request_pattern') }
 
-      subject(:built_in) { WebMockAdapter.new }
+      subject(:adapter) { WebMockAdapter.new middleware }
 
       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
+        allow(stubbed_request).to receive(:to_return).with(no_args)
+        allow(stubbed_request).to receive(: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
+          expect(WebMock).to receive(:after_request) do | _arg, &block |
+            expect(block.parameters.size).to eq(2)
           end
 
-          # WebMockAdapter.new
-          Pacto.configuration.provider # this way the rpec after block doesn't create a second instance
+          Pacto.configuration.adapter # (rather than WebMockAdapter.new, to prevent rpec after block from creating a second instance
         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
+        it 'calls the middleware for processing' do
+          expect(middleware).to receive(:process).with(a_kind_of(Pacto::PactoRequest), a_kind_of(Pacto::PactoResponse))
+          adapter.process_hooks request_signature, response
         end
       end
 
       describe '#stub_request!' do
         before(:each) do
-          WebMock.should_receive(:stub_request) do | method, url |
+          expect(WebMock).to receive(:stub_request) do | _method, url |
             stubbed_request[:path] = url
             stubbed_request
           end
@@ -91,112 +87,66 @@ module Pacto
 
         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
+            { 'message' => 'foo' }
           end
 
           context 'a GET request' do
-            let(:method) { :get }
+            let(:http_method) { :get }
 
             it 'uses WebMock to stub the request' do
-              request_pattern.should_receive(:with).
-                with(:headers => request.headers, :query => request.params).
+              expect(request_pattern).to receive(:with).
+                with(headers: request.headers, query: request.params).
                 and_return(stubbed_request)
-              built_in.stub_request! request, response
+              adapter.stub_request! contract
             end
           end
 
           context 'a POST request' do
-            let(:method) { :post }
+            let(:http_method) { :post }
 
             it 'uses WebMock to stub the request' do
-              request_pattern.should_receive(:with).
-                with(:headers => request.headers, :body => request.params).
+              expect(request_pattern).to receive(:with).
+                with(headers: request.headers, body: request.params).
                 and_return(stubbed_request)
-              built_in.stub_request! request, response
+              adapter.stub_request! contract
             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'}
+              Fabricate(:request_clause,
+                        host: 'http://localhost',
+                        http_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).
+              expect(request_pattern).to receive(:with).
+                with(query: request.params).
                 and_return(stubbed_request)
-              built_in.stub_request! request, response
+              adapter.stub_request! contract
             end
           end
 
           context 'a request with no params' do
             let(:request) do
-              double(
-                :host => 'http://localhost',
-                :method => :get,
-                :path => '/hello_world',
-                :headers => {},
-                :params => {}
+              Fabricate(:request_clause,
+                        host: 'http://localhost',
+                        http_method: :get,
+                        path: '/hello_world',
+                        headers: {},
+                        params: {}
               )
             end
 
             it 'uses WebMock to stub the request' do
-              request_pattern.should_receive(:with).
+              expect(request_pattern).to receive(:with).
                 with({}).
                 and_return(stubbed_request)
-              built_in.stub_request! request, response
+              adapter.stub_request! contract
             end
           end
         end

data/spec/unit/pacto/swagger_contract_factory_spec.rb

@@ -0,0 +1,56 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Generator
+    describe SwaggerContractFactory do
+      let(:swagger_file) { 'spec/fixtures/swagger/petstore.yaml' }
+      let(:expected_schema) do
+        {
+          'type' => 'array',
+          'items' => {
+            'required' => %w(id name),
+            'properties' => {
+              'id' => { 'type' => 'integer', 'format' => 'int64' },
+              'name' => { 'type' => 'string' },
+              'tag' => { 'type' => 'string' }
+            }
+          }
+        }
+      end
+      describe '#load_hints' do
+        it 'loads hints from Swagger' do
+          hints = subject.load_hints(swagger_file)
+          expect(hints.size).to eq(3) # number of API operations
+          hints.each do | hint |
+            expect(hint).to be_a_kind_of(Pacto::Generator::Hint)
+            expect(hint.host).to eq('petstore.swagger.wordnik.com')
+            expect([:get, :post]).to include(hint.http_method)
+            expect(hint.path).to match(/\/pets/)
+          end
+        end
+      end
+
+      describe '#build_from_file' do
+        it 'loads Contracts from Swagger' do
+          contracts = subject.build_from_file(swagger_file)
+          expect(contracts.size).to eq(3) # number of API operations
+          contracts.each do | contract |
+            expect(contract).to be_a_kind_of(Pacto::Contract)
+
+            request_clause = contract.request
+            expect(request_clause.host).to eq('petstore.swagger.wordnik.com')
+            expect([:get, :post]).to include(request_clause.http_method)
+            expect(request_clause.path).to match(/\/pets/)
+
+            response_clause = contract.response
+            if request_clause.http_method == :get
+              expect(response_clause.status).to eq(200)
+            else
+              expect(response_clause.status).to eq(201)
+            end
+            expect(response_clause.schema).to eq(expected_schema) if response_clause.status == 200
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/uri_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 module Pacto

data/tasks/release.rake

@@ -0,0 +1,57 @@
+require 'octokit'
+
+def github
+  @client ||= Octokit::Client.new :access_token => ENV['GITHUB_TOKEN']
+end
+
+def release_tag
+  "v#{Pacto::VERSION}"
+end
+
+def release
+  @release ||= github.list_releases('thoughtworks/pacto').find{|r| r.name == release_tag }
+end
+
+def changelog
+  changelog = File.read('changelog.md').split("\n\n\n", 2).first
+  confirm 'Does the CHANGELOG look correct? ', changelog
+end
+
+def confirm(question, data)
+  puts 'Please confirm...'
+  puts data
+  print question
+  abort 'Aborted' unless $stdin.gets.strip == 'y'
+  puts 'Confirmed'
+  data
+end
+
+desc 'Tags and pushes the gem'
+task :release_gem do
+  sh 'git', 'tag', '-m', changelog, "v#{Pacto::VERSION}"
+  sh 'git push origin master'
+  sh "git push origin v#{Pacto::VERSION}"
+  sh 'ls pkg/*.gem | xargs -n 1 gem push'
+end
+
+desc 'Releases to RubyGems and GitHub'
+task :release => [:build, :release_gem, :documentation, :package, :create_release, :upload_docs]
+
+desc 'Preview the changelog'
+task :changelog do
+  changelog
+end
+
+desc 'Create a release on GitHub'
+task :create_release do
+  github.create_release 'thoughtworks/pacto', release_tag, {:name => release_tag, :body => changelog}
+end
+
+desc 'Upload docs to the GitHub release'
+task :upload_docs do
+  Dir['pkg/pacto_docs*'].each do |file|
+    next if File.directory? file
+    puts "Uploading #{file}"
+    github.upload_asset release.url, file
+  end
+end