pact 0.1.28

data/lib/pact/producer/rspec.rb

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

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

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

data/lib/pact/rake_task.rb

@@ -0,0 +1,64 @@
+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/reification.rb

@@ -0,0 +1,26 @@
+require 'randexp'
+
+module Pact
+  module Reification
+
+    def self.from_term(term)
+      case
+      when term.respond_to?(:generate)
+        term.generate
+      when term.is_a?(Hash)
+        term.inject({}) do |mem, (key,term)|
+          mem[key] = from_term(term)
+        mem
+        end
+      when term.is_a?(Array)
+        term.inject([]) do |mem, term|
+          mem << from_term(term)
+          mem
+        end
+      else
+        term
+      end
+    end
+
+  end
+end

data/lib/pact/request.rb

@@ -0,0 +1,109 @@
+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/term.rb

@@ -0,0 +1,40 @@
+module Pact
+  class Term
+
+    attr_reader :generate, :matcher
+
+    def self.json_create(obj)
+      new(generate: obj['data']['generate'], matcher: obj['data']['matcher'])
+    end
+
+    def initialize(attributes = {})
+      @generate = attributes[:generate]
+      @matcher = attributes[:matcher]
+    end
+
+    def to_json(options = {})
+      { json_class: self.class.name, data: { generate: generate, matcher: matcher} }.to_json(options)
+    end
+
+    def match(literal)
+      literal.respond_to?(:to_s) ? matcher.match(literal.to_s) : nil
+    end
+
+    def ==(other)
+      return false unless other.respond_to?(:generate) && other.respond_to?(:matcher)
+      generate == other.generate && matcher == other.matcher
+    end
+
+    def to_s
+      "Pact::Term matcher: #{matcher.to_s}" + (generate.nil? ? "" : " generate: \"#{generate}\"")
+    end
+
+    def diff_with_actual(actual)
+      match(actual) ? nil : {
+        expected: self,
+        actual: actual
+      }
+    end
+
+  end
+end

data/lib/pact/verification_task.rb

@@ -0,0 +1,57 @@
+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/lib/pact/version.rb

@@ -0,0 +1,3 @@
+module Pact
+  VERSION = "0.1.28"
+end

data/lib/pact.rb

@@ -0,0 +1,5 @@
+require_relative 'pact/version'
+require_relative 'pact/configuration'
+require_relative 'pact/consumer'
+require_relative 'pact/producer'
+require_relative 'pact/consumer_contract'

data/lib/tasks/pact.rake

@@ -0,0 +1,6 @@
+namespace :pact do
+	desc "Runs all the tasks prefixed with pact:verify in this project"
+  task :verify do
+    Rake::Task.tasks.find_all{ | task| task.name.start_with? "pact:verify:"}.map(&:invoke)
+  end
+end

data/pact.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pact/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pact"
+  gem.version       = Pact::VERSION
+  gem.authors       = ["James Fraser", "Sergei Matheson", "Brent Snook", "Ronald Holshausen", "Bethany Skurrie"]
+  gem.email         = ["james.fraser@alumni.swinburne.edu", "sergei.matheson@gmail.com", "brent@fuglylogic.com", "uglyog@gmail.com", "bskurrie@dius.com.au"]
+  gem.description   = %q{Define a pact between service consumers and providers}
+  gem.summary       = %q{Define a pact between service consumers and providers}
+  gem.homepage      = "https://github.com/uglyog/pact.git"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.license       = 'MIT'
+
+  gem.add_runtime_dependency 'randexp', '~> 0.1.7'
+  gem.add_runtime_dependency 'hashie', '~> 2.0.5'
+  gem.add_runtime_dependency 'rspec', '~> 2.12'
+  gem.add_runtime_dependency 'find_a_port', '~> 1.0.1'
+  gem.add_runtime_dependency 'rack-test', '~> 0.6.2'
+  gem.add_runtime_dependency 'awesome_print', '~> 1.1.0'
+  gem.add_runtime_dependency 'capybara', '~> 2.1.0'
+  gem.add_runtime_dependency 'thor'
+  gem.add_runtime_dependency 'thin'
+  gem.add_runtime_dependency 'json' #Not locking down a version because buncher gem requires 1.6, while other projects use 1.7.
+
+  gem.add_development_dependency 'geminabox-client'
+  gem.add_development_dependency 'rake', '~> 10.0.3'
+  gem.add_development_dependency 'webmock', '~> 1.9.3'
+  gem.add_development_dependency 'pry'
+end

data/scratchpad.txt

@@ -0,0 +1,36 @@
+Ideas for expectation DSL
+
+Unfortunately RSpec has already stolen the method "example".
+Could use:
+eg
+ex
+
+my_producer.
+   given("a thing exists").
+      upon_receiving("a request for a thing").with({:method => 'get', :path => '/thing'})
+         will_respond_with({:body => {
+            name: ex("Fred"),
+            age: eg 29,
+            mobile: eg("0415 134 234", /\d{4} \d{3} \d{3}/),
+            dob: eg("1983-02-28", match: /\d\d\d\d-\d\d-\d\d/),
+            driver_licence_number: eg(12345678, size: 8),
+            children: eg([{name: 'Mary'}])
+         }})
+
+eg([ {name: 'Mary'} ]) should match any array where every element has a name String
+eg([ {name: example('Mary', size: 4) } ]) should match any array where every element has a 4 letter name
+
+eg("Fred") could return Pact::Term.new(:matcher => /.+/, :generate => 'Fred')
+eg(29) could return Pact::Term.new(:matcher => /\d+/, :generate => 29)
+
+Need a way to specify a literal empty hash, rather than a hash that matches anything as {} currently does.
+
+{:something => literal({}) }
+{:something => actual({}) }
+{:something => empty_hash }
+
+Slightly unintuitive behaviour: {} matches any hash, but [] only matches an empty array (or does now we've changed the code). Should [] match any array? How do we then specify an empty array?
+
+{:something => literal([]) }
+{:something => actual([]) }
+{:something => empty_array }