pact 0.1.28 → 1.3.3

data/spec/support/interaction_view_model_with_terms.json

@@ -0,0 +1,50 @@
+{
+    "provider": {
+        "name": "a provider"
+    },
+    "consumer": {
+        "name": "a consumer"
+    },
+    "interactions": [
+        {
+            "description": "an interaction with terms",
+            "request": {
+                "method": "post",
+                "path": "/path",
+                "query": "some=thing",
+                "headers": {
+                    "key": "a header"
+                },
+                "body": {
+                    "term": {
+                      "json_class": "Pact::Term",
+                      "data": {
+                        "generate": "sunny",
+                        "matcher": {
+                          "json_class": "Regexp",
+                          "o": 0,
+                          "s": "sun"
+                        }
+                      }
+                    }
+                }
+            },
+            "response": {
+                "status": 200,
+                "body": {
+                    "term": {
+                      "json_class": "Pact::Term",
+                      "data": {
+                        "generate": "rainy",
+                        "matcher": {
+                          "json_class": "Regexp",
+                          "o": 0,
+                          "s": "rain"
+                        }
+                      }
+                    }
+                }
+            }
+        }
+    ]
+}

data/spec/support/markdown_pact.json

@@ -0,0 +1,48 @@
+{
+  "provider": {
+    "name": "Some Provider"
+  },
+  "consumer": {
+    "name": "Some Consumer"
+  },
+  "interactions": [
+    {
+      "description": "a request for alligators",
+      "provider_state": "alligators exist",
+      "request": {
+        "method": "get",
+        "path": "/alligators"
+      },
+      "response": {
+        "headers" : {"Content-Type": "application/json"},
+        "status" : 200,
+        "body" : {
+          "alligators": [{
+            "name": "Bob",
+            "phoneNumber" : {
+              "json_class": "Pact::Term",
+              "data": {
+                "generate": "12345678",
+                "matcher": {"json_class":"Regexp","o":0,"s":"\\d+"}
+              }
+            }
+          }]
+        }
+      }
+    },{
+      "description": "a request for polar bears",
+      "provider_state": null,
+      "request": {
+        "method": "get",
+        "path": "/polar-bears"
+      },
+      "response": {
+        "headers" : {"Content-Type": "application/json"},
+        "status" : 404,
+        "body" : {
+          "message": "Sorry, due to climate change, the polar bears are currently unavailable."
+        }
+      }
+    }
+  ]
+}

data/spec/support/missing_provider_states_output.txt

@@ -0,0 +1,25 @@
+Pact.provider_states_for "Consumer 1" do
+
+  provider_state "state1" do
+    set_up do
+      # Your set up code goes here
+    end
+  end
+
+  provider_state "state2" do
+    set_up do
+      # Your set up code goes here
+    end
+  end
+
+end
+
+Pact.provider_states_for "Consumer 2" do
+
+  provider_state "state3" do
+    set_up do
+      # Your set up code goes here
+    end
+  end
+
+end

data/spec/support/options.json

@@ -0,0 +1,21 @@
+{
+    "consumer": {
+        "name": "Consumer"
+    },
+    "provider": {
+        "name": "Provider"
+    },
+    "interactions": [
+        {
+            "description": "an OPTIONS request",
+            "request": {
+                "method": "options",
+                "path": "/"
+            },
+            "response": {
+                "status": 200
+            },
+            "provider_state": null
+        }
+    ]
+}

data/spec/support/options_app.rb

@@ -0,0 +1,15 @@
+require 'pact/provider/rspec'
+
+class App
+  def self.call env
+    if env['REQUEST_METHOD'] == 'OPTIONS'
+      [200, {}, []]
+    else
+      [500, {}, ["Expected an options request"]]
+    end
+  end
+end
+
+Pact.service_provider 'Provider' do
+  app { App }
+end

data/spec/support/pact_helper.rb

@@ -0,0 +1,57 @@
+# This is the pact_helper for rake pact:tests
+require 'json'
+require 'pact/provider/rspec'
+require './spec/support/active_support_if_configured'
+
+module Pact
+	module Test
+		class TestApp
+			def call env
+				if env['PATH_INFO'] == '/weather'
+					[200, {'Content-Type' => 'application/json'}, [{message: WEATHER[:current_state], :array => [{"foo"=> "blah"}]}.to_json]]
+				elsif env['PATH_INFO'] == '/sometext'
+					[200, {'Content-Type' => 'text/plain'}, ['some text']]
+				elsif env['PATH_INFO'] == '/content_type_is_important'
+						[200, {'Content-Type' => 'application/json'}, [{message: "A message", note: "This will cause verify to fail if it using the wrong content type differ."}.to_json]]
+				else
+					raise "unexpected path #{env['PATH_INFO']}!!!"
+				end
+			end
+		end
+
+		Pact.configure do | config |
+			config.logger.level = Logger::DEBUG
+			config.diff_formatter = :unix
+		end
+
+		Pact.service_provider "Some Provider" do
+			app { TestApp.new }
+
+			honours_pact_with 'some-test-consumer' do
+				pact_uri './spec/support/test_app_pass.json'
+			end
+		end
+
+		Pact.set_up do
+			WEATHER ||= {}
+		end
+
+		#one with a top level consumer
+		Pact.provider_states_for 'some-test-consumer' do
+
+			provider_state "the weather is sunny" do
+				set_up do
+
+					WEATHER[:current_state] = 'sunny'
+				end
+			end
+		end
+
+		#one without a top level consumer
+		Pact.provider_state "the weather is cloudy" do
+			set_up do
+				WEATHER[:current_state] = 'cloudy'
+			end
+		end
+	end
+end

data/spec/support/shared_examples_for_request.rb

@@ -0,0 +1,94 @@
+shared_examples "a request" do
+
+  describe 'matching' do
+    let(:expected) do
+      Pact::Request::Expected.from_hash(
+        {'method' => 'get', 'path' => 'path', 'query' => /b/}
+        )
+    end
+
+    let(:actual) do
+      Pact::Consumer::Request::Actual.from_hash({'method' => 'get', 'path' => 'path', 'query' => 'blah', 'headers' => {}, 'body' => ''})
+    end
+
+    it "should match" do
+      expect(expected.difference(actual)).to eq({})
+    end
+  end
+
+  describe 'full_path' do
+    context "with empty path" do
+      subject { described_class.from_hash({:path => '', :method => 'get', :query => '', :headers => {}}) }
+      it "returns the full path"do
+        expect(subject.full_path).to eq "/"
+      end
+    end
+    context "with a path" do
+      subject { described_class.from_hash({:path => '/path', :method => 'get', :query => '', :headers => {}}) }
+      it "returns the full path"do
+        expect(subject.full_path).to eq "/path"
+      end
+    end
+    context "with a path and query" do
+      subject { described_class.from_hash({:path => '/path', :method => 'get', :query => "something", :headers => {}}) }
+      it "returns the full path"do
+        expect(subject.full_path).to eq "/path?something"
+      end
+    end
+    context "with a path and a query that is a Term" do
+      subject { described_class.from_hash({:path => '/path', :method => 'get', :headers => {}, :query => Pact::Term.new(generate: 'a', matcher: /a/)}) }
+      it "returns the full path with reified path" do
+        expect(subject.full_path).to eq "/path?a"
+      end
+    end
+  end
+
+  describe "building from a hash" do
+
+    let(:raw_request) do
+      {
+        'method' => 'get',
+        'path' => '/mallory',
+        'query' => 'query',
+        'headers' => {
+          'Content-Type' => 'application/json'
+        },
+        'body' => 'hello mallory'
+      }
+    end
+
+    subject { described_class.from_hash(raw_request) }
+
+    it "extracts the method" do
+      expect(subject.method).to eq 'get'
+    end
+
+    it "extracts the path" do
+      expect(subject.path).to eq '/mallory'
+    end
+
+    it "extracts the body" do
+      expect(subject.body).to eq 'hello mallory'
+    end
+
+    it "extracts the query" do
+      expect(subject.query).to eq 'query'
+    end
+
+    it "blows up if method is absent" do
+      raw_request.delete 'method'
+      expect { described_class.from_hash(raw_request) }.to raise_error
+    end
+
+    it "blows up if path is absent" do
+      raw_request.delete 'path'
+      expect { described_class.from_hash(raw_request) }.to raise_error
+    end
+
+    it "does not blow up if body is missing" do
+      raw_request.delete 'body'
+      expect { described_class.from_hash(raw_request) }.to_not raise_error
+    end
+
+  end
+end

data/spec/support/spec_support.rb

@@ -0,0 +1,20 @@
+require 'pact/rspec'
+
+module Pact
+  module SpecSupport
+
+    extend self
+
+    def remove_ansicolor string
+      string.gsub(/\e\[(\d+)m/, '')
+    end
+
+    Pact::RSpec.with_rspec_2 do
+
+      def instance_double *args
+        double(*args)
+      end
+
+    end
+  end
+end

data/spec/support/stubbing.json

@@ -0,0 +1,22 @@
+{
+    "consumer": {
+        "name": "Consumer"
+    },
+    "provider": {
+        "name": "Provider"
+    },
+    "interactions": [
+        {
+            "description": "a test request",
+            "request": {
+                "method": "get",
+                "path": "/"
+            },
+            "response": {
+                "status": 200,
+                "body": "stubbing works"
+            },
+            "provider_state": "something is stubbed"
+        }
+    ]
+}

data/spec/support/stubbing_using_allow.rb

@@ -0,0 +1,29 @@
+require 'pact/provider/rspec'
+require 'rspec/mocks'
+require './spec/support/active_support_if_configured'
+
+class StubbedThing
+  def self.stub_me
+  end
+end
+
+class App
+  def self.call env
+    [200, {}, [StubbedThing.stub_me]]
+  end
+end
+
+Pact.provider_states_for 'Consumer' do
+  provider_state 'something is stubbed' do
+    set_up do
+      allow(StubbedThing).to receive(:stub_me).and_return("stubbing works")
+    end
+  end
+end
+
+# Include the ExampleMethods module after the provider states are declared
+# to ensure the ordering doesn't matter
+
+Pact.service_provider 'Provider' do
+  app { App }
+end

data/spec/support/term.json

@@ -0,0 +1,48 @@
+{
+    "consumer": {
+        "name": "some-test-consumer"
+    },
+    "provider": {
+        "name": "an unknown provider"
+    },
+    "interactions": [
+        {
+            "description": "a test request",
+            "request": {
+                "method": "get",
+                "path": "/weather",
+                "query": ""
+            },
+            "response": {
+                "status": 200,
+                "headers" : {
+                    "Content-type": {
+                      "json_class": "Pact::Term",
+                      "data": {
+                        "generate": "text/plain",
+                        "matcher": {
+                          "json_class": "Regexp",
+                          "o": 0,
+                          "s": "text"
+                        }
+                      }
+                    }
+                },
+                "body": {
+                    "message" : {
+                      "json_class": "Pact::Term",
+                      "data": {
+                        "generate": "rainy",
+                        "matcher": {
+                          "json_class": "Regexp",
+                          "o": 0,
+                          "s": "rain"
+                        }
+                      }
+                    }
+                }
+            },
+            "provider_state": "the weather is sunny"
+        }
+    ]
+}

data/spec/support/test_app_fail.json

@@ -2,9 +2,12 @@
     "consumer": {
         "name": "an unknown consumer"
     },
+    "provider": {
+        "name": "an unknown provider"
+    },
     "interactions": [
         {
-            "description": "A test request",
+            "description": "a test request",
             "request": {
                 "method": "get",
                 "path": "/weather",
@@ -13,10 +16,46 @@
             "response": {
                 "status": 200,
                 "headers" : {"Content-type": "application/json"},
+                "body": {"message" : "this is not the weather you are looking for", "array": [{"foo": "bar"}], "somethingElse" : {"blah" : {"nested" : "that is missing"} }}
+
+            },
+            "provider_state": "the weather is cloudy"
+        },{
+            "description": "another test request",
+            "request": {
+                "method": "get",
+                "path": "/weather",
+                "query": ""
+            },
+            "response": {
+                "status": 200,
+                "headers" : {
+                    "Content-type": {
+                      "json_class": "Pact::Term",
+                      "data": {
+                        "generate": "application/hal+json",
+                        "matcher": {"json_class":"Regexp","o":0,"s":"hal"}
+                      }
+                    },
+                    "X-Special-Header": "something"
+                },
                 "body": {"message" : "this is not the weather you are looking for"}
 
+            }
+        },{
+            "description": "another test request",
+            "provider_state": "a missing provider state",
+            "request": {
+                "method": "get",
+                "path": "/weather",
+                "query": ""
             },
-            "producer_state": "the weather is cloudy"
+            "response": {
+                "status": 200,
+                "headers" : {"Content-type": "application/json"},
+                "body": {"message" : "this is not the weather you are looking for"}
+
+            }
         }
     ]
 }

data/spec/support/test_app_pass.json

@@ -2,9 +2,12 @@
     "consumer": {
         "name": "some-test-consumer"
     },
+    "provider": {
+        "name": "an unknown provider"
+    },
     "interactions": [
         {
-            "description": "A test request",
+            "description": "a test request",
             "request": {
                 "method": "get",
                 "path": "/weather",
@@ -15,7 +18,21 @@
                 "headers" : {"Content-type": "application/json"},
                 "body": {"message" : "sunny"}
             },
-            "producer_state": "the weather is sunny"
+            "provider_state": "the weather is sunny"
+        },
+        {
+            "description": "a test request for text",
+            "request": {
+                "method": "get",
+                "path": "/sometext",
+                "query": "",
+                "body" : "some request text"
+            },
+            "response": {
+                "status": 200,
+                "headers" : {"Content-type": "text/plain"},
+                "body": "some text"
+            }
         }
     ]
 }

data/spec/support/test_app_with_right_content_type_differ.json

@@ -0,0 +1,23 @@
+{
+    "consumer": {
+        "name": "some-test-consumer"
+    },
+    "provider": {
+        "name": "the test app in the pact_helper file"
+    },
+    "interactions": [
+        {
+            "description": "a test request expecting an application/json response",
+            "request": {
+                "method": "get",
+                "path": "/content_type_is_important",
+                "query": ""
+            },
+            "response": {
+                "status": 200,
+                "headers" : {"Content-type": "application/json"},
+                "body": {"message" : "A message"}
+            }
+        }
+    ]
+}

data/tasks/pact-test.rake

@@ -1,19 +1,109 @@
-require './lib/pact/producer/pact_spec_runner'
+require 'pact/tasks/verification_task'
+require 'open3'
+
+Pact::VerificationTask.new(:stubbing) do | pact |
+	pact.uri './spec/support/stubbing.json', :pact_helper => './spec/support/stubbing_using_allow.rb'
+end
+
+Pact::VerificationTask.new(:options) do | pact |
+	pact.uri './spec/support/options.json', :pact_helper => './spec/support/options_app.rb'
+end
+
+Pact::VerificationTask.new(:pass) do | pact |
+	pact.uri './spec/support/test_app_pass.json'
+end
+
+Pact::VerificationTask.new(:fail) do | pact |
+	pact.uri './spec/support/test_app_pass.json'
+	pact.uri './spec/support/test_app_fail.json'
+end
+
+Pact::VerificationTask.new(:term) do | pact |
+	pact.uri './spec/support/term.json'
+end
+
+RSpec::Core::RakeTask.new('spec:standalone:fail') do | task |
+	task.pattern = FileList["spec/standalone/**/*_fail_test.rb"]
+end
+
+RSpec::Core::RakeTask.new('spec:standalone:pass') do | task |
+	task.pattern = FileList["spec/standalone/**/*_pass_test.rb"]
+end
+
+Pact::VerificationTask.new('test_app:pass') do | pact |
+	pact.uri './spec/support/test_app_pass.json'
+end
+
+Pact::VerificationTask.new('test_app:content_type') do | pact |
+	pact.uri './spec/support/test_app_with_right_content_type_differ.json'
+end
+
+Pact::VerificationTask.new('test_app:fail') do | pact |
+	pact.uri './spec/support/test_app_fail.json', pact_helper: './spec/support/pact_helper.rb'
+end
+
+task :bethtest => ['pact:tests:all','pact:tests:all:with_active_support']
 
 namespace :pact do
 
+	desc "All the verification tests"
+	task "tests:all" do
+		Rake::Task['pact:verify:stubbing'].execute
+		Rake::Task['spec:standalone:pass'].execute
+		Rake::Task['pact:verify'].execute
+		Rake::Task['pact:verify:test_app:pass'].execute
+		Rake::Task['pact:test:fail'].execute
+		Rake::Task['pact:test:pactfile'].execute
+		Rake::Task['pact:verify:test_app:content_type'].execute
+	end
+
+	desc "All the verification tests with active support loaded"
+	task 'tests:all:with_active_support' => :set_active_support_on do
+		Rake::Task['pact:tests:all'].execute
+	end
+
+	desc "Ensure pact file is written"
+	task 'test:pactfile' do
+		pact_path = './spec/pacts/standalone_consumer-standalone_provider.json'
+		FileUtils.rm_rf pact_path
+		Rake::Task['spec:standalone:pass'].execute
+		fail "Did not find expected pact file at #{pact_path}" unless File.exist?(pact_path)
+	end
+
 	desc 'Runs pact tests against a sample application, testing failure and success.'
-	task :tests do
-		puts "Running task pact:tests"
+	task 'test:fail' do
+
+		require 'open3'
+
+		silent = true
 		# Run these specs silently, otherwise expected failures will be written to stdout and look like unexpected failures.
+		#Pact.configuration.output_stream = StringIO.new if silent
 
-		result = Pact::Producer::PactSpecRunner.run([{ uri: './spec/support/test_app_pass.json', support_file: './spec/support/pact_rake_support.rb', consumer: 'some-test-consumer' }], silent: true)
-		fail 'Expected pact to pass' unless (result == 0)
+		expect_to_fail "bundle exec rake pact:verify:test_app:fail", with: [/Could not find one or more provider states/]
+		expect_to_fail "bundle exec rake spec:standalone:fail", with: [/Actual interactions do not match expected interactions/]
+		expect_to_fail "bundle exec rake pact:verify:term", with: [%r{"Content-type" with value /text/}]
+	end
 
-		result = Pact::Producer::PactSpecRunner.run([{ uri: './spec/support/test_app_fail.json', support_file: './spec/support/pact_rake_support.rb' }], silent: true)
-		fail 'Expected pact to fail' if (result == 0)
+	def expect_to_fail command, options = {}
+		success = execute_command command, options
+		fail "Expected '#{command}' to fail" if success
+	end
+
+	def execute_command command, options
+		result = nil
+		Open3.popen3(command) {|stdin, stdout, stderr, wait_thr|
+		  result = wait_thr.value
+		  ensure_patterns_present(command, options, stdout, stderr) if options[:with]
+		}
+		result.success?
+	end
 
-		puts "Task pact:tests completed succesfully."
+	def ensure_patterns_present command, options, stdout, stderr
+		require 'term/ansicolor'
+		output = stdout.read + stderr.read
+		options[:with].each do | pattern |
+			raise (::Term::ANSIColor.red("Could not find #{pattern.inspect} in output of #{command}") + "\n\n#{output}") unless output =~ pattern
+		end
 	end
 
 end