pact 0.1.28 → 1.3.3

data/lib/pact/producer/rspec.rb

@@ -1,127 +0,0 @@
-require 'open-uri'
-require 'pact/consumer_contract'
-require 'pact/json_warning'
-require_relative 'matchers'
-require_relative 'test_methods'
-require_relative 'configuration_dsl'
-
-module Pact
-  module Producer
-    module RSpec
-
-      module InstanceMethods
-        def app
-          Pact.configuration.producer.app
-        end
-      end
-
-      module ClassMethods
-
-        include Pact::JsonWarning
-
-        def honour_pactfile pactfile_uri, options = {}
-          describe "Pact in #{pactfile_uri}" do
-            consumer_contract = Pact::ConsumerContract.from_json(read_pact_from(pactfile_uri, options))
-            honour_consumer_contract consumer_contract, options
-          end
-        end
-
-        def honour_consumer_contract consumer_contract, options = {}
-          check_for_active_support_json
-          describe_consumer_contract consumer_contract, options.merge({:consumer => consumer_contract.consumer.name})
-        end
-
-        private
-
-        def describe_consumer_contract consumer_contract, options
-          consumer_contract.interactions.each do |interaction|
-            describe_interaction_with_producer_state interaction, options
-          end
-        end
-
-        def describe_interaction_with_producer_state interaction, options
-          if interaction.producer_state
-            describe "Given #{interaction.producer_state}" do
-              describe_interaction interaction, options
-            end
-          else
-            describe_interaction interaction, options
-          end
-        end
-
-        def describe_interaction interaction, options
-
-          describe description_for(interaction) do
-
-            before do
-              set_up_producer_state interaction.producer_state, options[:consumer]
-              replay_interaction interaction
-            end
-
-            after do
-              tear_down_producer_state interaction.producer_state, options[:consumer]
-            end
-
-            describe_response interaction.response
-          end
-
-        end
-
-        def describe_response response
-          describe "returns a response which" do
-            if response['status']
-              it "has status code #{response['status']}" do
-                expect(last_response.status).to eql response['status']
-              end
-            end
-
-            if response['headers']
-              describe "includes headers" do
-                response['headers'].each do |name, value|
-                  it "\"#{name}\" with value \"#{value}\"" do
-                    expect(last_response.headers[name]).to match_term value
-                  end
-                end
-              end
-            end
-
-            if response['body']
-              it "has a matching body" do
-                logger.debug "Response body is #{last_response.body}"
-                expect(parse_entity_from_response(last_response)).to match_term response['body']
-              end
-            end
-          end
-        end
-
-        def description_for interaction
-          "#{interaction.description} to #{interaction.request.path}"
-        end
-
-        def read_pact_from uri, options = {}
-          pact = open(uri) { | file | file.read }
-          if options[:save_pactfile_to_tmp]
-            save_pactfile_to_tmp pact, File.basename(uri)
-          end
-          pact
-        rescue StandardError => e
-          $stderr.puts "Error reading file from #{uri}"
-          $stderr.puts "#{e.to_s} #{e.backtrace.join("\n")}"
-          raise e
-        end
-
-        def save_pactfile_to_tmp pact, name
-          File.open(Pact.configuration.tmp_dir + "/#{name}", "w") { |file|  file << pact}
-        end
-
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.extend Pact::Producer::RSpec::ClassMethods
-  config.include Pact::Producer::RSpec::InstanceMethods
-  config.include Pact::Producer::TestMethods
-  config.include Pact::Producer::TestMethods
-end

data/lib/pact/producer/test_methods.rb

@@ -1,89 +0,0 @@
-require 'pact/logging'
-require 'rack/test'
-require 'pact/reification'
-require 'pact/producer/producer_state'
-
-module Pact
-  module Producer
-    module TestMethods
-
-      include Pact::Logging
-      include Rack::Test::Methods
-
-      def parse_entity_from_response response
-        case response.headers['Content-Type']
-        when /json/
-          JSON.load(response.body)
-        else
-          response.body
-        end
-      end
-
-      def set_up_producer_state producer_state_name, consumer
-        if producer_state_name
-          get_producer_state(producer_state_name, consumer).set_up
-        end
-      end
-
-      def tear_down_producer_state producer_state_name, consumer
-        if producer_state_name
-          get_producer_state(producer_state_name, consumer).tear_down
-        end
-      end
-
-      def replay_interaction interaction
-        request = interaction.request
-        path = request_path(request)
-        args = [path, request_body(request)]
-
-        if !request.headers.nil?
-          args << request_headers(request)
-        end
-
-        logger.debug "Sending #{request.method} with #{args}"
-        self.send(request.method, *args)
-      end
-
-      private
-
-      def request_headers request
-        request_headers = {}
-        request.headers.each do |key, value|
-          key = key.upcase
-          if key.match(/CONTENT.TYPE/)
-            request_headers['CONTENT_TYPE'] = value
-          else
-            request_headers['HTTP_' + key.to_s] = value
-          end
-        end
-        request_headers
-      end
-
-      def request_path request
-        path = request.path
-        query = request.query
-        if query && !query.empty?
-          path += "?" + request.query
-        end
-        path
-      end
-
-      def request_body request
-        body = request.body
-        if body
-          body = JSON.dump(Pact::Reification.from_term(body))
-        else
-          body = ""
-        end
-      end
-
-      def get_producer_state producer_state_name, consumer
-        unless producer_state = ProducerState.get(producer_state_name, :for => consumer)
-          extra = consumer ? " for consumer \"#{consumer}\"" : ""
-          raise "Could not find a producer state defined for \"#{producer_state_name}\"#{extra}. Have you required the producer state file in your spec?"
-        end
-        producer_state
-      end
-    end
-  end
-end

data/lib/pact/producer.rb

@@ -1 +0,0 @@
-#TODO delete this file after checking if any projects load it

data/lib/pact/rake_task.rb

@@ -1,64 +0,0 @@
-require 'rake/tasklib'
-
-
-module Pact
-
-  ##
-  # To enable `rake pact`, put something like this in your Rakefile:
-  #
-  #     ```
-  #     require 'pact/rake_task'
-  #
-  #     Pact::RakeTask.new do |pact|
-  #       pact.file 'spec/pacts/some-pact.json',
-  #         from_url: 'http://example.com/some-pact.json'
-  #       pact.file 'spec/pacts/other-pact.json',
-  #         from_url: 'http://example.com/other-pact.json'
-  #     end
-  #     ```
-  class RakeTask < ::Rake::TaskLib
-    attr_reader :connections
-
-    def initialize(name = :pact)
-      @connections = []
-
-      yield self
-
-      namespace name do
-        desc "Update integration pacts from external sources"
-        task :pull do
-          connections.each do |conn|
-            body = fetch conn[:url]
-            File.open(conn[:file], 'w') {|f| f.write body }
-            puts "Wrote #{conn[:url]} to #{conn[:file]}"
-          end
-        end
-      end
-      task name => "#{name}:pull" # default task for the namespace
-    end
-
-    def file(filename, options = {})
-      url = options.fetch(:from_url)
-      @connections << {file: filename, url: url}
-    end
-
-    private
-    # written with plain Net::HTTP to avoid bringing in extra dependencies
-    def fetch(url_string, redirection_limit = 5)
-      raise 'Too many HTTP redirects' if redirection_limit == 0
-      url = URI.parse(url_string)
-      response = Net::HTTP.get_response(url)
-      case response
-      when Net::HTTPSuccess then
-        response.body
-      when Net::HTTPRedirection then
-        location = response['Location']
-        fetch(location, redirection_limit - 1)
-      else
-        response.value # raise the appropriate error
-      end
-    end
-  end
-
-
-end

data/lib/pact/request.rb

@@ -1,109 +0,0 @@
-require 'pact/matchers'
-
-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
-
-      def self.from_hash(hash)
-        sym_hash = hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
-        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 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
-
-    end
-
-    class Expected < Base
-
-      attr_accessor :description
-
-      def self.from_hash(hash)
-        request = super
-        request.description = hash.fetch(:description, nil)
-        request
-      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)
-        diff(as_json, actual_request.as_json)
-      end
-
-    end
-
-    class Actual < Base
-    end
-
-  end
-end

data/lib/pact/verification_task.rb

@@ -1,57 +0,0 @@
-require 'rake/tasklib'
-require 'pact/producer/pact_spec_runner'
-
-=begin
-	To create a rake pact:verify:<something> task
-
-	Pact::VerificationTask.new(:head) do | pact |
-	  pact.uri 'http://master.cd.vpc.realestate.com.au/browse/BIQ-MAS/latestSuccessful/artifact/JOB2/Pacts/mas-contract_transaction_service.json',
-	              support_file: './spec/consumers/pact_helper'
-    pact.uri 'http://master.cd.vpc.realestate.com.au/browse/BIQ-IMAGINARY-CONSUMER/latestSuccessful/artifact/JOB2/Pacts/imaginary_consumer-contract_transaction_service.json',
-                support_file: './spec/consumers/pact_helper'
-	end
-
-	The pact.uri may be a local file system path or a remote URL.
-	The support_file should include code that makes your rack app available for the rack testing framework.
-	Eg.
-
-	Pact.configure do | config |
-		config.producer do
-			name "My Producer"
-			app { TestApp.new }
-		end
-	end
-
-	It should also load all your app's dependencies (eg by calling out to spec_helper)
-
-=end
-
-module Pact
-	class VerificationTask < ::Rake::TaskLib
-	  attr_reader :pact_spec_config
-
-	  def initialize(name)
-	    @pact_spec_config = []
-
-	    yield self
-
-	    namespace :pact do
-	      desc "Verify producer against the consumer pacts for #{name}"
-	      task "verify:#{name}" do
-	        exit_status = Producer::PactSpecRunner.run(pact_spec_config)
-	        fail failure_message if exit_status != 0
-	      end
-
-	      def failure_message
-	      	"\n* * * * * * * * * * * * * * * * * * *\n" +
-	      	"Producer 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
-	    end
-	  end
-
-	  def uri(uri, options)
-	    @pact_spec_config << {uri: uri, support_file: options[:support_file], consumer: options[:consumer]}
-	  end
-	end
-end

data/spec/integration/pact/configuration_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'pact/configuration'
-require 'pact/consumer/dsl'
-require 'pact/consumer/configuration_dsl'
-require 'pact/producer/configuration_dsl'
-
-describe "configure" do
-
- before do
-    Pact.clear_configuration
-    Pact::Consumer::AppManager.instance.clear_all
-
-    Pact.configure do | config |
-      config.consumer do
-        name "My Consumer"
-      end
-    end
-
-    Pact.with_producer "My Service" do
-      mock_service :my_service do
-        port 1234
-        standalone true
-      end
-    end
-
-    Pact.with_producer "My Other Service" do
-      mock_service :my_other_service do
-        port 1235
-        standalone false
-      end
-    end
-  end
-
-  describe "configuration" do
-    it "should return the same configuration object each time" do
-      expect(Pact.configuration).to equal(Pact.configuration)
-    end
-  end
-
-  describe "consumer" do
-    it "should be configured" do
-      Pact.configuration.consumer.name.should eq "My Consumer"
-    end
-  end
-
-  describe "producers" do
-    include Pact::Consumer::ConsumerContractBuilders
-
-    it "should have defined methods in MockServices for the producers" do
-      my_service.should be_instance_of Pact::Consumer::ConsumerContractBuilder
-    end
-
-    context "when standalone is true" do
-      it "is not registerd with the AppManager" do
-        Pact::Consumer::AppManager.instance.app_registered_on?(1234).should be_false
-      end
-    end
-
-    context "when standalone is false" do
-      it "should register the MockServices on their given ports if they are not" do
-        Pact::Consumer::AppManager.instance.app_registered_on?(1235).should be_true
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/dsl'
-require 'pact/consumer/configuration_dsl'
-
-module Pact::Consumer::DSL
-   describe Service do
-      before do
-         Pact.clear_configuration
-         Pact::Consumer::AppManager.instance.stub(:register_mock_service_for)
-      end
-      describe "configure_consumer_contract_builder" do
-         subject { 
-            Service.new :mock_service do
-               port 1234
-               standalone true
-               verify true
-            end
-         }
-
-         let(:producer_name) { 'Mock Producer'}
-         let(:consumer_contract_builder) { double('Pact::Consumer::ConsumerContractBuilder').as_null_object}
-         let(:url) { "http://localhost:1234"}
-
-         it "adds a verification to the Pact configuration" do
-            Pact::Consumer::ConsumerContractBuilder.stub(:new).and_return(consumer_contract_builder)
-            subject.configure_consumer_contract_builder({})
-            consumer_contract_builder.should_receive(:verify)
-            Pact.configuration.producer_verifications.first.call
-         end
-
-         context "when standalone" do
-            it "does not register the app with the AppManager" do
-               Pact::Consumer::AppManager.instance.should_not_receive(:register_mock_service_for)
-               subject.configure_consumer_contract_builder({})
-            end
-         end
-         context "when not standalone" do
-            subject { 
-               Service.new :mock_service do
-                  port 1234
-                  standalone false
-                  verify true
-               end
-            }            
-            it "registers the app with the AppManager" do
-               Pact::Consumer::AppManager.instance.should_receive(:register_mock_service_for).with(producer_name, url)
-               subject.configure_consumer_contract_builder({:producer_name => producer_name })
-            end
-         end         
-      end
-   end
-end

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

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-module Pact
-  module Consumer
-    describe InteractionBuilder do
-
-      subject { 
-        interaction_builder = InteractionBuilder.new('Test request', nil).with(request) 
-        interaction_builder.on_interaction_fully_defined do | interaction |
-          producer.callback interaction
-        end
-        interaction_builder
-      }
-
-      let(:pact_path) { File.expand_path('../../../../pacts/mock', __FILE__) }
-
-      let(:request) do
-        {
-          method: 'post',
-          path: '/foo',
-          body: Term.new(generate: 'waffle', matcher: /ffl/),
-          headers: { 'Content-Type' => 'application/json' },
-          query: '',
-        }
-      end
-
-      let(:response) do
-        { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
-      end
-
-      let(:producer) do
-        double(callback: nil)
-      end
-
-      describe "setting up responses" do
-
-        it "invokes the callback" do
-          producer.should_receive(:callback).with(subject.interaction)
-          subject.will_respond_with response
-        end
-
-      end
-
-      describe "to JSON" do
-
-        let(:parsed_result) do
-          JSON.load(JSON.dump(subject.interaction))
-        end
-
-        before do
-          subject.will_respond_with response
-        end
-
-        it "contains the request" do
-          expect(parsed_result['request']).to eq({
-              'method' => 'post',
-              'path' => '/foo',
-              'headers' => {
-                'Content-Type' => 'application/json'
-              },
-              'body' => Term.new(generate: 'waffle', matcher: /ffl/),
-              'query' => ''
-            })
-        end
-
-        describe "response" do
-
-          it "serialises regexes" do
-            expect(parsed_result['response']['baz']).to eql /qux/
-          end
-
-          it "serialises terms" do
-            term = Term.new(generate:'wiffle', matcher: /iff/)
-            parsed_term = parsed_result['response']['wiffle']
-            expect(term.matcher).to eql parsed_term.matcher
-            expect(term.generate).to eql parsed_term.generate
-          end
-
-        end
-
-        context "with a producer_state" do
-          context "described with a string" do
-            subject { 
-              interaction_builder = InteractionBuilder.new('Test request', "there are no alligators").with(request) 
-              interaction_builder.on_interaction_fully_defined {}
-              interaction_builder
-            }
-
-            it "includes the state name as a string" do
-              expect(parsed_result['producer_state']).to eql("there are no alligators")
-            end
-          end
-          context "described with a symbol" do
-            subject { 
-              interaction_builder = InteractionBuilder.new('Test request', :there_are_no_alligators).with(request) 
-              interaction_builder.on_interaction_fully_defined {}
-              interaction_builder
-            }
-
-            it "includes the state name as a symbol" do
-              expect(parsed_result['producer_state']).to eql("there_are_no_alligators")
-            end
-          end
-        end
-      end
-    end
-  end
-end