pact-support 1.9.0 → 1.15.0

data/spec/support/markdown_pact.json

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

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

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

data/spec/support/ruby_version_helpers.rb

@@ -1,23 +0,0 @@
-module RubyVersionHelpers
-  RUBY_2_4 = Gem::Version.new('2.4.0')
-  CURRENT_RUBY = Gem::Version.new(RUBY_VERSION)
-
-  def numeric_type
-    if CURRENT_RUBY < RUBY_2_4
-      Fixnum
-    else
-      Integer
-    end
-  end
-  module_function :numeric_type
-
-  def a_numeric
-    type = numeric_type
-    if type == Integer
-      "an #{type}"
-    else
-      "a #{type}"
-    end
-  end
-  module_function :a_numeric
-end

data/spec/support/shared_examples_for_request.rb

@@ -1,132 +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
-    context "with a path and a query that is a QueryString" 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
-    context "with a path and a query that is a QueryHash" do
-      subject { described_class.from_hash({:path => '/path', :method => 'get', :headers => {}, :query =>  {param: 'hello', extra: 'world'}}) }
-      it "returns the full path with reified path" do
-        expect(subject.full_path).to eq "/path?param=hello&extra=world"
-      end
-    end
-    context "with a path and a query that is a QueryHash with an embeded Term" do
-      subject { described_class.from_hash({:path => '/path', :method => 'get', :headers => {},
-                                           :query =>   {param: 'hello', extra: Pact::Term.new(generate: "wonderworld", matcher: /\w+world/)}}) }
-      it "returns the full path with reified path" do
-        expect(subject.full_path).to eq "/path?param=hello&extra=wonderworld"
-      end
-    end
-    context "with a path and a query that has multiple terms" do
-      subject { described_class.from_hash({:path => '/path', :method => 'get', :headers => {},
-                                           :query =>   {param: 'hello', simple: 'hi', double: [ 'hello', 'world'], last: 'gone'}}) }
-      it "returns the full path with reified path" do
-        expect(subject.full_path).to eq "/path?param=hello&simple=hi&double=hello&double=world&last=gone"
-      end
-    end
-    context "with a path and a query that has multiple terms including terms" do
-      subject { described_class.from_hash({:path => '/path', :method => 'get', :headers => {},
-                                           :query => {param: 'hello', simple: 'hi', double: [ 'hello', Pact::Term.new(generate: "wonderworld", matcher: /\w+world/)], last: 'gone'}}) }
-      it "returns the full path with reified path" do
-        expect(subject.full_path).to eq "/path?param=hello&simple=hi&double=hello&double=wonderworld&last=gone"
-      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 string query" do
-      expect(subject.query).to eq Pact::QueryString.new('query')
-    end
-
-    it "extracts the hash query" do
-      raw_request['query']= {param: 'hello', extra: 'world'}
-      expect(subject.query).to eq Pact::QueryHash.new( {param: 'hello', extra: 'world'})
-    end
-
-    it "blows up if method is absent" do
-      raw_request.delete 'method'
-      expect { described_class.from_hash(raw_request) }.to raise_error(KeyError)
-    end
-
-    it "blows up if path is absent" do
-      raw_request.delete 'path'
-      expect { described_class.from_hash(raw_request) }.to raise_error(KeyError)
-    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,29 +0,0 @@
-require 'pact/rspec'
-
-module Pact
-  module SpecSupport
-
-    extend self
-
-    def load_fixture name
-      File.read(File.join("./spec/fixtures", name))
-    end
-
-    def load_json_fixture name
-      require 'json'
-      JSON.parse(load_fixture(name))
-    end
-
-    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/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"
-            }
-        }
-    ]
-}