pacto 0.3.0.pre → 0.3.0

data/spec/integration/data/strict_contract.json

@@ -21,8 +21,8 @@
             "items": {
               "type": "string",
               "required": true,
-              "default": "/dev/<%= device_id %>",
-              "pattern": "^/dev/[^/]+(/[^/]+)*$"
+              "default": "/dev/<%= values[:device_id].tap do values[:device_id] = values[:device_id] + 1 end %>",
+              "pattern": "^/dev/[\\d]+$"
             },
             "required": true,
             "uniqueItems": true

data/spec/integration/e2e_spec.rb

@@ -17,23 +17,18 @@ describe 'Pacto' do
     end
 
     it 'verifies the contract against a producer' do
-      contract = Pacto.build_from_file(contract_path, 'http://localhost:8000')
-      expect(contract.validate).to be_empty
+      contract = Pacto.load_contracts(contract_path, 'http://localhost:8000')
+      expect(contract.validate_all.flatten).to eq([])
     end
   end
 
-  context 'Stub generation' do
-    it 'generates a stub to be used by a consumer' do
-      contract = Pacto.build_from_file(contract_path, 'http://dummyprovider.com')
-      Pacto.register_contract(contract, 'my_tag')
-      Pacto.use('my_tag')
-      expect(response.keys).to eq ['message']
-      expect(response['message']).to be_kind_of(String)
-    end
+  context 'Stubbing a collection of contracts' do
+    it 'generates a server that stubs the contract for consumers' do
+      contracts = Pacto.load_contracts(contract_path, 'http://dummyprovider.com')
+      contracts.stub_all
 
-    let :response do
-      raw_response = HTTParty.get('http://dummyprovider.com/hello', headers: {'Accept' => 'application/json' })
-      MultiJson.load(raw_response.body)
+      response = get_json('http://dummyprovider.com/hello')
+      expect(response['message']).to eq 'bar'
     end
   end
 
@@ -41,31 +36,27 @@ describe 'Pacto' do
     it 'stubs multiple services with a single use' do
       Pacto.configure do |c|
         c.strict_matchers = false
-        c.postprocessor = Pacto::ERBProcessor.new
-        c.preprocessor = nil
-        c.register_callback Pacto::Hooks::ERBHook.new
-      end
-
-      # Preprocessor must be off before building!
-      login_contract = Pacto.build_from_file(contract_path, 'http://dummyprovider.com')
-      contract = Pacto.build_from_file(strict_contract_path, 'http://dummyprovider.com')
-      Pacto.configure do |c|
-        c.register_contract login_contract, :default
-        c.register_contract contract, :devices
+        c.register_hook Pacto::Hooks::ERBHook.new
       end
 
-      Pacto.use(:devices, {:device_id => 42})
+      contracts = Pacto.load_contracts 'spec/integration/data/', 'http://dummyprovider.com'
+      contracts.stub_all(:device_id => 42)
 
-      raw_response = HTTParty.get('http://dummyprovider.com/hello', headers: {'Accept' => 'application/json' })
-      login_response = MultiJson.load(raw_response.body)
+      login_response = get_json('http://dummyprovider.com/hello')
       expect(login_response.keys).to eq ['message']
       expect(login_response['message']).to be_kind_of(String)
 
-      devices_response = HTTParty.get('http://dummyprovider.com/strict', headers: {'Accept' => 'application/json' })
-      devices_response = MultiJson.load(devices_response.body)
+      devices_response = get_json('http://dummyprovider.com/strict')
       expect(devices_response['devices']).to have(2).items
-      expect(devices_response['devices'][0]).to eq '/dev/42'
-      # devices_response['devices'][1].should == '/dev/43'
+      expect(devices_response['devices'][0]).to eq('/dev/42')
+      expect(devices_response['devices'][1]).to eq('/dev/43')
+    end
+  end
+
+  def get_json(url)
+    response = Faraday.get(url) do |req|
+      req.headers = {'Accept' => 'application/json' }
     end
+    MultiJson.load(response.body)
   end
 end

data/spec/integration/rspec_spec.rb

@@ -0,0 +1,94 @@
+require 'pacto/rspec'
+
+describe 'pacto/rspec' do
+  let(:contract_path) { 'spec/integration/data/simple_contract.json' }
+  let(:strict_contract_path) { 'spec/integration/data/strict_contract.json' }
+
+  before :all do
+    WebMock.allow_net_connect!
+    @server = Pacto::Server::Dummy.new 8000, '/hello', '{"message": "Hello World!"}'
+    @server.start
+  end
+
+  after :all do
+    @server.terminate
+  end
+
+  def expect_to_raise(message_pattern = nil, &blk)
+    expect { blk.call }.to raise_error(RSpec::Expectations::ExpectationNotMetError, message_pattern)
+  end
+
+  def json_response(url)
+    response = Faraday.get(url) do |req|
+      req.headers = {'Accept' => 'application/json' }
+    end
+    MultiJson.load(response.body)
+  end
+
+  context 'successful validations' do
+    let(:contracts) do
+      Pacto.load_contracts 'spec/integration/data/', 'http://dummyprovider.com'
+    end
+
+    before(:each) do
+      Pacto.configure do |c|
+        c.strict_matchers = false
+        c.register_hook Pacto::Hooks::ERBHook.new
+      end
+
+      contracts.stub_all(:device_id => 42)
+      Pacto.validate!
+
+      Faraday.get('http://dummyprovider.com/hello') do |req|
+        req.headers = {'Accept' => 'application/json' }
+      end
+    end
+
+    it 'performs successful assertions' do
+      # High level assertions
+      expect(Pacto).to_not have_unmatched_requests
+      expect(Pacto).to_not have_failed_validations
+
+      # Increasingly strict assertions
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello')
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with(:headers => {'Accept' => 'application/json'})
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').against_contract(/simple_contract.json/)
+    end
+
+    it 'supports negative assertions' do
+      expect(Pacto).to_not have_validated(:get, 'http://dummyprovider.com/strict')
+      Faraday.get('http://dummyprovider.com/strict') do |req|
+        req.headers = {'Accept' => 'application/json' }
+      end
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict')
+    end
+
+    it 'raises useful error messages' do
+      # High level error messages
+      expect_to_raise(/Expected Pacto to have not matched all requests to a Contract, but all requests were matched/) { expect(Pacto).to have_unmatched_requests }
+      expect_to_raise(/Expected Pacto to have found validation problems, but none were found/) { expect(Pacto).to have_failed_validations }
+
+      unmatched_url = 'http://localhost:8000/404'
+      Faraday.get unmatched_url
+      expect_to_raise(/the following requests were not matched.*#{Regexp.quote unmatched_url}/m) { expect(Pacto).to_not have_unmatched_requests }
+
+      # Expected failures
+      expect_to_raise(/no matching request was received/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with(:headers => {'Accept' => 'text/plain'}) }
+      # No support for with accepting a block
+      # expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with { |req| req.body == "abc" }
+      expect_to_raise(/but it was validated against/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').against_contract(/strict_contract.json/) }
+      expect_to_raise(/but it was validated against/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').against_contract('simple_contract.json') }
+      expect_to_raise(/but no matching request was received/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict') }
+    end
+
+    it 'displays Contract validation problems' do
+      contracts.stub_all(:device_id => 1.5)
+      Faraday.get('http://dummyprovider.com/strict') do |req|
+        req.headers = {'Accept' => 'application/json' }
+      end
+      expect_to_raise(/validation errors were found:/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict') }
+
+      expect_to_raise(/but the following issues were found:/) { expect(Pacto).to_not have_failed_validations }
+    end
+  end
+end

data/spec/integration/templating_spec.rb

@@ -1,36 +1,34 @@
 require 'securerandom'
-require 'pacto/erb_processor'
 
 describe 'Templating' do
   let(:contract_path) { 'spec/integration/data/templating_contract.json' }
+  let(:contracts) {  Pacto.load_contracts(contract_path, 'http://dummyprovider.com') }
 
   let(:key) { SecureRandom.hex }
   let(:auth_token) { SecureRandom.hex }
+
   let :response do
-    contract = Pacto.build_from_file(contract_path, 'http://dummyprovider.com')
-    Pacto.register_contract(contract, 'my_contract')
-    Pacto.use('my_contract', {:key => key, :auth_token => auth_token})
+    contracts.stub_all(:key => key, :auth_token => auth_token)
 
-    raw_response = HTTParty.get('http://dummyprovider.com/echo', headers: {
+    raw_response = Faraday.get('http://dummyprovider.com/echo') do |req|
+      req.headers = {
       'Accept' => 'application/json',
       'Custom-Auth-Token' => "#{auth_token}",
       'X-Message' => "#{key}"
       }
-    )
+    end
     MultiJson.load(raw_response.body)
   end
 
   before :each do
-    Pacto.unregister_all!
+    Pacto.clear!
   end
 
   context 'No processing' do
     it 'does not proccess erb tag' do
       Pacto.configure do |c|
-        c.preprocessor = nil
-        c.postprocessor = nil
         c.strict_matchers = false
-        c.register_callback do |contracts, req, res|
+        c.register_hook do |contracts, req, res|
           res
         end
       end
@@ -43,9 +41,8 @@ describe 'Templating' do
   context 'Post processing' do
     it 'processes erb on each request' do
       Pacto.configure do |c|
-        c.preprocessor = nil
         c.strict_matchers = false
-        c.postprocessor = Pacto::ERBProcessor.new
+        c.register_hook Pacto::Hooks::ERBHook.new
       end
 
       expect(response.keys).to eq ['message']

data/{lib → spec}/pacto/server/dummy.rb

@@ -6,25 +6,25 @@ module Pacto
     class Servlet < WEBrick::HTTPServlet::AbstractServlet
       extend Forwardable
 
-      def initialize server, json
+      def initialize(server, json)
         super(server)
 
-        @doer = PlaybackServlet.new({
+        @doer = PlaybackServlet.new(
           status: 200,
-          headers: {'Content-Type' => 'application/json'},
+          headers: {'Content-Type' => 'application/json', 'Vary' => 'Accept'},
           body: json
-        })
+        )
       end
 
-      def_delegator :@doer, :do_GET
+      def_delegator :@doer, :do_GET # rubocop:disable SymbolName
     end
 
     class Dummy
-      def initialize port, path, response
+      def initialize(port, path, response)
         params = {
           :Port => port,
           :AccessLog => [],
-          :Logger => WEBrick::Log::new('/dev/null', 7)
+          :Logger => WEBrick::Log.new('/dev/null', 7)
         }
         @server = WEBrick::HTTPServer.new params
         @server.mount path, Servlet, response
@@ -32,12 +32,15 @@ module Pacto
 
       def start
         @pid = Thread.new do
-          trap 'INT' do @server.shutdown end
+          trap 'INT' do
+            @server.shutdown
+          end
           @server.start
         end
       end
 
       def terminate
+        @server.shutdown
         @pid.kill
       end
     end

data/{lib → spec}/pacto/server/playback_servlet.rb

@@ -9,7 +9,7 @@ module Pacto
         @body = attributes.fetch(:body, nil)
       end
 
-      def do_GET(request, response)
+      def do_GET(request, response) # rubocop:disable MethodName
         response.status = status
         headers.each do |key, value|
           response[key] = value

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
 require 'coveralls_helper'
+require 'webmock/rspec'
 require 'pacto'
 require 'pacto/server'
 require 'stringio'
+require 'rspec'
 require 'should_not/rspec'
 
 RSpec.configure do |config|

data/spec/unit/hooks/erb_hook_spec.rb

@@ -1,14 +1,14 @@
 describe Pacto::Hooks::ERBHook do
   describe '#process' do
-    let(:req) {
-      OpenStruct.new({:headers => {'User-Agent' => 'abcd'}})
-    }
-    let(:converted_req) {
+    let(:req) do
+      OpenStruct.new(:headers => {'User-Agent' => 'abcd'})
+    end
+    let(:converted_req) do
       {'HEADERS' => {'User-Agent' => 'abcd'}}
-    }
-    let(:res) {
-      OpenStruct.new({:body => 'before'})
-    }
+    end
+    let(:res) do
+      OpenStruct.new(:body => 'before')
+    end
 
     before do
     end
@@ -16,7 +16,7 @@ describe Pacto::Hooks::ERBHook do
     context 'no matching contracts' do
       it 'binds the request' do
         contracts = Set.new
-        mock_erb({ :req => converted_req })
+        mock_erb(:req => converted_req)
         described_class.new.process contracts, req, res
         expect(res.body).to eq('after')
       end
@@ -24,9 +24,9 @@ describe Pacto::Hooks::ERBHook do
 
     context 'one matching contract' do
       it 'binds the request and the contract\'s values' do
-        contract = OpenStruct.new({:values => {:max => 'test'}})
+        contract = OpenStruct.new(:values => {:max => 'test'})
         contracts = Set.new([contract])
-        mock_erb({ :req => converted_req, :max => 'test'})
+        mock_erb(:req => converted_req, :max => 'test')
         described_class.new.process contracts, req, res
         expect(res.body).to eq('after')
       end
@@ -34,10 +34,10 @@ describe Pacto::Hooks::ERBHook do
 
     context 'multiple matching contracts' do
       it 'binds the request and the first contract\'s values' do
-        contract1 = OpenStruct.new({:values => {:max => 'test'}})
-        contract2 = OpenStruct.new({:values => {:mob => 'team'}})
-        res = OpenStruct.new({:body => 'before'})
-        mock_erb({ :req => converted_req, :max => 'test'})
+        contract1 = OpenStruct.new(:values => {:max => 'test'})
+        contract2 = OpenStruct.new(:values => {:mob => 'team'})
+        res = OpenStruct.new(:body => 'before')
+        mock_erb(:req => converted_req, :max => 'test')
         contracts = Set.new([contract1, contract2])
         described_class.new.process contracts, req, res
         expect(res.body).to eq('after')

data/spec/unit/pacto/configuration_spec.rb

@@ -3,16 +3,8 @@ module Pacto
     subject(:configuration) { Configuration.new }
     let(:contracts_path) { 'path_to_contracts' }
 
-    it 'sets the preprocessor by default to ERBProcessor' do
-      expect(configuration.preprocessor).to be_kind_of ERBProcessor
-    end
-
-    it 'sets the postprocessor by default to HashMergeProcessor' do
-      expect(configuration.postprocessor).to be_kind_of HashMergeProcessor
-    end
-
-    it 'sets the stub provider by default to BuiltIn' do
-      expect(configuration.provider).to be_kind_of Stubs::BuiltIn
+    it 'sets the stub provider by default to WebMockAdapter' do
+      expect(configuration.provider).to be_kind_of Stubs::WebMockAdapter
     end
 
     it 'sets strict matchers by default to true' do

data/spec/unit/pacto/contract_factory_spec.rb

@@ -1,20 +1,23 @@
+require 'spec_helper'
+
 module Pacto
   describe ContractFactory do
-    let(:host)               { 'http://localhost' }
-    let(:contract_name)      { 'contract' }
-    let(:contract_path)      { File.join('spec', 'unit', 'data', "#{contract_name}.json") }
-    let(:file_pre_processor) { double('file_pre_processor') }
-    let(:file_content)       { File.read(contract_path) }
+    let(:host)                 { 'http://localhost' }
+    let(:contract_name)        { 'contract' }
+    let(:contracts_path)       { %w(spec unit data) }
+    let(:contract_path)        { File.join(contracts_path, "#{contract_name}.json") }
+    subject(:contract_factory) { ContractFactory.new }
 
-    describe '.build_from_file' do
-      it 'builds a contract given a JSON file path and a host' do
-        file_pre_processor.stub(:process).and_return(file_content)
-        expect(described_class.build_from_file(contract_path, host, file_pre_processor)).to be_a_kind_of(Pacto::Contract)
-      end
+    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
 
-      it 'processes files using File Pre Processor module' do
-        file_pre_processor.should_receive(:process).with(file_content).and_return(file_content)
-        described_class.build_from_file(contract_path, host, file_pre_processor)
+    it 'builds contracts from a list of file paths and a host' do
+      contract_files = [contract_path, contract_path]
+      contracts = contract_factory.build(contract_files, host)
+      contracts.each do |contract|
+        expect(contract).to be_a(Contract)
       end
     end
   end

data/spec/unit/pacto/contract_files_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'fileutils'
+
+module Pacto
+  describe ContractFiles do
+    let(:test_dir) { File.join(File.dirname(__FILE__), 'temp') }
+    let(:contract_1) { Pathname.new(File.join(test_dir, 'contract_1.json')) }
+    let(:contract_2) { Pathname.new(File.join(test_dir, 'contract_2.json')) }
+    let(:contract_3) { Pathname.new(File.join(test_dir, 'nested', 'contract_3.json')) }
+
+    before do
+      Dir.mkdir(test_dir)
+      Dir.chdir(test_dir) do
+        Dir.mkdir('nested')
+        ['contract_1.json', 'contract_2.json', 'not_a_contract', 'nested/contract_3.json'].each do |file|
+          FileUtils.touch file
+        end
+      end
+    end
+
+    after do
+      FileUtils.rm_rf(test_dir)
+    end
+
+    describe 'for a dir' do
+      it 'returns a list with the full path of all json found recursively in that dir' do
+        files = ContractFiles.for(test_dir)
+        expect(files.size).to eq(3)
+        expect(files).to include(contract_1)
+        expect(files).to include(contract_2)
+        expect(files).to include(contract_3)
+      end
+    end
+
+    describe 'for a file' do
+      it 'returns a list containing only that file' do
+        files = ContractFiles.for(File.join(test_dir, 'contract_1.json'))
+        expect(files).to eq [contract_1]
+      end
+    end
+  end
+end