pacto 0.3.1 → 0.4.0.rc1

data/spec/unit/pacto/investigation_registry_spec.rb

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+describe Pacto::InvestigationRegistry do
+  subject(:registry) { described_class.instance }
+  let(:request_pattern) { Fabricate(:webmock_request_pattern) }
+  let(:request_signature) { Fabricate(:webmock_request_signature) }
+  let(:pacto_response) { Fabricate(:pacto_response) }
+  let(:different_request_signature) { Fabricate(:webmock_request_signature, uri: 'www.thoughtworks.com') }
+  let(:investigation) { Pacto::Investigation.new(request_signature, pacto_response, nil, []) }
+  let(:investigation_for_a_similar_request) { Pacto::Investigation.new(request_signature, pacto_response, nil, []) }
+  let(:investigation_for_a_different_request) { Pacto::Investigation.new(different_request_signature, pacto_response, nil, []) }
+
+  before(:each) do
+    registry.reset!
+  end
+
+  describe 'reset!' do
+    before(:each) do
+      registry.register_investigation(investigation)
+    end
+
+    it 'cleans investigations' do
+      expect { registry.reset! }.to change { registry.validated? request_pattern }.from([investigation]).to(nil)
+    end
+  end
+
+  describe 'registering and reporting registered investigations' do
+    it 'returns registered investigation' do
+      expect(registry.register_investigation investigation).to eq(investigation)
+    end
+
+    it 'reports if investigation is not registered' do
+      expect(registry.validated? request_pattern).to be_falsey
+    end
+
+    it 'registers and returns matching investigations' do
+      registry.register_investigation(investigation)
+      registry.register_investigation(investigation_for_a_similar_request)
+      registry.register_investigation(investigation_for_a_different_request)
+      expect(registry.validated? request_pattern).to eq([investigation, investigation_for_a_similar_request])
+    end
+  end
+
+  describe '.unmatched_investigations' do
+    let(:contract) { Fabricate(:contract) }
+
+    it 'returns investigations with no contract' do
+      investigation_with_citations = Pacto::Investigation.new(different_request_signature, pacto_response, contract, [])
+      registry.register_investigation(investigation)
+      registry.register_investigation(investigation_for_a_similar_request)
+      registry.register_investigation(investigation_for_a_different_request)
+      registry.register_investigation(investigation_with_citations)
+
+      expect(registry.unmatched_investigations).to match_array([investigation, investigation_for_a_similar_request, investigation_for_a_different_request])
+    end
+  end
+
+  describe '.failed_investigations' do
+    let(:contract) { Fabricate(:contract) }
+    let(:citations2) { ['a sample citation'] }
+
+    it 'returns investigations with unsuccessful citations' do
+      allow(contract).to receive(:name).and_return 'test'
+      investigation_with_successful_citations = Pacto::Investigation.new(request_signature, pacto_response, nil, ['error'])
+      investigation_with_unsuccessful_citations = Pacto::Investigation.new(request_signature, pacto_response, nil, %w(error2 error3))
+
+      # Twice because of debug statement...
+      expect(investigation_with_successful_citations).to receive(:successful?).twice.and_return true
+      expect(investigation_with_unsuccessful_citations).to receive(:successful?).twice.and_return false
+
+      registry.register_investigation(investigation)
+      registry.register_investigation(investigation_with_successful_citations)
+      registry.register_investigation(investigation_with_unsuccessful_citations)
+
+      expect(registry.failed_investigations).to match_array([investigation_with_unsuccessful_citations])
+    end
+  end
+end

data/spec/unit/pacto/logger_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   module Logger
     describe SimpleLogger do
@@ -9,27 +10,27 @@ module Pacto
       let(:logger_lib) { ::Logger.new(StringIO.new) }
 
       it 'delegates debug to the logger lib' do
-        logger_lib.should_receive(:debug)
+        expect(logger_lib).to receive(:debug)
         logger.debug
       end
 
       it 'delegates info to the logger lib' do
-        logger_lib.should_receive(:info)
+        expect(logger_lib).to receive(:info)
         logger.info
       end
 
       it 'delegates warn to the logger lib' do
-        logger_lib.should_receive(:warn)
+        expect(logger_lib).to receive(:warn)
         logger.warn
       end
 
       it 'delegates error to the logger lib' do
-        logger_lib.should_receive(:error)
+        expect(logger_lib).to receive(:error)
         logger.error
       end
 
       it 'delegates fatal to the logger lib' do
-        logger_lib.should_receive(:error)
+        expect(logger_lib).to receive(:error)
         logger.error
       end
 

data/spec/unit/pacto/meta_schema_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   describe MetaSchema do
     let(:valid_contract) do
@@ -17,7 +18,7 @@ module Pacto
             "headers": {
               "Content-Type": "application/json"
             },
-            "body": {
+            "schema": {
               "description": "A simple response",
               "type": "object",
               "properties": {
@@ -64,7 +65,7 @@ module Pacto
             "headers": {
               "Content-Type": "application/json"
             },
-            "body": {
+            "schema": {
               "description": "A simple response",
               "required": {},
               "type": "object",
@@ -79,14 +80,14 @@ module Pacto
       EOF
     end
 
-    subject(:schema) { MetaSchema.new }
+    subject(:schema) { described_class.new }
 
     describe 'when validating a contract against the master schema' do
       context 'with a valid contract structure' do
         it 'does not raise any exceptions' do
           expect do
             schema.validate(valid_contract)
-          end.to_not raise_error(Exception)
+          end.to_not raise_error
         end
       end
 

data/spec/unit/pacto/native_contract_factory_spec.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+module Pacto
+  describe NativeContractFactory do
+    let(:host)                 { 'http://localhost' }
+    let(:contract_name)        { 'contract' }
+    let(:contracts_path)       { %w(spec fixtures contracts) }
+    let(:contract_path)        { File.join(contracts_path, "#{contract_name}.json") }
+    subject(:contract_factory) { described_class.new }
+
+    it 'builds a contract given a JSON file path and a host' do
+      contract = contract_factory.build_from_file(contract_path, host)
+      expect(contract).to be_a(Contract)
+    end
+
+    context 'deprecated contracts' do
+      let(:contracts_path)       { %w(spec fixtures deprecated_contracts) }
+      let(:contract_name)        { 'deprecated_contract' }
+      it 'can still be loaded' do
+        contract = contract_factory.build_from_file(contract_path, host)
+        expect(contract).to be_a(Contract)
+      end
+    end
+  end
+end

data/spec/unit/pacto/pacto_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe Pacto do
@@ -11,32 +12,23 @@ describe Pacto do
     $stdout.string.strip
   end
 
-  def mock_validation(errors)
+  def mock_investigation(errors)
     expect(JSON::Validator).to receive(:fully_validate).with(any_args).and_return errors
   end
 
   describe '.validate_contract' do
     context 'valid' do
-      it 'displays a success message and return true' do
-        mock_validation []
-        success = Pacto.validate_contract 'my_contract.json'
-        expect(output).to eq 'Validating my_contract.json'
-        expect(success).to be_true
+      it 'returns true' do
+        mock_investigation []
+        success = described_class.validate_contract 'my_contract.json'
+        expect(success).to be true
       end
     end
 
     context 'invalid' do
-      it 'displays one error messages and return false' do
-        mock_validation ['Error 1']
-        success = Pacto.validate_contract 'my_contract.json'
-        expect(output).to match(/error/)
-        expect(success).to be_false
-      end
-
-      it 'displays several error messages and return false' do
-        mock_validation ['Error 1', 'Error 2']
-        success = Pacto.validate_contract 'my_contract.json'
-        expect(success).to be_false
+      it 'raises an InvalidContract error' do
+        mock_investigation ['Error 1']
+        expect { described_class.validate_contract 'my_contract.json' }.to raise_error(InvalidContract)
       end
     end
   end
@@ -44,19 +36,12 @@ describe Pacto do
   describe 'loading contracts' do
     let(:contracts_path) { 'path/to/dir' }
     let(:host) { 'localhost' }
-    let(:contract1)  { double }
-    let(:contract2)  { double }
-    let(:factory)  { double(:factory) }
-
-    before do
-      allow(Pacto::ContractFactory).to receive(:new).and_return(factory)
-    end
 
     it 'instantiates a contract list' do
-      allow(Pacto::ContractFiles).to receive(:for).with(contracts_path).and_return { %w{file1 file2} }
-      allow(factory).to receive(:build).with(%w{file1 file2}, host).and_return { [contract1, contract2] }
-      expect(Pacto::ContractList).to receive(:new).with([contract1, contract2])
-      Pacto.load_contracts(contracts_path, host)
+      expect(Pacto::ContractSet).to receive(:new) do |contracts|
+        contracts.each { |contract| expect(contract).to be_a_kind_of(Pacto::Contract) }
+      end
+      described_class.load_contracts('spec/fixtures/contracts/', host)
     end
   end
 end

data/spec/unit/pacto/request_clause_spec.rb

@@ -1,39 +1,42 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   describe RequestClause do
     let(:host)           { 'http://localhost' }
     let(:method)         { 'GET' }
     let(:path)           { '/hello_world' }
-    let(:headers)        { {'accept' => 'application/json'} }
-    let(:params)         { {'foo' => 'bar'} }
+    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
-      RequestClause.new(
-        host,
-        'method'  => method,
+      req_hash = {
+        host: host,
+        'http_method'  => method,
         'path'    => path,
         'headers' => headers,
-        'params'  => params,
-        'body'    => body
-      )
+        'params'  => params
+      }
+      # The default test is for missing keys, not explicitly nil keys
+      req_hash.merge!('schema' => body) if body
+      described_class.new(req_hash)
     end
 
     it 'has a host' do
       expect(request.host).to eq host
     end
 
-    describe '#method' do
+    describe '#http_method' do
       it 'delegates to definition' do
-        expect(request.method).to eq :get
+        expect(request.http_method).to eq :get
       end
 
       it 'downcases the method' do
-        expect(request.method).to eq request.method.downcase
+        expect(request.http_method).to eq request.http_method.downcase
       end
 
       it 'returns a symbol' do
-        expect(request.method).to be_kind_of Symbol
+        expect(request.http_method).to be_kind_of Symbol
       end
     end
 
@@ -42,7 +45,7 @@ module Pacto
         expect(request.schema).to eq body
       end
 
-      describe 'when definition does not have body' do
+      describe 'when definition does not have a schema' do
         let(:body) { nil }
 
         it 'returns an empty empty hash' do
@@ -68,43 +71,5 @@ module Pacto
         expect(request.params).to eq params
       end
     end
-
-    describe '#execute' do
-      let(:connection)       { double 'connection' }
-      let(:response)         { double 'response' }
-      let(:adapted_response) { double 'adapted response' }
-
-      before do
-        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 '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
-          request.execute
-          expect(WebMock).to have_requested(:get, 'http://localhost/hello_world?foo=bar').
-            with(:headers => headers)
-        end
-      end
-
-      context 'for a POST request' do
-        let(:method)  { 'POST' }
-
-        it 'makes the request thru the http client' do
-          request.execute
-          expect(WebMock).to have_requested(:post, 'http://localhost/hello_world?foo=bar').
-            with(:headers => headers)
-        end
-      end
-    end
   end
 end

data/spec/unit/pacto/request_pattern_spec.rb

@@ -1,19 +1,20 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 module Pacto
   describe RequestPattern do
-    let(:method) { :get  }
+    let(:http_method) { :get  }
     let(:uri_pattern) { double }
     let(:request_pattern) { double }
-    let(:request) { double(method: method) }
+    let(:request) { double(http_method: http_method) }
 
-    it 'returns a pattern that combines the contracts method and uri_pattern' do
+    it 'returns a pattern that combines the contracts http_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).
+      expect(Pacto::RequestPattern).to receive(:new).
+        with(http_method, uri_pattern).
         and_return(request_pattern)
 
       expect(RequestPattern.for(request)).to eq request_pattern

data/spec/unit/pacto/response_clause_spec.rb

@@ -1,11 +1,8 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   describe ResponseClause do
     let(:body_definition) do
-      {
-        :type => 'object',
-        :required => true,
-        :properties => double('body definition properties')
-      }
+      Fabricate(:schema)
     end
 
     let(:definition) do
@@ -14,11 +11,11 @@ module Pacto
         'headers' => {
           'Content-Type' => 'application/json'
         },
-        'body' => body_definition
+        'schema' => body_definition
       }
     end
 
-    subject(:response) { ResponseClause.new(definition) }
+    subject(:response) { described_class.new(definition) }
 
     it 'has a status' do
       expect(response.status).to eq(200)
@@ -35,20 +32,10 @@ module Pacto
     end
 
     it 'has a default value for the schema' do
-      response = ResponseClause.new(definition.merge('body' => nil))
+      definition.delete 'schema'
+      response = described_class.new(definition)
       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/server/playback_servlet_spec.rb

@@ -1,24 +1,27 @@
-module Pacto::Server
-  describe PlaybackServlet do
-    let(:request) { double }
-    let(:response) { double('response', :status= => '', :[]= => '', :body= => '') }
+# -*- encoding : utf-8 -*-
+module Pacto
+  module DummyServer
+    describe PlaybackServlet do
+      let(:request) { double }
+      let(:response) { double('response', :status= => '', :[]= => '', :body= => '') }
 
-    it 'alters response data with recorded status' do
-      servlet = PlaybackServlet.new status: 200
-      servlet.do_GET(request, response)
-      expect(response).to have_received(:status=).with(200)
-    end
+      it 'alters response data with recorded status' do
+        servlet = PlaybackServlet.new status: 200
+        servlet.do_GET(request, response)
+        expect(response).to have_received(:status=).with(200)
+      end
 
-    it 'alters reponse data with recorded headers' do
-      servlet = PlaybackServlet.new headers: {'Content-Type' => 'application/json'}
-      servlet.do_GET(request, response)
-      expect(response).to have_received(:[]=).with('Content-Type', 'application/json')
-    end
+      it 'alters reponse data with recorded headers' do
+        servlet = PlaybackServlet.new headers: { 'Content-Type' => 'application/json' }
+        servlet.do_GET(request, response)
+        expect(response).to have_received(:[]=).with('Content-Type', 'application/json')
+      end
 
-    it 'alters reponse data with recorded ' do
-      servlet = PlaybackServlet.new body: 'recorded'
-      servlet.do_GET(request, response)
-      expect(response).to have_received(:body=).with('recorded')
+      it 'alters reponse data with recorded ' do
+        servlet = PlaybackServlet.new body: 'recorded'
+        servlet.do_GET(request, response)
+        expect(response).to have_received(:body=).with('recorded')
+      end
     end
   end
 end