pact 1.3.3 → 1.4.0

data/spec/lib/pact/reification_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-module Pact
-  describe Reification do
-
-    let(:response_spec) do
-      {
-        woot: /x/,
-        britney: 'britney',
-        nested: { foo: /bar/, baz: 'qux' },
-        my_term: Term.new(generate: 'wiffle', matcher: /^wif/),
-        array: ['first', /second/]
-      }
-    end
-
-    describe "from term" do
-
-      subject { Reification.from_term(response_spec) }
-
-      it "converts regexes into real data" do
-        expect(subject[:woot]).to eql 'x'
-      end
-
-      it "converts terms into real data" do
-        expect(subject[:my_term]).to eql 'wiffle'
-      end
-
-      it "passes strings through" do
-        expect(subject[:britney]).to eql 'britney'
-      end
-
-      it "handles nested hashes" do
-        expect(subject[:nested]).to eql({ foo: 'bar', baz: 'qux' })
-      end
-
-      it "handles arrays" do
-        expect(subject[:array]).to eql ['first', 'second']
-      end
-
-    end
-
-    context "when reifying a Request" do
-
-      let(:request){ Pact::Request::Expected.from_hash(method: 'get', path: '/', body: Pact::Term.new(generate: "sunny", matcher: /sun/))}
-
-      subject { Reification.from_term(request) }
-
-      it "turns it into a hash before reifying it" do
-        expect(subject[:body]).to eq("sunny")
-      end
-
-    end
-
-    context "when SomethingLike" do
-
-      let(:request) { Pact::SomethingLike.new({a: 'String'})}
-
-      subject { Reification.from_term(request)}
-
-      it "returns the contents of the SomethingLike" do
-        expect(subject).to eq({a: 'String'})
-      end
-
-    end
-
-  end
-end

data/spec/lib/pact/shared/dsl_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/dsl'
-require 'support/dsl_spec_support'
-
-module Pact
-  describe DSL do
-
-    class TestDSL
-      extend DSL
-      attr_accessor :thing, :blah, :global, :the_block, :another_block, :finalized
-
-      dsl do
-        def with_thing thing
-          self.thing = thing
-        end
-        def with_blah blah
-          self.blah = blah
-        end
-        def with_global global
-          self.global = global
-        end
-
-        def with_block &the_block
-          self.the_block = the_block
-        end
-
-        def with_another_block &the_block
-          self.another_block = the_block
-        end
-
-      end
-
-      def finalize
-        @finalized = true
-      end
-    end
-
-    describe "build" do
-       before do
-          def my_local_method
-             'LA LA LA'
-          end
-
-          my_local_var = 123
-
-          local_app = "I'm a local app"
-
-          @test = TestDSL.build do
-            with_thing my_local_method
-            with_blah my_local_var
-            with_global global_method
-            with_block do
-              global_app
-            end
-            with_another_block do
-              local_app
-            end
-          end
-       end
-
-       it "supports using a local variable" do
-          expect(@test.blah).to eq 123
-       end
-
-       it "supports using a local method" do
-          expect(@test.thing).to eq 'LA LA LA'
-       end
-
-       it "supports using global methods from other files" do
-         expect(@test.global).to eq "I'm global"
-       end
-
-       it "supports using a local method to provide the app" do
-         expect(@test.another_block.call).to eq("I'm a local app")
-       end
-
-       it "should support using a global method to provide the app but it doesn't" do
-         expect(@test.the_block.call).to eq("I'm a global app")
-       end
-
-       it "calls finalize" do
-        expect(@test.finalized).to be true
-       end
-    end
-  end
-end

data/spec/lib/pact/shared/json_differ_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/json_differ'
-
-module Pact
-  describe JsonDiffer do
-
-    describe ".call" do
-
-      let(:expected) { {'a' => 'b'} }
-
-      subject { JsonDiffer.call(expected, actual) }
-
-      context "when the actual is valid JSON" do
-
-        let(:actual) { {'a' => 'c'} }
-        let(:difference) { {'a' => Pact::Matchers::Difference.new('b', 'c')} }
-
-        context "when the actual does not equal the expected" do
-          it "parses the JSON and returns a diff" do
-            expect(subject).to eq(difference)
-          end
-        end
-
-        context "when the actual equals the expected" do
-          let(:actual) { expected }
-          it "parses the JSON and returns an empty diff" do
-            expect(subject.any?).to be false
-          end
-        end
-
-      end
-
-    end
-
-  end
-end

data/spec/lib/pact/shared/key_not_found_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/key_not_found'
-
-module Pact
-  describe KeyNotFound do
-
-    describe "#as_json" do
-      it "returns a string representation of the object" do
-        expect(subject.as_json).to eq subject.to_s
-      end
-    end
-
-    describe "#to_json" do
-      it "serialises the object to JSON" do
-        expect(subject.to_json).to eq "\"#{subject.to_s}\""
-      end
-    end
-
-  end
-end

data/spec/lib/pact/shared/request_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/request'
-require 'pact/shared/key_not_found'
-
-module Pact
-
-  module Request
-
-    describe Base do
-
-      class TestRequest < Base
-
-        def self.key_not_found
-          Pact::KeyNotFound.new
-        end
-
-      end
-
-      subject { TestRequest.new("get", "/", {some: "things"}, {some: "things"} , "some=things") }
-
-      describe "#to_json" do
-        it "renders the keys in a sensible order" do
-          expect(subject.to_json).to match(/method.*path.*query.*headers.*body/)
-        end
-      end
-
-      describe "#full_path" do
-
-        subject { TestRequest.new("get", "/something", {}, {some: "things"} , query).full_path }
-
-        context "with a query that is a Pact::Term" do
-          let(:query) { Pact::Term.new(generate: "some=things", matcher: /some/) }
-          it "reifies and appends the query" do
-            expect(subject).to eq("/something?some=things")
-          end
-        end
-
-        context "with a query that is a string" do
-          let(:query) { "some=things" }
-          it "appends the query" do
-            expect(subject).to eq("/something?some=things")
-          end
-        end
-
-        context "with an empty query" do
-          let(:query) { "" }
-          it "does include a query" do
-            expect(subject).to eq("/something")
-          end
-        end
-
-        context "with a nil query" do
-          let(:query) { nil }
-          it "does not include a query" do
-            expect(subject).to eq("/something")
-          end
-        end
-      end
-
-      describe "#method_and_path" do
-        context "with an empty path" do
-          subject { TestRequest.new("get", "", {}, {} , "").method_and_path }
-
-          it "includes a slash" do
-            expect(subject).to eq("GET /")
-          end
-        end
-
-        context "with a path" do
-          subject { TestRequest.new("get", "/something", {}, {} , "").method_and_path }
-
-          it "includes the path" do
-            expect(subject).to eq("GET /something")
-          end
-        end
-
-        context "with a query" do
-          subject { TestRequest.new("get", "/something", {}, {} , "test=query").method_and_path }
-
-          it "includes the query" do
-            expect(subject).to eq("GET /something?test=query")
-          end
-        end
-      end
-
-      describe "#content_type" do
-
-        subject { TestRequest.new("get", "/something", headers, {} , "") }
-        context "when there are no expected headers" do
-          let(:headers) { Pact::KeyNotFound.new }
-          it "returns nil" do
-            expect(subject.send(:content_type)).to be nil
-          end
-        end
-        context "when there is no Content-Type header" do
-          let(:headers) { {} }
-          it "returns the content-type" do
-            expect(subject.send(:content_type)).to be nil
-          end
-        end
-        context "when there is a content-type header (" do
-          let(:headers) { {'content-type' => 'blah'} }
-          it "returns the content-type" do
-            expect(subject.send(:content_type)).to eq 'blah'
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/lib/pact/shared/text_differ_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/text_differ'
-
-module Pact
-  describe TextDiffer do
-
-    describe ".call" do
-
-      subject { TextDiffer.call expected, actual }
-
-      let(:expected) { "This is the string you are looking for" }
-
-      context "when the expected and actual are both strings" do
-
-        context "when they equal each other" do
-          let(:actual) { "This is the string you are looking for" }
-
-          it "returns an empty diff" do
-            expect(subject.any?).to be false
-          end
-        end
-
-        context "when they don't equal each other" do
-          let(:actual) { "This is not the string you are looking for" }
-
-          it "returns the diff" do
-            expect(subject).to eq Pact::Matchers::Difference.new(expected, actual)
-          end
-        end
-      end
-
-      context "when the actual is not a String" do
-        let(:actual) { {some: 'hash'} }
-        let(:difference) { Pact::Matchers::Difference.new(expected, actual)}
-        it "returns the diff" do
-          expect(subject)
-        end
-      end
-
-      context "when the expected and actual are both objects" do
-        let(:actual) { {some: 'hash', blah: 'blah'} }
-        let(:expected) { {some: 'hash'} }
-        let(:difference) { Pact::Matchers::Difference.new(expected, actual)}
-
-        it "returns the diff using the JSON matching logic, allowing extra keys. But should it really if the expected Content-Type isn't actually JSON?" do
-          expect(subject)
-        end
-
-        it "potentially should treat both expected and actual as Strings"
-      end
-
-    end
-  end
-end

data/spec/lib/pact/something_like_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-module Pact
-  describe SomethingLike do
-    describe 'json_create' do
-      let(:json) do
-'
-{
-    "json_class": "Pact::SomethingLike",
-    "contents" : { "thing" : "blah" }
-}
-'
-      end
-      subject { SomethingLike.json_create(JSON.parse(json)) }
-      it "creates a SomethingLike object from json" do
-        expect(subject).to eq(SomethingLike.new({"thing" => "blah"}))
-      end
-    end
-  end
-
-end

data/spec/lib/pact/tasks/task_helper_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'pact/tasks/task_helper'
-require 'rake/file_utils'
-
-module Pact
-  describe TaskHelper do
-
-
-    describe ".execute_pact_verify" do
-      let(:ruby_path) { "/path/to/ruby" }
-      let(:pact_uri) { "/pact/uri" }
-      let(:default_pact_helper_path) { "/pact/helper/path.rb" }
-
-      before do
-        stub_const("FileUtils::RUBY", ruby_path)
-        allow(Pact::Provider::PactHelperLocater).to receive(:pact_helper_path).and_return(default_pact_helper_path)
-      end
-
-      context "with no pact_helper or pact URI" do
-        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{default_pact_helper_path}" }
-        it "executes the command" do
-          expect(TaskHelper).to receive(:execute_cmd).with(command)
-          TaskHelper.execute_pact_verify
-        end
-      end
-
-      context "with a pact URI" do
-        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{default_pact_helper_path} -p #{pact_uri}" }
-        it "executes the command" do
-          expect(TaskHelper).to receive(:execute_cmd).with(command)
-          TaskHelper.execute_pact_verify(pact_uri)
-        end
-      end
-
-      context "with a pact URI and a pact_helper" do
-        let(:custom_pact_helper_path) { '/custom/pact_helper.rb' }
-        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{custom_pact_helper_path} -p #{pact_uri}" }
-        it "executes the command" do
-          expect(TaskHelper).to receive(:execute_cmd).with(command)
-          TaskHelper.execute_pact_verify(pact_uri, custom_pact_helper_path)
-        end
-      end
-
-      context "with a pact_helper with no .rb on the end" do
-        let(:custom_pact_helper_path) { '/custom/pact_helper' }
-        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{custom_pact_helper_path}.rb -p #{pact_uri}" }
-        it "executes the command" do
-          expect(TaskHelper).to receive(:execute_cmd).with(command)
-          TaskHelper.execute_pact_verify(pact_uri, custom_pact_helper_path)
-        end
-      end
-
-      context "with a pact URI and a nil pact_helper" do
-        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{default_pact_helper_path} -p #{pact_uri}" }
-        it "executes the command" do
-          expect(TaskHelper).to receive(:execute_cmd).with(command)
-          TaskHelper.execute_pact_verify(pact_uri, nil)
-        end
-      end
-
-      context "with rspec_opts" do
-        it "includes the rspec_opts as SPEC_OPTS in the command" do
-          expect(TaskHelper).to receive(:execute_cmd) do | command |
-            expect(command).to start_with("SPEC_OPTS=--reporter\\ SomeReporter #{ruby_path}")
-          end
-          TaskHelper.execute_pact_verify(pact_uri, nil, "--reporter SomeReporter")
-        end
-      end
-
-    end
-
-
-  end
-end

data/spec/lib/pact/tasks/verification_task_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'pact/tasks/verification_task'
-
-module Pact
-  describe VerificationTask do
-    before :all do
-      @pact_helper = '/custom/path/pact_helper  .rb'
-      @pact_uri = 'http://example.org/pact.json'
-      @task_name = 'pact:verify:pact_rake_spec'
-      @task_name_with_explict_pact_helper = 'pact:verify:pact_rake_spec_with_explict_pact_helper'
-      @consumer = 'some-consumer'
-      @criteria = {:description => /wiffle/}
-
-      VerificationTask.new(:pact_rake_spec_with_explict_pact_helper) do | pact |
-        pact.uri @pact_uri, pact_helper: @pact_helper
-      end
-
-      VerificationTask.new(:pact_rake_spec) do | pact |
-        pact.uri @pact_uri
-      end
-    end
-
-    before do
-      allow(Pact::TaskHelper).to receive(:execute_pact_verify).and_return(0)
-    end
-
-    let(:exit_code) {0}
-
-
-    describe '.initialize' do
-      context 'with an explict pact_helper' do
-        it 'creates the tasks' do
-          expect(Rake::Task.tasks).to include_task @task_name
-        end
-      end
-      context 'with no explict pact_helper' do
-        it 'creates the tasks' do
-          expect(Rake::Task.tasks).to include_task @task_name_with_explict_pact_helper
-        end
-      end
-    end
-
-    describe 'execute' do
-
-      context "with no explicit pact_helper" do
-        it 'verifies the pacts using the TaskHelper' do
-          expect(Pact::TaskHelper).to receive(:execute_pact_verify).with(@pact_uri, nil, nil)
-          Rake::Task[@task_name].execute
-        end
-      end
-
-      context "with an explict pact_helper" do
-        let(:verification_config) { [ uri: @pact_uri, pact_helper: @pact_helper] }
-        it 'verifies the pacts using the TaskHelper' do
-          expect(Pact::TaskHelper).to receive(:execute_pact_verify).with(@pact_uri, @pact_helper, nil)
-          Rake::Task[@task_name_with_explict_pact_helper].execute
-        end
-      end
-
-      context 'when all specs pass' do
-
-        it 'does not raise an exception' do
-          Rake::Task[@task_name].execute
-        end
-      end
-
-    end
-  end
-end
-
-RSpec::Matchers.define :include_task do |expected|
-  match do |actual|
-    actual.any? { |task| task.name == expected }
-  end
-end

data/spec/lib/pact/term_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-module Pact
-  describe Term do
-
-    describe 'initialize' do
-      let(:matcher) { /e/ }
-      let(:generate) { 'apple'}
-      subject { Term.new(generate: generate, matcher: matcher) }
-      context "when a matcher and generate are specified" do
-        context "when the matcher matches the generated value" do
-          it 'does not raise an exception' do
-            subject
-          end
-        end
-
-        context "when the matcher does not match the generated value" do
-          let(:generate) { 'banana' }
-          it 'raises an exception' do
-            expect { subject }.to raise_error /does not match/
-          end
-        end
-      end
-      context 'when a matcher is not specified' do
-        let(:matcher) { nil }
-        it 'raises an exception' do
-          expect { subject }.to raise_error /Please specify a matcher/
-        end
-      end
-      context 'when a generate is not specified' do
-        let(:generate) { nil }
-        it 'raises an exception' do
-          expect { subject }.to raise_error /Please specify a value/
-        end
-      end
-    end
-
-    describe "equality" do
-      context "when the matcher and generate attrs are the same" do
-        let(:this) { Term.new(generate: 'A', matcher: /A/) }
-        let(:that) { Term.new(generate: 'A', matcher: /A/) }
-
-        it "is equal" do
-          expect(this).to eq that
-        end
-      end
-
-      context "when the generate attrs are different" do
-        let(:this) { Term.new(generate: 'A', matcher: /.*/) }
-        let(:that) { Term.new(generate: 'B', matcher: /.*/) }
-
-        it "is not equal" do
-          expect(this).to_not eq that
-        end
-      end
-
-      context "when the matcher attrs are different" do
-        let(:this) { Term.new(matcher: /A/, generate: 'AB') }
-        let(:that) { Term.new(matcher: /B/, generate: 'AB') }
-
-        it "is not equal" do
-          expect(this).to_not eq that
-        end
-      end
-    end
-
-    describe 'empty?' do
-
-      subject { Term.new(generate: 'some', matcher: /some/) }
-
-      it 'should return false' do
-        expect(subject).to_not be_empty
-      end
-
-    end
-
-    describe 'unpack_regexps' do
-      let(:term) { Term.new(generate: 'some', matcher: /s/) }
-      let(:body) { [{a: [{b: term}], c:term, d: 1, e: 'blah'}] }
-      let(:expected) { [{:a=>[{:b=>/s/}], :c=>/s/, :d=>1, :e=>"blah"}] }
-
-      it "returns a structure with the Pact::Terms replaced by their regexps" do
-        expect(Term.unpack_regexps(body)).to eq expected
-      end
-
-    end
-
-  end
-end

data/spec/pact_specification/compliance-1.0.0.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/request'
-require 'pact/consumer_contract/request'
-
-PACT_SPEC_DIR = "../pact-specification/testcases"
-REQUEST_TEST_CASE_FOLDERS = Dir.glob("#{PACT_SPEC_DIR}/request/**")
-REQUEST_TEST_CASE_FILES = Dir.glob("#{PACT_SPEC_DIR}/request/**/*.json")
-
-TEST_DESCRIPTIONS = {true => "matches", false => "does not match"}
-
-describe "Pact gem complicance with Pact Specification 1.0.0" do
-
-  directories = Dir.glob("#{PACT_SPEC_DIR}/*")
-
-  directories.each do | dir_name |
-
-    describe File.basename(dir_name) do
-
-      sub_directories = Dir.glob("#{dir_name}/*")
-
-      sub_directories.each do | sub_dir_name |
-
-        context File.basename(sub_dir_name) do
-          testcases = Dir.glob("#{sub_dir_name}/**/*.json")
-
-          testcases.each do | file_name |
-
-            context File.basename(file_name).chomp(".json") do
-
-              file_content = JSON.parse(File.read(file_name))
-              expected = Pact::Request::Expected.from_hash(file_content["expected"])
-              actual = Pact::Consumer::Request::Actual.from_hash(file_content["actual"])
-              expected_result = file_content.fetch("match")
-              comment = file_content["comment"]
-
-              it "#{TEST_DESCRIPTIONS[expected_result]} - #{comment}" do
-                expect(expected.matches?(actual)).to eq expected_result
-              end
-
-            end
-
-          end
-        end
-      end
-    end
-  end
-end