pacto 0.3.0.pre → 0.3.0

data/features/generation/generation.feature

@@ -1,25 +0,0 @@
-@needs_server
-Feature: Contract Generation
-  Scenario: Generating a contract from a partial contract
-    Given a directory named "contracts"
-    Given a file named "requests/my_contract.json" with:
-    """
-        {
-        "request": {
-          "method": "GET",
-          "path": "/hello",
-          "headers": {
-            "Accept": "application/json"
-          },
-          "params": {}
-        },
-        "response": {
-          "status": 200,
-          "body": {
-            "required": true
-          }
-        }
-      }
-    """
-    When I successfully run `bundle exec rake --trace pacto:generate['tmp/aruba/requests','tmp/aruba/contracts','http://localhost:8000']`
-    Then the output should contain "Successfully generated all contracts"

data/lib/pacto/core/contract_repository.rb

@@ -1,44 +0,0 @@
-module Pacto
-  class << self
-
-    def register_contract(contract = nil, *tags)
-      tags << :default if tags.empty?
-      start_count = registered.count
-      tags.uniq.each do |tag|
-        registered[tag] << contract
-      end
-      registered.count - start_count
-    end
-
-    def use(tag, values = {})
-      merged_contracts = registered[:default] + registered[tag]
-
-      raise ArgumentError, "contract \"#{tag}\" not found" if merged_contracts.empty?
-
-      merged_contracts.each do |contract|
-        contract.stub_contract! values
-      end
-      merged_contracts.count
-    end
-
-    def registered
-      @registered ||= Hash.new { |hash, key| hash[key] = Set.new }
-    end
-
-    def unregister_all!
-      registered.clear
-    end
-
-    def contract_for(request_signature)
-      matches = Set.new
-      registered.values.each do |contract_set|
-        contract_set.each do |contract|
-          if contract.matches? request_signature
-            matches.add contract
-          end
-        end
-      end
-      matches
-    end
-  end
-end

data/lib/pacto/hash_merge_processor.rb

@@ -1,14 +0,0 @@
-module Pacto
-  class HashMergeProcessor
-    def process(response_body, values = {})
-      unless values.nil? || values.empty?
-        if response_body.respond_to?(:normalize_keys)
-          response_body = response_body.normalize_keys.deep_merge(values.normalize_keys)
-        else
-          response_body = values
-        end
-      end
-      response_body.to_s
-    end
-  end
-end

data/lib/pacto/request.rb

@@ -1,57 +0,0 @@
-module Pacto
-  class Request
-    attr_reader :host
-
-    def initialize(host, definition)
-      @host = host
-      @definition = definition
-    end
-
-    def method
-      @definition['method'].to_s.downcase.to_sym
-    end
-
-    def path
-      @definition['path']
-    end
-
-    def headers
-      @definition['headers']
-    end
-
-    def params
-      @definition['params']
-    end
-
-    def absolute_uri
-      @host + path
-    end
-
-    def full_uri
-      return absolute_uri if params.empty?
-
-      uri = Addressable::URI.new
-      uri.query_values = params
-
-      absolute_uri + '?' + uri.query
-    end
-
-    def execute
-      response = HTTParty.send(method, @host + path, {
-        httparty_params_key => normalized_params,
-        :headers => headers
-      })
-      ResponseAdapter.new(response)
-    end
-
-    private
-
-    def httparty_params_key
-      method == :get ? :query : :body
-    end
-
-    def normalized_params
-      method == :get ? params : params.to_json
-    end
-  end
-end

data/lib/pacto/response.rb

@@ -1,63 +0,0 @@
-module Pacto
-  class Response
-    attr_reader :status, :headers, :schema
-
-    def initialize(definition)
-      @definition = definition
-      @status = @definition['status']
-      @headers = @definition['headers']
-      @schema = @definition['body']
-    end
-
-    def instantiate
-      OpenStruct.new({
-        'status' => @status,
-        'headers' => @headers,
-        'body' => JSON::Generator.generate(@schema)
-      })
-    end
-
-    def validate(response, opt = {})
-
-      unless opt[:body_only]
-        if @definition['status'] != response.status
-          return ["Invalid status: expected #{@definition['status']} but got #{response.status}"]
-        end
-
-        unless @definition['headers'].normalize_keys.subset_of?(response.headers.normalize_keys)
-          return ["Invalid headers: expected #{@definition['headers'].inspect} to be a subset of #{response.headers.inspect}"]
-        end
-      end
-
-      if @definition['body']
-        if @definition['body']['type'] && @definition['body']['type'] == 'string'
-          validate_as_pure_string response.body
-        else
-          response.respond_to?(:body) ? validate_as_json(response.body) : validate_as_json(response)
-        end
-      else
-        []
-      end
-    end
-
-    private
-
-    def validate_as_pure_string response_body
-      errors = []
-      if @definition['body']['required'] && response_body.nil?
-        errors << 'The response does not contain a body'
-      end
-
-      pattern = @definition['body']['pattern']
-      if pattern && !(response_body =~ Regexp.new(pattern))
-        errors << "The response does not match the pattern #{pattern}"
-      end
-
-      errors
-    end
-
-    def validate_as_json response_body
-      JSON::Validator.fully_validate(@definition['body'], response_body, :version => :draft3)
-    end
-  end
-end

data/lib/pacto/response_adapter.rb

@@ -1,24 +0,0 @@
-module Pacto
-  class ResponseAdapter
-    def initialize(response)
-      @response = response
-    end
-
-    def status
-      @response.code
-    end
-
-    def body
-      @response.body
-    end
-
-    def headers
-      # Normalize headers values according to RFC2616
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
-      normalized_headers = @response.headers.map do |(key, value)|
-        [key, value.join(',')]
-      end
-      Hash[normalized_headers]
-    end
-  end
-end

data/lib/pacto/stubs/built_in.rb

@@ -1,57 +0,0 @@
-module Pacto
-  module Stubs
-    class BuiltIn
-
-      def initialize
-        register_callbacks
-      end
-
-      def stub_request! request, response
-        stub = WebMock.stub_request(request.method, "#{request.host}#{request.path}")
-        stub = stub.with(request_details(request)) if Pacto.configuration.strict_matchers
-        stub.to_return({
-            :status => response.status,
-            :headers => response.headers,
-            :body => format_body(response.body)
-          })
-      end
-
-      def reset!
-        WebMock.reset!
-        WebMock.reset_callbacks
-      end
-
-      private
-
-      def register_callbacks
-        WebMock.after_request do |request_signature, response|
-          contracts = Pacto.contract_for request_signature
-          Pacto.configuration.callback.process contracts, request_signature, response
-        end
-      end
-
-      def format_body(body)
-        if body.is_a?(Hash) || body.is_a?(Array)
-          body.to_json
-        else
-          body
-        end
-      end
-
-      def request_details request
-        details = {}
-        unless request.params.empty?
-          details[webmock_params_key(request)] = request.params
-        end
-        unless request.headers.empty?
-          details[:headers] = request.headers
-        end
-        details
-      end
-
-      def webmock_params_key request
-        request.method == :get ? :query : :body
-      end
-    end
-  end
-end

data/spec/unit/pacto/core/contract_repository_spec.rb

@@ -1,133 +0,0 @@
-describe Pacto do
-  let(:tag) { 'contract_tag' }
-  let(:another_tag) { 'another_tag' }
-  let(:contract) { double('contract') }
-  let(:another_contract) { double('another_contract') }
-
-  after do
-    described_class.unregister_all!
-  end
-
-  describe '.register' do
-    context 'no tag' do
-      it 'registers the contract with the default tag' do
-        described_class.register_contract contract
-        expect(described_class.registered[:default]).to include(contract)
-      end
-    end
-
-    context 'one tag' do
-      it 'registers a contract under a given tag' do
-        described_class.register_contract(contract, tag)
-        expect(described_class.registered[tag]).to include(contract)
-      end
-
-      it 'does not duplicate a contract when it has already been registered with the same tag' do
-        described_class.register_contract(contract, tag)
-        described_class.register_contract(contract, tag)
-        expect(described_class.registered[tag]).to include(contract)
-        expect(described_class.registered[tag]).to have(1).items
-      end
-    end
-
-    context 'multiple tags' do
-      it 'registers a contract using different tags' do
-        described_class.register_contract(contract, tag, another_tag)
-        expect(described_class.registered[tag]).to include(contract)
-        expect(described_class.registered[another_tag]).to include(contract)
-      end
-
-      it 'registers a tag with different contracts ' do
-        described_class.register_contract(contract, tag)
-        described_class.register_contract(another_contract, tag)
-        expect(described_class.registered[tag]).to include(contract, another_contract)
-      end
-
-    end
-
-    context 'with a block' do
-      it 'has a compact syntax for registering multiple contracts' do
-        described_class.configure do |c|
-          c.register_contract 'new_api/create_item_v2', :item, :new
-          c.register_contract 'authentication', :default
-          c.register_contract 'list_items_legacy', :legacy
-          c.register_contract 'get_item_legacy', :legacy
-        end
-        expect(described_class.registered[:new]).to include('new_api/create_item_v2')
-        expect(described_class.registered[:default]).to include('authentication')
-        expect(described_class.registered[:legacy]).to include('list_items_legacy', 'get_item_legacy')
-      end
-    end
-  end
-
-  describe '.use' do
-    before do
-      described_class.register_contract(contract, tag)
-      described_class.register_contract(another_contract, :default)
-    end
-
-    context 'when a contract has been registered' do
-      let(:response_body) { double('response_body') }
-
-      it 'stubs a contract with default values' do
-        contract.should_receive(:stub_contract!)
-        another_contract.should_receive(:stub_contract!)
-        expect(described_class.use(tag)).to eq 2
-      end
-
-      it 'stubs default contract if unused tag' do
-        another_contract.should_receive(:stub_contract!)
-        expect(described_class.use(another_tag)).to eq 1
-      end
-    end
-
-    context 'when contract has not been registered' do
-      it 'raises an argument error' do
-        described_class.unregister_all!
-        expect { described_class.use('unregistered') }.to raise_error ArgumentError
-      end
-    end
-  end
-
-  describe '.unregister_all!' do
-    it 'unregisters all previously registered contracts' do
-      described_class.register_contract(contract, tag)
-      described_class.unregister_all!
-      expect(described_class.registered).to be_empty
-    end
-  end
-
-  describe '.contract_for' do
-    let(:request_signature) { double('request signature') }
-
-    context 'when no contracts are found for a request' do
-      it 'returns an empty list' do
-        expect(described_class.contract_for request_signature).to be_empty
-      end
-    end
-
-    context 'when contracts are found for a request' do
-      let(:contracts_that_match)      { create_contracts 2, true }
-      let(:contracts_that_dont_match) { create_contracts 3, false }
-      let(:all_contracts)             { contracts_that_match + contracts_that_dont_match }
-
-      it 'returns the matching contracts' do
-        register_and_use all_contracts
-        expect(described_class.contract_for request_signature).to eq(contracts_that_match)
-      end
-    end
-  end
-
-  def create_contracts(total, matches)
-    total.times.map do
-      double('contract',
-             :stub_contract! => double('request matcher'),
-             :matches? => matches)
-    end.to_set
-  end
-
-  def register_and_use contracts
-    contracts.each { |contract| described_class.register_contract contract }
-    Pacto.use :default
-  end
-end

data/spec/unit/pacto/hash_merge_processor_spec.rb

@@ -1,20 +0,0 @@
-module Pacto
-  describe HashMergeProcessor do
-    describe '#process' do
-      let(:response_body_string) { 'a simple string' }
-      let(:response_body_hash) {
-        {'a' => 'simple hash'}
-      }
-
-      it 'does not change contract if values is nil' do
-        expect(subject.process(response_body_string, nil)).to eq response_body_string
-      end
-
-      it 'merges response body with values' do
-        merged_body = {'a' => 'simple hash', 'b' => :key}
-        expect(subject.process(response_body_hash, {:b => :key})).to eq merged_body.to_s
-      end
-
-    end
-  end
-end