pact-support 1.11.0 → 1.12.0

data/spec/lib/pact/matching_rules_spec.rb

@@ -1,82 +0,0 @@
-require 'pact/matching_rules'
-
-module Pact
-  module MatchingRules
-    describe ".merge" do
-      before do
-        allow(V3::Merge).to receive(:call)
-        allow(Merge).to receive(:call)
-        allow(Pact.configuration.error_stream).to receive(:puts)
-      end
-
-      let(:object) { double('object') }
-      let(:rules) { double('rules') }
-      let(:options) { { pact_specification_version: Pact::SpecificationVersion.new(pact_specification_version) } }
-
-      subject { MatchingRules.merge(object, rules, options)}
-
-      context "when the pact_specification_version is nil" do
-        let(:options) { { pact_specification_version: nil } }
-
-        it "calls Merge" do
-          expect(Merge).to receive(:call)
-          subject
-        end
-      end
-
-      context "when the pact_specification_version starts with '1.'" do
-        let(:pact_specification_version) { "1.0" }
-
-        it "calls Merge" do
-          expect(Merge).to receive(:call)
-          subject
-        end
-      end
-
-      context "when the pact_specification_version is with '1'" do
-        let(:pact_specification_version) { "1" }
-
-        it "calls Merge" do
-          expect(Merge).to receive(:call)
-          subject
-        end
-      end
-
-      context "when the pact_specification_version starts with '2.'" do
-        let(:pact_specification_version) { "2.0" }
-
-        it "calls Merge" do
-          expect(Merge).to receive(:call)
-          subject
-        end
-      end
-
-      context "when the pact_specification_version starts with '3.'" do
-        let(:pact_specification_version) { "3.0" }
-
-        it "calls V3::Merge" do
-          expect(V3::Merge).to receive(:call)
-          subject
-        end
-      end
-
-      context "when the pact_specification_version starts with '4.'" do
-        let(:pact_specification_version) { "4.0" }
-
-        it "calls V3::Merge" do
-          expect(V3::Merge).to receive(:call)
-          subject
-        end
-      end
-
-      context "when the pact_specification_version is with '11'" do
-        let(:pact_specification_version) { "11" }
-
-        it "calls V3::Merge" do
-          expect(V3::Merge).to receive(:call)
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/reification_spec.rb

@@ -1,172 +0,0 @@
-require 'spec_helper'
-require 'pact/reification'
-require 'pact/consumer_contract/request'
-
-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
-
-    context "when nested SomethingLike" do
-
-      let(:request) {
-        Pact::SomethingLike.new(
-          {
-            a: 'String',
-            b: Pact::SomethingLike.new(
-              c: 'NestedString'
-            )
-          }
-        )
-      }
-
-      subject { Reification.from_term(request)}
-
-      it "returns the contents of the SomethingLike" do
-        expect(subject).to eq({a: 'String', b: { c: 'NestedString' }})
-      end
-
-    end
-
-    context "when ArrayLike" do
-
-      let(:request) { Pact::ArrayLike.new({a: 'String'}, {min: 3})}
-
-      subject { Reification.from_term(request)}
-
-      it "returns the contents of the ArrayLike" do
-        expect(subject).to eq([{a: 'String'}, {a: 'String'}, {a: 'String'}])
-      end
-
-    end
-
-    context "when Query" do
-
-      let(:query) { QueryString.new(Pact::Term.new(generate: "param=thing", matcher: /param=.*/)) }
-
-      subject { Reification.from_term(query)}
-
-      it "returns the contents of the generate" do
-        expect(subject).to eq("param=thing")
-      end
-
-    end
-
-    context "when Hash Query" do
-
-      subject { Reification.from_term(query)}
-
-      let(:query) { QueryHash.new( {param: 'hello', extra: 'world'})}
-
-      it "returns the hash in the natural order" do
-        expect(subject).to eq("param=hello&extra=world")
-      end
-    end
-
-    context "when Hash Query with UTF-8 string" do
-      subject { Reification.from_term(query)}
-
-      let(:query) { QueryHash.new(param: 'ILove', extra: '寿司') }
-
-      it "returns the hash with escaping UTF-8 string" do
-        expect(subject).to eq("param=ILove&extra=%E5%AF%BF%E5%8F%B8")
-      end
-    end
-
-    context "when Hash Query with embeded terms" do
-      subject { Reification.from_term(query)}
-
-      let(:query) { QueryHash.new( {param: 'hello', extra: Pact::Term.new(generate: "wonderworld", matcher: /\w+world/)})}
-
-      it "returns the hash in the natural order, and fills in Terms appropriately" do
-        expect(subject).to eq("param=hello&extra=wonderworld")
-      end
-    end
-
-    context "when Hash Query with Arrays and multiple params with the same name" do
-      subject { Reification.from_term(query)}
-
-      let(:query) { QueryHash.new( {param: 'hello', double: [Pact::Term.new(generate: "wonder", matcher: /\w+/), 'world'], simple: 'bye'})}
-
-      it "returns the hash in the natural order, and fills in Terms appropriately" do
-        expect(subject).to eq("param=hello&double=wonder&double=world&simple=bye")
-      end
-    end
-
-    context "when Hash Query with an ArrayLike" do
-      subject { Reification.from_term(query)}
-
-      let(:query) { QueryHash.new(param: Pact.each_like("1", min: 2)) }
-
-      it "turns the hash into a string with the right number of params" do
-        expect(subject).to eq("param=1&param=1")
-      end
-    end
-
-    context "with a StringWithMatchingRules" do
-      subject { Reification.from_term(StringWithMatchingRules.new("foo", Pact::SpecificationVersion.new("3"), {}))}
-
-      it "returns a String" do
-        expect(subject.class).to be String
-      end
-    end
-  end
-end

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

@@ -1,100 +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
-
-      def initialize
-        @thing = 0
-      end
-
-      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
-      context "with block" 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
-
-      context "without block" do
-        let(:test) { TestDSL.build }
-
-        it "initializes an instance" do
-          expect(test.thing).to eq(0)
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/form_differ'
-require 'pact/matchers/difference'
-require 'pact/matchers/unix_diff_formatter'
-
-module Pact
-  describe FormDiffer do
-
-    describe ".call" do
-
-      let(:expected) { "param1=foo&param2=bar&param2=foobar" }
-      let(:actual)   { "param1=wiffle&param2=foobar&param2=bar" }
-
-      let(:difference) do
-        {
-          'param1' => [Pact::Matchers::Difference.new("foo", "wiffle")],
-          'param2' => [Pact::Matchers::Difference.new("bar", "foobar"), Pact::Matchers::Difference.new("foobar", "bar")]
-        }
-      end
-
-      subject { FormDiffer.call(expected, actual) }
-
-      context "when there is a diff" do
-        it "returns the diff" do
-          expect(subject).to eq difference
-        end
-      end
-
-      context "when the expected is a matching Hash" do
-        let(:expected) do
-          {
-            param1: "wiffle",
-            param2: ["foobar", "bar"]
-          }
-        end
-
-        it "returns an empty diff" do
-          expect(subject).to be_empty
-        end
-      end
-
-      context "when the expected is a matching Hash with a Pact::Term" do
-        let(:expected) do
-          {
-            param1: "wiffle",
-            param2: [Pact::Term.new(generate: 'foobar', matcher: /bar/), "bar"]
-          }
-        end
-
-        it "returns an empty diff" do
-          expect(subject).to be_empty
-        end
-      end
-
-      context "when the expected is a Hash that doesn't match the actual" do
-        let(:expected) do
-          {
-            param1: "woffle",
-            param2: ["foobar", "bar"]
-          }
-        end
-
-        it "returns the diff" do
-          expect(subject).to_not be_empty
-        end
-      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