pact 1.3.3 → 1.4.0.rc2

data/spec/lib/pact/matchers/regexp_difference_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/regexp_difference'
-
-module Pact
-  module Matchers
-    describe RegexpDifference do
-
-      context "when a regexp is expected" do
-
-        subject { RegexpDifference.new(/ap/, 'pear').as_json }
-
-        it "indicates that the actual was indended 'to match'" do
-          expect(subject).to eq({:EXPECTED_TO_MATCH => "/ap/", :ACTUAL => "pear"})
-        end
-
-      end
-
-    end
-  end
-end

data/spec/lib/pact/matchers/type_difference_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/type_difference'
-
-module Pact
-  module Matchers
-    describe TypeDifference do
-
-      describe "#as_json" do
-
-        let(:expected) { ExpectedType.new("Fred") }
-        let(:actual) { ActualType.new(1) }
-        subject { TypeDifference.new expected, actual }
-
-        context "when the actual is a KeyNotFound" do
-          let(:actual) { KeyNotFound.new }
-          let(:expected_hash) { {:EXPECTED_TYPE => "String", :ACTUAL => actual.to_s } }
-
-          it "use the key ACTUAL" do
-            expect(subject.as_json).to eq(expected_hash)
-          end
-        end
-
-        context "when the actual is an ActualType" do
-          let(:expected_hash) { {:EXPECTED_TYPE => "String", :ACTUAL_TYPE => "Fixnum" } }
-
-          it "uses the key ACTUAL_TYPE" do
-             expect(subject.as_json).to eq(expected_hash)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact/matchers/unexpected_index_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unexpected_index'
-
-module Pact
-  describe UnexpectedIndex 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/matchers/unexpected_key_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unexpected_key'
-
-module Pact
-  describe UnexpectedKey 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/matchers/unix_diff_formatter_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unix_diff_formatter'
-require 'pact/matchers/expected_type'
-require 'pact/matchers/actual_type'
-
-module Pact
-  module Matchers
-    describe UnixDiffFormatter do
-
-      describe ".call" do
-
-        let(:key_lines_count) { 4 }
-        let(:colour) { false }
-        subject { UnixDiffFormatter.call(diff, {colour: colour}) }
-
-        let(:line_count) { subject.split("\n").size }
-
-        context "when colour = false" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          it "does not include colour" do
-            expect(subject).to_not include("[0m")
-          end
-        end
-
-        context "when colour = true" do
-          let(:colour) { true }
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          it "uses colour" do
-            expect(subject).to include("[0m")
-          end
-        end
-
-        context "with class based matching" do
-          let(:diff) { {thing: TypeDifference.new(ExpectedType.new("fred"), ActualType.new(1))}}
-          let(:output) { <<-EOF
- {
--  "thing": String
-+  "thing": Fixnum
- }
-EOF
-          }
-
-          it "displays nicely" do
-            expect(remove_ansicolor subject).to include output
-          end
-        end
-
-        context "with an incorrect value in a hash" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-
-          it "displays '+' next to the unexpected value, and '-' next to the missing one" do
-            expect(subject).to match /alligator/
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\+.*Joe/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
-          end
-
-        end
-
-        context "with an incorrect value in an array" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new({name: 'Mary'}, "Joe"), NoDiffIndicator.new] }
-
-          it "displays '+' next to the incorrect values and '-' next to the missing ones" do
-            expect(subject).to match /no difference here!/
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\+.*Joe/
-            expect(subject).to match /no.*Mary.*Joe.*no/m
-          end
-
-          it "doesn't display the no difference indicator as a change" do
-            expect(subject).to match(/^\s+no difference here!,$/)
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
-          end
-
-        end
-
-        context "with a regular expression that was not matched" do
-          let(:regexp) { %r{http://.*/thing/1234} }
-          let(:diff) { {thing: RegexpDifference.new(regexp, "pear")} }
-
-          it "displays the regular expression" do
-            expect(subject).to include(regexp.inspect)
-            expect(subject).to include(regexp.inspect)
-            expect(subject).to match /\-.*thing/
-            expect(subject).to match /\+.*pear/
-          end
-
-          it "does not put quotes around the regular expression" do
-            expect(subject).to match /\/$/
-            expect(subject).to match /: \//
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 5 + key_lines_count
-          end
-
-        end
-
-        context "with a missing key" do
-
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, KeyNotFound.new )}} }
-
-          it "it displays '-' next to the missing key and its value" do
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-            expect(subject).to match /\-.*alligator/
-            expect(subject).to match /\-.*name/
-            expect(subject).to match /\-.*Mary/
-          end
-
-          it "does not display the missing key in the actual output" do
-            expect(subject).to_not match /\+.*alligator/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-        end
-
-        context "with an unexpected key" do
-          let(:diff) { {thing: {alligator: Difference.new(UnexpectedKey.new, {name: 'Mary'} )}} }
-
-          it "displays '+' next to the unexpected key and its value" do
-            expect(subject).to match /\+.*name/
-            expect(subject).to match /\+.*Mary/
-            expect(subject).to match /\+.*alligator/
-            expect(subject).to match /\+.*}/
-            expect(subject).to match /\+.*{/
-          end
-
-          it "does not display the unexpected key in the expected output" do
-            expect(subject).to_not match /\-.*alligator/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with a missing index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new({name: 'Mary'}, IndexNotFound.new)] }
-
-          it "displays '-' next to the missing items" do
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-          end
-
-          it "does not display IndexNotFound" do
-            expect(subject).to_not match /#{IndexNotFound.new.to_s}/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with an unexpected index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'})] }
-
-          it "displays '+' next to the unexpected item" do
-            expect(subject).to match /\+.*{/
-            expect(subject).to match /\+.*}/
-            expect(subject).to match /\+.*name/
-            expect(subject).to match /\+.*Mary/
-          end
-
-          xit "doesn't mark the 'no difference' as a change" do
-            expect(subject).to match /#{NoDiffIndicator.new.to_s},/
-            expect(subject).to_not match /\-.*#{NoDiffIndicator.new.to_s}/
-            expect(subject).to_not match /\+.*#{NoDiffIndicator.new.to_s}/
-          end
-
-          it "does not display the UnexpectedIndex" do
-            expect(subject).to_not match UnexpectedIndex.new.to_s
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with 2 unexpected indexes" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'}), Difference.new(UnexpectedIndex.new, {name: 'Joe'})] }
-
-          it "displays '+' next to the unexpected item" do
-            expect(subject).to match /\+.*Mary/
-            expect(subject).to match /\+.*Joe/
-          end
-
-          it "does not display the UnexpectedIndex" do
-            expect(subject).to_not match UnexpectedIndex.new.to_s
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 11 + key_lines_count
-          end
-
-        end
-
-      end
-
-    end
-  end
-end

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