pact 1.3.3 → 1.4.0

data/spec/support/shared_examples_for_request.rb

@@ -1,94 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,22 +0,0 @@
-{
-    "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

@@ -1,29 +0,0 @@
-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

@@ -1,48 +0,0 @@
-{
-    "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

@@ -1,61 +0,0 @@
-{
-    "consumer": {
-        "name": "an unknown consumer"
-    },
-    "provider": {
-        "name": "an unknown provider"
-    },
-    "interactions": [
-        {
-            "description": "a test request",
-            "request": {
-                "method": "get",
-                "path": "/weather",
-                "query": ""
-            },
-            "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": ""
-            },
-            "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

@@ -1,38 +0,0 @@
-{
-    "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": "application/json"},
-                "body": {"message" : "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

@@ -1,23 +0,0 @@
-{
-    "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,109 +0,0 @@
-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 '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
-
-		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
-
-	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
-
-	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

data/tasks/spec.rake

@@ -1,8 +0,0 @@
-task :set_active_support_on do
-  ENV["LOAD_ACTIVE_SUPPORT"] = 'true'
-end
-
-desc "This is to ensure that the gem still works even when active support JSON is loaded."
-task :spec_with_active_support => [:set_active_support_on] do
-  Rake::Task['spec'].execute
-end