pact 1.3.3 → 1.4.0

data/lib/pact/shared/null_expectation.rb

@@ -1,31 +0,0 @@
-module Pact
-  class NullExpectation
-    def to_s
-      "<No expectation>"
-    end
-
-    def ==(other_object)
-     other_object.is_a? NullExpectation
-    end
-
-    def ===(other_object)
-     other_object.is_a? NullExpectation
-    end
-
-    def eql?(other_object)
-      self == other_object
-    end
-
-    def hash
-      2934820948209428748274238642672
-    end
-
-    def empty?
-      true
-    end
-
-    def nil?
-      true
-    end
-  end
-end

data/lib/pact/shared/request.rb

@@ -1,80 +0,0 @@
-require 'pact/matchers'
-require 'pact/symbolize_keys'
-require 'pact/consumer_contract/headers'
-
-module Pact
-
-  module Request
-
-    class Base
-      include Pact::Matchers
-      include Pact::SymbolizeKeys
-      extend Pact::Matchers
-
-      attr_reader :method, :path, :headers, :body, :query, :options
-
-      def initialize(method, path, headers, body, query)
-        @method = method.to_s
-        @path = path.chomp('/')
-        @headers = Hash === headers ? Headers.new(headers) : headers # Could be a NullExpectation - TODO make this more elegant
-        @body = body
-        @query = query
-      end
-
-      def to_json(options = {})
-        as_json.to_json(options)
-      end
-
-      def as_json options = {}
-        to_hash
-      end
-
-      def to_hash
-        hash = {
-          method: method,
-          path: path,
-        }
-
-        hash.merge!(query: query) unless query.is_a? self.class.key_not_found.class
-        hash.merge!(headers: headers) unless headers.is_a? self.class.key_not_found.class
-        hash.merge!(body: body) unless body.is_a? self.class.key_not_found.class
-        hash
-      end
-
-      def method_and_path
-        "#{method.upcase} #{full_path}"
-      end
-
-      def full_path
-        display_path + display_query
-      end
-
-      def content_type
-        return nil if headers.is_a? self.class.key_not_found.class
-        headers['Content-Type']
-      end
-
-      protected
-
-      def self.key_not_found
-        raise NotImplementedError
-      end
-
-      def to_hash_without_body
-        keep_keys = [:method, :path, :headers, :query]
-        as_json.reject{ |key, value| !keep_keys.include? key }.tap do | hash |
-          hash[:method] = method.upcase
-        end
-      end
-
-      def display_path
-        path.empty? ? "/" : path
-      end
-
-      def display_query
-        (query.nil? || query.empty?) ? '' : "?#{Pact::Reification.from_term(query)}"
-      end
-
-    end
-  end
-end

data/lib/pact/shared/text_differ.rb

@@ -1,14 +0,0 @@
-require 'pact/matchers/matchers'
-require 'pact/matchers/difference'
-
-module Pact
-  class TextDiffer
-
-    extend Matchers
-
-    def self.call expected, actual, options = {}
-      diff expected, actual, options
-    end
-
-  end
-end

data/lib/pact/something_like.rb

@@ -1,49 +0,0 @@
-require 'pact/symbolize_keys'
-module Pact
-
-  # Specifies that the actual object should be considered a match if
-  # it includes the same keys, and the values of the keys are of the same class.
-
-  class SomethingLike
-    include SymbolizeKeys
-
-    attr_reader :contents
-
-    def initialize contents
-      @contents = contents
-    end
-
-    def to_hash
-      {
-        :json_class => self.class.name,
-        :contents => contents
-      }
-    end
-
-    def as_json
-      to_hash
-    end
-
-    def to_json opts = {}
-      as_json.to_json opts
-    end
-
-    def self.json_create hash
-      new(symbolize_keys(hash)[:contents])
-    end
-
-    def eq other
-      self == other
-    end
-
-    def == other
-      other.is_a?(SomethingLike) && other.contents == self.contents
-    end
-
-    def generate
-      contents
-    end
-  end
-end
-
-

data/lib/pact/symbolize_keys.rb

@@ -1,12 +0,0 @@
-module Pact
-  module SymbolizeKeys
-
-    def self.included(base)
-      base.extend(self)
-    end
-
-    def symbolize_keys hash
-      hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
-    end
-  end
-end

data/lib/pact/term.rb

@@ -1,85 +0,0 @@
-require 'pact/shared/active_support_support'
-require 'json/add/regexp'
-
-module Pact
-  class Term
-
-    include Pact::ActiveSupportSupport
-
-    attr_reader :generate, :matcher
-
-    def self.json_create(obj)
-      new(generate: obj['data']['generate'], matcher: obj['data']['matcher'])
-    end
-
-    def self.unpack_regexps source
-      case source
-      when Pact::Term then source.matcher
-      when Array then unpack_regexps_from_array source
-      when Hash then unpack_regexps_from_hash source
-      else
-        source
-      end
-    end
-
-    def initialize(attributes = {})
-      @generate = attributes[:generate]
-      @matcher = attributes[:matcher]
-      raise "Please specify a matcher for the Term" unless @matcher != nil
-      raise "Please specify a value to generate for the Term" unless @generate != nil
-      raise "Value to generate \"#{@generate}\" does not match regular expression #{@matcher}" unless @generate =~ @matcher
-    end
-
-    def to_hash
-      { json_class: self.class.name, data: { generate: generate, matcher: fix_regexp(matcher)} }
-    end
-
-    def as_json(options = {})
-      to_hash
-    end
-
-
-    def to_json(options = {})
-      as_json.to_json(options)
-    end
-
-    def match(literal)
-      literal.respond_to?(:to_s) ? matcher.match(literal.to_s) : nil
-    end
-
-    def ==(other)
-      return false unless other.respond_to?(:generate) && other.respond_to?(:matcher)
-      generate == other.generate && matcher == other.matcher
-    end
-
-    def to_s
-      "Pact::Term matcher: #{matcher.inspect}" + (generate.nil? ? "" : " generate: \"#{generate}\"")
-    end
-
-    def diff_with_actual(actual)
-      match(actual) ? nil : {
-        expected: self,
-        actual: actual
-      }
-    end
-
-    def empty?
-      false
-    end
-
-    private
-
-    def self.unpack_regexps_from_array source
-      source.each_with_object([]) do | item, destination |
-        destination << unpack_regexps(item)
-      end
-    end
-
-    def self.unpack_regexps_from_hash source
-      source.keys.each_with_object({}) do | key, destination |
-        destination[key] = unpack_regexps source[key]
-      end
-    end
-
-  end
-end

data/scratchpad.rb

@@ -1,52 +0,0 @@
-Ideas for expectation DSL
-
-Unfortunately RSpec has already stolen the method "example".
-Could use:
-eg
-ex
-
-my_provider.
-   given("a thing exists").
-      upon_receiving("a request for a thing").with({:method => 'get', :path => '/thing'})
-         will_respond_with({:body => {
-            name: ex("Fred"),
-            age: eg 29,
-            mobile: eg("0415 134 234", /\d{4} \d{3} \d{3}/),
-            dob: eg("1983-02-28", match: /\d\d\d\d-\d\d-\d\d/),
-            driver_licence_number: eg(12345678, size: 8),
-            children: eg([{name: 'Mary'}])
-         }})
-
-eg([ {name: 'Mary'} ]) should match any array where every element has a name String
-eg([ {name: example('Mary', size: 4) } ]) should match any array where every element has a 4 letter name
-
-eg("Fred") could return Pact::Term.new(:matcher => /.+/, :generate => 'Fred')
-eg(29) could return Pact::Term.new(:matcher => /\d+/, :generate => 29)
-
-Need a way to specify a literal empty hash, rather than a hash that matches anything as {} currently does.
-
-{:something => literal({}) }
-{:something => actual({}) }
-{:something => empty_hash }
-
-# Slightly unintuitive behaviour: {} matches any hash, but [] only matches an empty array (or does now we've changed the code). Should [] match any array? How do we then specify an empty array?
-
-{:something => literal([]) }
-{:something => actual([]) }
-{:something => empty_array }
-
-
-Pact.build do
-   {
-      status: 200,
-      headers: exactly({
-
-         }),
-      body: including({
-         age: literal('12'),
-         phoneNumber: example("0415 134 234", /\d{4} \d{3} \d{3}/),
-         favouriteColors:
-      })
-   }
-
-end

data/spec/features/consumption_spec.rb

@@ -1,114 +0,0 @@
-require 'net/http'
-require 'pact/consumer'
-require 'pact/consumer/rspec'
-load 'pact/consumer/world.rb'
-
-describe "A service consumer side of a pact", :pact => true  do
-
-  before do
-    Pact.clear_configuration
-    Pact.clear_consumer_world
-  end
-
-  describe "blah" do
-    describe "thing" do
-
-  it "goes a little something like this" do
-
-    Pact.service_consumer "Consumer" do
-      has_pact_with "Alice Service" do
-        mock_service :alice_service do
-          verify true
-          port 1234
-        end
-      end
-
-      has_pact_with "Bob" do
-        mock_service :bob_service do
-          verify false
-          port 4321
-        end
-      end
-    end
-
-    alice_service.
-      upon_receiving("a retrieve Mallory request").with({
-      method: :get,
-      path: '/mallory'
-    }).
-      will_respond_with({
-      status: 200,
-      headers: { 'Content-Type' => 'text/html' },
-      body: Pact::Term.new(matcher: /Mallory/, generate: 'That is some good Mallory.')
-    })
-
-    bob_service.
-      upon_receiving('a create donut request').with({
-      method: :post,
-      path: '/donuts',
-      body: {
-        "name" => Pact::Term.new(matcher: /Bob/, generate: 'Bob')
-      },
-      headers: {'Accept' => 'text/plain', "Content-Type" => 'application/json'}
-    }).
-      will_respond_with({
-      status: 201,
-      body: 'Donut created.'
-    })
-    bob_service.
-      upon_receiving('a delete charlie request').with({
-      method: :delete,
-      path: '/charlie'
-    }).
-      will_respond_with({
-      status: 200,
-      body: /deleted/
-    })
-    bob_service.
-      upon_receiving('an update alligators request').with({
-        method: :put,
-        path: '/alligators',
-        body: [{"name" => 'Roger' }]
-    }).
-      will_respond_with({
-        status: 200,
-        body: [{"name" => "Roger", "age" => 20}]
-    })
-
-
-    alice_response = Net::HTTP.get_response(URI('http://localhost:1234/mallory'))
-
-    expect(alice_response.code).to eql '200'
-    expect(alice_response['Content-Type']).to eql 'text/html'
-    expect(alice_response.body).to eql 'That is some good Mallory.'
-
-    uri = URI('http://localhost:4321/donuts')
-    post_req = Net::HTTP::Post.new(uri.path)
-    post_req['Accept'] = "text/plain"
-    post_req['Content-Type'] = "application/json"
-    post_req.body = {"name" => "Bobby"}.to_json
-    bob_post_response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-      http.request post_req
-    end
-
-    expect(bob_post_response.code).to eql '201'
-    expect(bob_post_response.body).to eql 'Donut created.'
-
-    uri = URI('http://localhost:4321/alligators')
-    post_req = Net::HTTP::Put.new(uri.path)
-    post_req['Content-Type'] = "application/json"
-    post_req.body = [{"name" => "Roger"}].to_json
-    bob_post_response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-      http.request post_req
-    end
-
-    expect(bob_post_response.code).to eql '200'
-    expect(bob_post_response.body).to eql([{"name" => "Roger", "age" => 20}].to_json)
-
-    expect{ bob_service.verify('goes a little something like this') }.to raise_error /do not match/
-  end
-
-end
-end
-end
-

data/spec/features/production_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/rspec'
-require 'pact/consumer_contract'
-require 'features/provider_states/zebras'
-
-
-module Pact::Provider
-
-  describe "A service production side of a pact" do
-
-    class ServiceUnderTest
-
-      def call(env)
-        case env['PATH_INFO']
-        when '/donuts'
-          [201, {'Content-Type' => 'application/json'}, { message: "Donut created." }.to_json]
-        when '/charlie'
-          [200, {'Content-Type' => 'application/json'}, { message: "Your charlie has been deleted" }.to_json]
-        end
-      end
-
-    end
-
-    class ServiceUnderTestWithFixture
-
-      def find_zebra_names
-        #simulate loading data from a database
-        data = JSON.load(File.read('tmp/a_mock_database.json'))
-        data.collect{ | zebra | zebra['name'] }
-      end
-
-      def call(env)
-        case env['PATH_INFO']
-        when "/zebra_names"
-            [200, {'Content-Type' => 'application/json'}, { names: find_zebra_names }.to_json]
-        end
-      end
-
-    end
-
-    pact = Pact::ConsumerContract.from_json <<-EOS
-    {
-        "consumer" : { "name" : "a consumer"},
-        "provider" : { "name" : "a provider"},
-        "interactions" : [
-            {
-                "description": "donut creation request",
-                "request": {
-                    "method": "post",
-                    "path": "/donuts"
-                },
-                "response": {
-                    "body": {"message": "Donut created."},
-                    "status": 201
-                }
-            },
-            {
-                "description": "charlie deletion request",
-                "request": {
-                    "method": "delete",
-                    "path": "/charlie"
-                },
-                "response": {
-                    "body": {
-                      "message": {
-                        "json_class": "Regexp",
-                        "o": 0,
-                        "s": "deleted"
-                      }
-                    },
-                    "status": 200
-                }
-            }
-        ]
-    }
-    EOS
-
-    before :all do
-        Pact.service_provider "My Provider" do
-            app { ServiceUnderTest.new }
-        end
-    end
-
-    honour_consumer_contract pact
-
-  end
-
-  describe "with a provider_state" do
-
-    context "that is a symbol" do
-        consumer_contract = Pact::ConsumerContract.from_json <<-EOS
-        {
-            "consumer" : { "name" : "the-wild-beast-store"},
-            "provider" : { "name" : "provider"},
-            "interactions" : [
-                {
-                    "description": "donut creation request",
-                    "request": {
-                        "method": "delete",
-                        "path": "/zebra_names"
-                    },
-                    "response": {
-                        "body": {"names": ["Jason", "Sarah"]},
-                        "status": 200
-                    },
-                    "provider_state" : "the_zebras_are_here"
-                }
-            ]
-        }
-        EOS
-
-        before :all do
-            Pact.service_provider "My Provider" do
-                app { ServiceUnderTestWithFixture.new }
-            end
-        end
-
-
-        honour_consumer_contract consumer_contract
-    end
-
-    context "that is a string" do
-        consumer_contract = Pact::ConsumerContract.from_json <<-EOS
-        {
-            "consumer" : { "name" : "some consumer"},
-            "provider" : { "name" : "provider"},
-            "interactions" : [
-                {
-                    "description": "donut creation request",
-                    "request": {
-                        "method": "post",
-                        "path": "/zebra_names"
-                    },
-                    "response": {
-                        "body": {"names": ["Mark", "Gertrude"]},
-                        "status": 200
-                    },
-                    "provider_state" : "some other zebras are here"
-                }
-            ]
-        }
-        EOS
-
-        before :all do
-            Pact.service_provider "ServiceUnderTestWithFixture" do
-                app { ServiceUnderTestWithFixture.new }
-            end
-        end
-
-
-        honour_consumer_contract consumer_contract
-    end
-
-  end
-end

data/spec/features/provider_states/zebras.rb

@@ -1,28 +0,0 @@
-require 'json'
-require 'fileutils'
-
-Pact.provider_states_for 'the-wild-beast-store' do
-
-  provider_state :the_zebras_are_here do
-    set_up do
-      FileUtils.mkdir_p 'tmp'
-      some_data = [{'name' => 'Jason'},{'name' => 'Sarah'}]
-      File.open("tmp/a_mock_database.json", "w") { |file| file << some_data.to_json }
-    end
-
-    tear_down do
-      FileUtils.rm_rf("tmp/a_mock_database.json")
-    end
-  end
-end
-
-Pact.provider_state "some other zebras are here" do
-  set_up do
-    some_data = [{'name' => 'Mark'},{'name' => 'Gertrude'}]
-    File.open("tmp/a_mock_database.json", "w") { |file| file << some_data.to_json }
-  end
-
-  tear_down do
-    FileUtils.rm_rf("tmp/a_mock_database.json")
-  end
-end