pact 1.3.3 → 1.4.0.rc2

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/spec/lib/pact/consumer/request_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples_for_request'
-
-module Pact
-  describe Consumer::Request::Actual do
-    it_behaves_like "a request"
-
-    let(:raw_request) do
-      {
-        'method' => 'get',
-        'path' => '/mallory'
-      }
-    end
-
-    describe "from_hash" do
-      context "when field are not defined" do
-        subject { described_class.from_hash(raw_request) }
-        it "raises an error" do
-          expect{subject}.to raise_error KeyError
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/consumer_contract/active_support_support_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/active_support_support'
-
-module Pact
-  describe ActiveSupportSupport do
-
-    include ActiveSupportSupport
-
-
-    describe "fix_regexp" do
-      let(:regexp) { /moose/ }
-
-      subject { fix_regexp regexp }
-
-      it "returns the original regexp" do
-        expect(subject).to be(regexp)
-      end
-
-      it "fixes the as_json method for Regexp that ActiveSupport tramples beneath its destructive hooves of destruction" do
-        expect(subject.to_json).to eq("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"moose\"}")
-      end
-    end
-
-    describe "fix_all_the_things" do
-      let(:hash) do
-        { 'body' => Pact::Term.new(matcher: /a*b/, generate: 'abba'), array: [/blah/], thing: /alligator/ }
-      end
-
-      subject { fix_all_the_things(hash) }
-
-      it "returns the original object" do
-        expect(subject).to be(hash)
-      end
-
-      it "finds all the Regexp objects in hashes or Pact class attributes and fixes the as_json method" do
-        json = subject.to_json
-        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"a*b\"}")
-        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"blah\"}")
-        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"alligator\"}")
-      end
-    end
-
-    describe "fix_json_formatting" do
-      let(:active_support_affected_pretty_generated_json) { "{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"a*b\"}" }
-      let(:pretty_generated_json) do
-'{
-  "json_class": "Regexp",
-  "o": 0,
-  "s": "a*b"
-}'
-      end
-
-      it "pretty formats the json that has been not pretty formatted because of ActiveSupport" do
-        expect(fix_json_formatting(active_support_affected_pretty_generated_json)).to eq (pretty_generated_json.strip)
-      end
-    end
-  end
-end

data/spec/lib/pact/consumer_contract/consumer_contract_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract'
-
-module Pact
-  describe ConsumerContract do
-    describe "as_json" do
-
-      class MockInteraction
-        def as_json(options ={})
-          {:mock => "interaction"}
-        end
-      end
-
-      before do
-        allow(DateTime).to receive(:now).and_return(DateTime.strptime("2013-08-15T13:27:13+10:00"))
-      end
-
-      let(:service_consumer) { double('ServiceConsumer', :as_json => {:a => 'consumer'}) }
-      let(:service_provider) { double('ServiceProvider', :as_json => {:a => 'provider'}) }
-      let(:pact) { ConsumerContract.new({:interactions => [MockInteraction.new], :consumer => service_consumer, :provider => service_provider }) }
-      let(:expected_as_json) { {:provider=>{:a=>"provider"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pactSpecificationVersion=> "1.0.0" }} }
-
-      it "should return a hash representation of the Pact" do
-        expect(pact.as_json).to eq expected_as_json
-      end
-
-    end
-
-    describe ".from_json" do
-      let(:loaded_pact) { ConsumerContract.from_json(string) }
-      context "when the top level object is a ConsumerContract" do
-        let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
-
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
-        end
-
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
-
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
-
-        it "should have a provider" do
-          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-        end
-      end
-
-      context "with old 'producer' key" do
-        let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
-        end
-
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
-
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
-
-        it "should have a provider" do
-          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-          expect(loaded_pact.provider.name).to eq "an old producer"
-        end
-
-        it "should have a provider_state" do
-          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
-        end
-      end
-    end
-
-    describe "find_interactions" do
-      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
-      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
-      let(:interaction) { double('Pact::Interaction') }
-      subject { ConsumerContract.new(:interactions => [interaction], :consumer => consumer, :provider => provider) }
-      let(:criteria) { {:description => /blah/} }
-      before do
-        expect(interaction).to receive(:matches_criteria?).with(criteria).and_return(matches)
-      end
-      context "by description" do
-        context "when no interactions are found" do
-          let(:matches) { false }
-          it "returns an empty array" do
-            expect(subject.find_interactions(criteria)).to eql []
-          end
-        end
-        context "when interactions are found" do
-          let(:matches) { true }
-          it "returns an array of the matching interactions" do
-            expect(subject.find_interactions(criteria)).to eql [interaction]
-          end
-        end
-      end
-    end
-
-    describe "find_interaction" do
-      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
-      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
-      let(:interaction1) { double('Pact::Interaction') }
-      let(:interaction2) { double('Pact::Interaction') }
-      let(:criteria) { {:description => /blah/} }
-
-      before do
-        expect(interaction1).to receive(:matches_criteria?).with(criteria).and_return(matches1)
-        expect(interaction2).to receive(:matches_criteria?).with(criteria).and_return(matches2)
-      end
-
-      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :provider => provider) }
-      context "by description" do
-        context "when a match is found" do
-          let(:matches1) { true }
-          let(:matches2) { false }
-
-          it "returns the interaction" do
-            expect(subject.find_interaction criteria).to eql interaction1
-          end
-        end
-        context "when more than one match is found" do
-          let(:matches1) { true }
-          let(:matches2) { true }
-          it "raises an error" do
-            expect{ subject.find_interaction(criteria) }.to raise_error "Found more than 1 interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
-          end
-        end
-        context "when a match is not found" do
-          let(:matches1) { false }
-          let(:matches2) { false }
-          it "raises an error" do
-            expect{ subject.find_interaction(criteria) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
-          end
-        end
-      end
-    end
-
-    describe "update_pactfile" do
-      let(:pacts_dir) { Pathname.new("./tmp/pactfiles") }
-      let(:expected_pact_path) { pacts_dir + "test_consumer-test_service.json" }
-      let(:expected_pact_string) do <<-eos
-{
-  "provider": {
-    "name": "test_service"
-  },
-  "consumer": {
-    "name": "test_consumer"
-  },
-  "interactions": [
-    "something"
-  ],
-  "metadata": {
-    "pactSpecificationVersion": "1.0.0"
-  }
-}
-eos
-      end
-      let(:consumer) { Pact::ServiceConsumer.new(:name => 'test_consumer')}
-      let(:provider) { Pact::ServiceProvider.new(:name => 'test_service')}
-      let(:interactions) { [double("interaction", as_json: "something")]}
-      subject { ConsumerContract.new(:consumer => consumer, :provider => provider, :interactions => interactions) }
-      before do
-        allow(Pact.configuration).to receive(:pact_dir).and_return(Pathname.new("./tmp/pactfiles"))
-        FileUtils.rm_rf pacts_dir
-        FileUtils.mkdir_p pacts_dir
-        subject.update_pactfile
-      end
-
-      it "should write to a file specified by the consumer and provider name" do
-        expect(File.exist?(expected_pact_path)).to eq true
-      end
-
-      it "should write the interactions to the file" do
-        expect(File.read(expected_pact_path)).to eql expected_pact_string.strip
-      end
-    end
-  end
-end

data/spec/lib/pact/consumer_contract/headers_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/headers'
-
-module Pact
-  describe Headers do
-
-    describe "initialize" do
-
-      context "with duplicate headers" do
-
-        subject { Headers.new('Content-Type' => 'application/hippo', 'CONTENT-TYPE' => 'application/giraffe') }
-
-        it "raises an error" do
-          expect { subject }.to raise_error DuplicateHeaderError, /Content\-Type.*CONTENT\-TYPE/
-        end
-
-      end
-
-      context "with a symbol as a header name" do
-
-        subject { Headers.new(:'content-type' => 'application/hippo') }
-
-        it "converts the header name to a String" do
-          expect( subject.to_hash ).to eq 'content-type' => 'application/hippo'
-        end
-
-      end
-
-      context "with a nil header name" do
-
-        subject { Headers.new(nil => 'application/hippo') }
-
-        it "raises an error" do
-          expect{ subject }.to raise_error InvalidHeaderNameTypeError
-        end
-
-      end
-
-      context "with a boolean header name" do
-
-        subject { Headers.new(false => 'application/hippo') }
-
-        it "raises an error" do
-          expect{ subject }.to raise_error InvalidHeaderNameTypeError
-        end
-
-      end
-
-    end
-
-    describe "[]" do
-
-      subject { Headers.new 'Content-Type' => 'application/hippo' }
-
-      it "is case insensitive as HTTP headers are case insensitive" do
-        expect(subject['Content-Type']).to eq('application/hippo')
-        expect(subject['CONTENT-TYPE']).to eq('application/hippo')
-        expect(subject['content-type']).to eq('application/hippo')
-      end
-
-    end
-
-    describe "fetch" do
-
-      subject { Headers.new 'Content-Type' => 'application/hippo' }
-
-      it "is case insensitive as HTTP headers are case insensitive" do
-        expect(subject.fetch('Content-Type')).to eq('application/hippo')
-        expect(subject.fetch('CONTENT-TYPE')).to eq('application/hippo')
-        expect(subject.fetch('content-type')).to eq('application/hippo')
-        expect(subject.fetch('Content-Length','1')).to eq('1')
-        expect { subject.fetch('Content-Length')}.to raise_error KeyError
-      end
-
-    end
-
-    describe "key?" do
-
-      subject { Headers.new 'Content-Type' => 'application/hippo' }
-
-      it "is case insensitive as HTTP headers are case insensitive" do
-        expect(subject.key?('CONTENT-TYPE')).to be true
-        expect(subject.key?('CONTENT-LENGTH')).to be false
-      end
-    end
-
-    describe "has_key?" do
-
-      subject { Headers.new 'Content-Type' => 'application/hippo' }
-
-      it "is case insensitive as HTTP headers are case insensitive" do
-        expect(subject.has_key?('CONTENT-TYPE')).to be true
-        expect(subject.has_key?('CONTENT-LENGTH')).to be false
-      end
-    end
-
-    describe "[]=" do
-
-      subject { Headers.new }
-
-      it "does not allow modification" do
-        expect{ subject['Content-Type'] = 'application/hippo' }.to raise_error /frozen/
-      end
-
-    end
-  end
-end