pact 1.0.9 → 1.0.10

data/lib/pact/pact_task_helper.rb

@@ -1,21 +0,0 @@
-module PactTaskHelper
-  def failure_message
-    redify(
-      "\n* * * * * * * * * * * * * * * * * * *\n" +
-      "Provider did not honour pact file.\nSee\n * #{Pact.configuration.log_path}\n * #{Pact.configuration.tmp_dir}\nfor logs and pact files." +
-      "\n* * * * * * * * * * * * * * * * * * *\n\n"
-    )
-  end
-
-  def redify string
-    "\e[31m#{string}\e[m"
-  end
-
-  def handle_verification_failure
-    exit_status = yield
-    if exit_status != 0
-      $stderr.puts failure_message
-      fail
-    end
-  end
-end

data/lib/pact/provider/dsl.rb

@@ -1,115 +0,0 @@
-require_relative 'pact_verification'
-
-module Pact
-
-   module Provider
-      module DSL
-
-         #TODO: Move this into a module, out of configuration
-         module Configuration
-            def provider= provider
-               @provider = provider
-            end
-
-            def provider
-              if defined? @provider
-                @provider
-              else
-                raise "Please configure your provider. See the Provider section in the README for examples."
-              end
-            end
-
-            def add_pact_verification verification
-              pact_verifications << verification
-            end
-            def pact_verifications
-              @pact_verifications ||= []
-            end
-         end
-
-         Pact::Configuration.send(:include, Configuration)
-
-         def service_provider name, &block
-            service_provider = ServiceProviderDSL.new(name, &block).create_service_provider
-            Pact.configuration.provider = service_provider
-            service_provider
-         end
-
-        class ServiceProviderConfig
-           attr_accessor :name
-
-           def initialize name, &app_block
-             @name = name
-             @app_block = app_block
-           end
-
-           def app
-             @app_block.call
-           end
-         end
-
-         class VerificationDSL
-            def initialize consumer_name, options = {}, &block
-              @consumer_name = consumer_name
-              @ref = options.fetch(:ref, :head)
-              @pact_uri = nil
-              instance_eval(&block)
-            end
-
-            def pact_uri pact_uri, options = {}
-              @pact_uri = pact_uri
-            end
-
-            def task task
-              @task = task
-            end
-
-            def create_verification
-              validate
-              Pact::Provider::PactVerification.new(@consumer_name, @pact_uri, @ref)
-            end
-
-            private
-
-            def validate
-              raise "Please provide a pact_uri for the verification" unless @pact_uri
-            end
-
-         end
-
-         class ServiceProviderDSL
-
-           def initialize name, &block
-             @name = name
-             @app = nil
-             instance_eval(&block)
-           end
-
-           def validate
-             raise "Please provide a name for the Provider" unless @name && !@name.strip.empty?
-             raise "Please configure an app for the Provider" unless @app_block
-           end
-
-           def name name
-             @name = name
-           end
-
-           def app &block
-             @app_block = block
-           end
-
-           def honours_pact_with consumer_name, options = {}, &app_block
-              verification = VerificationDSL.new(consumer_name, options, &app_block).create_verification
-              Pact.configuration.add_pact_verification verification
-           end
-
-           def create_service_provider
-             validate
-             ServiceProviderConfig.new(@name, &@app_block)
-           end
-         end
-      end
-   end
-end
-
-Pact.send(:extend, Pact::Provider::DSL)

data/lib/pact/request.rb

@@ -1,167 +0,0 @@
-require 'pact/matchers'
-require 'pact/reification'
-
-module Pact
-
-  module Request
-
-    class NullExpectation
-      def to_s
-        "<No expectation>"
-      end
-
-      def ==(other_object)
-       other_object.is_a? NullExpectation
-      end
-
-      def ===(other_object)
-       other_object.is_a? NullExpectation
-      end
-
-      def eql?(other_object)
-        self == other_object
-      end
-
-      def hash
-        2934820948209428748274238642672
-      end
-
-      def empty?
-        true
-      end
-
-      def nil?
-        true
-      end
-    end
-
-    class Base
-      include Pact::Matchers
-      extend Pact::Matchers
-
-      NULL_EXPECTATION = NullExpectation.new
-
-      attr_reader :method, :path, :headers, :body, :query, :options
-
-      def self.from_hash(hash)
-        sym_hash = symbolize_keys hash
-        method = sym_hash.fetch(:method)
-        path = sym_hash.fetch(:path)
-        query = sym_hash.fetch(:query, NULL_EXPECTATION)
-        headers = sym_hash.fetch(:headers, NULL_EXPECTATION)
-        body = sym_hash.fetch(:body, NULL_EXPECTATION)
-        new(method, path, headers, body, query)
-      end
-
-      def self.symbolize_keys hash
-        hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
-      end
-
-      def initialize(method, path, headers, body, query)
-        @method = method.to_s
-        @path = path.chomp('/')
-        @headers = headers
-        @body = body
-        @query = query
-      end
-
-      def to_json(options = {})
-        as_json.to_json(options)
-      end
-
-      def as_json
-        base_json = {
-          method: method,
-          path: path,
-        }
-
-        base_json.merge!(body: body) unless body.is_a? NullExpectation
-        base_json.merge!(headers: headers) unless headers.is_a? NullExpectation
-        base_json.merge!(query: query) unless query.is_a? NullExpectation
-        base_json
-      end
-
-      def as_json_without_body
-        keep_keys = [:method, :path, :headers, :query]
-        as_json.reject{ |key, value| !keep_keys.include? key }
-      end
-
-      def short_description
-        "#{method} #{full_path}"
-      end
-
-      def full_path
-        fp = ''
-        if path.empty?
-          fp << "/"
-        else
-          fp << path
-        end
-        if query && !query.empty?
-          fp << ("?" + query)
-        end
-        fp
-      end
-
-    end
-
-    class Expected < Base
-
-      DEFAULT_OPTIONS = {:allow_unexpected_keys => false}.freeze
-      attr_accessor :description
-      attr_accessor :options
-
-      def self.from_hash(hash)
-        request = super
-        request.description = hash.fetch(:description, nil)
-        request.options = symbolize_keys(hash).fetch(:options, {})
-        request
-      end
-
-      def initialize(method, path, headers, body, query, options = {})
-        super(method, path, headers, body, query)
-        @options = options
-      end
-
-      def match(actual_request)
-        difference(actual_request).empty?
-      end
-
-      def matches_route? actual_request
-        diff({:method => method, :path => path}, {:method => actual_request.method, :path => actual_request.path}).empty?
-      end
-
-      def difference(actual_request)
-        request_diff = diff(as_json_without_body, actual_request.as_json_without_body)
-        unless body.is_a? NullExpectation
-          request_diff.merge(body_difference(actual_request.body))
-        else
-          request_diff
-        end
-      end
-
-      def body_difference(actual_body)
-        diff({:body => body}, {body: actual_body}, allow_unexpected_keys: runtime_options[:allow_unexpected_keys_in_body])
-      end
-
-      def as_json_with_options
-        as_json.merge( options.empty? ? {} : { options: options} )
-      end
-
-      def generated_body
-        Pact::Reification.from_term(body)
-      end
-
-      # Don't want to put the default options in the pact json just yet, so calculating these at run time, rather than assigning
-      # the result to @options
-      def runtime_options
-        DEFAULT_OPTIONS.merge(self.class.symbolize_keys(options))
-      end
-
-    end
-
-    class Actual < Base
-    end
-
-  end
-end

data/spec/lib/pact/consumer/mock_service_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/mock_service'
-
-module Pact::Consumer
-
-  describe InteractionList do
-    shared_context "unexpected requests and missed interactions" do
-      let(:expected_call) { {request: 'blah'} }
-      let(:unexpected_call) { Pact::Request::Actual.from_hash(path: '/path', method: 'get') }
-      subject {
-        interactionList = InteractionList.new
-        interactionList.add expected_call
-        interactionList.register_unexpected unexpected_call
-        interactionList
-       }
-    end
-
-    shared_context "no unexpected requests or missed interactions exist" do
-      let(:expected_call) { {request: 'blah'} }
-      let(:unexpected_call) { Pact::Request::Actual.from_hash(path: '/path', method: 'get') }
-      subject {
-        interactionList = InteractionList.new
-        interactionList.add expected_call
-        interactionList.register_matched expected_call
-        interactionList
-       }
-    end
-
-    describe "interaction_diffs" do
-      context "when unexpected requests and missed interactions exist" do
-        include_context "unexpected requests and missed interactions"
-        let(:expected) {
-          {:missing_interactions=>[{:request=>"blah"}], :unexpected_requests=>[{:method=>"get", :path=>"/path"}]}
-        }
-        it "returns the unexpected requests and missed interactions" do
-          expect(subject.interaction_diffs).to eq expected
-        end
-      end
-
-      context "when no unexpected requests or missed interactions exist" do
-        include_context "no unexpected requests or missed interactions exist"
-        let(:expected) {
-          {}
-        }
-        it "returns an empty hash" do
-          expect(subject.interaction_diffs).to eq expected
-        end
-      end
-    end
-
-    describe "all_matched?" do
-      context "when unexpected requests or missed interactions exist" do
-        include_context "unexpected requests and missed interactions"
-        it "returns false" do
-          expect(subject.all_matched?).to be_false
-        end
-      end
-      context "when unexpected requests or missed interactions do not exist" do
-        include_context "no unexpected requests or missed interactions exist"
-        it "returns false" do
-          expect(subject.all_matched?).to be_true
-        end
-      end
-    end
-  end
-
-  describe RequestExtractor do
-    class TestSubject
-      include RequestExtractor
-    end
-
-    let(:rack_env) {
-      {
-             "CONTENT_LENGTH" => "16",
-               "CONTENT_TYPE" => content_type,
-          "GATEWAY_INTERFACE" => "CGI/1.1",
-                  "PATH_INFO" => "/donuts",
-               "QUERY_STRING" => "",
-                "REMOTE_ADDR" => "127.0.0.1",
-                "REMOTE_HOST" => "localhost",
-             "REQUEST_METHOD" => "POST",
-                "REQUEST_URI" => "http://localhost:4321/donuts",
-                "SCRIPT_NAME" => "",
-                "SERVER_NAME" => "localhost",
-                "SERVER_PORT" => "4321",
-            "SERVER_PROTOCOL" => "HTTP/1.1",
-            "SERVER_SOFTWARE" => "WEBrick/1.3.1 (Ruby/1.9.3/2013-02-22)",
-                "HTTP_ACCEPT" => "text/plain",
-            "HTTP_USER_AGENT" => "Ruby",
-                  "HTTP_HOST" => "localhost:4321",
-               "rack.version" => [1, 2 ],
-                 "rack.input" => StringIO.new(body),
-                "rack.errors" => nil,
-           "rack.multithread" => true,
-          "rack.multiprocess" => false,
-              "rack.run_once" => false,
-            "rack.url_scheme" => "http",
-               "HTTP_VERSION" => "HTTP/1.1",
-               "REQUEST_PATH" => "/donuts"
-      }
-     }
-
-    subject { TestSubject.new }
-
-    let(:expected_request) {
-      {
-            "query" => "",
-           "method" => "post",
-             "body" => expected_body,
-             "path" => "/donuts",
-          "headers" => {
-              "Content-Type" => content_type,
-                    "Accept" => "text/plain",
-                "User-Agent" => "Ruby",
-                      "Host" => "localhost:4321",
-                   "Version" => "HTTP/1.1"
-          }
-      }
-    }
-
-    context "with a text body" do
-      let(:content_type) { "application/x-www-form-urlencoded" }
-      let(:body) { 'this is the body' }
-      let(:expected_body) { body }
-
-      it "extracts the body" do
-        expect(subject.request_from(rack_env)).to eq expected_request
-      end
-    end
-
-    context "with a json body" do
-      let(:content_type) { "application/json" }
-      let(:body) { '{"a" : "body" }' }
-      let(:expected_body) { {"a" => "body"} }
-
-      it "extracts the body" do
-        expect(subject.request_from(rack_env)).to eq expected_request
-      end
-    end
-
-
-  end
-end