pact-support 0.0.1

data/lib/pact/shared/text_differ.rb

@@ -0,0 +1,14 @@
+require 'pact/matchers/matchers'
+require 'pact/matchers/difference'
+
+module Pact
+  class TextDiffer
+
+    extend Matchers
+
+    def self.call expected, actual, options = {}
+      diff expected, actual, options
+    end
+
+  end
+end

data/lib/pact/something_like.rb

@@ -0,0 +1,49 @@
+require 'pact/symbolize_keys'
+module Pact
+
+  # Specifies that the actual object should be considered a match if
+  # it includes the same keys, and the values of the keys are of the same class.
+
+  class SomethingLike
+    include SymbolizeKeys
+
+    attr_reader :contents
+
+    def initialize contents
+      @contents = contents
+    end
+
+    def to_hash
+      {
+        :json_class => self.class.name,
+        :contents => contents
+      }
+    end
+
+    def as_json opts = {}
+      to_hash
+    end
+
+    def to_json opts = {}
+      as_json.to_json opts
+    end
+
+    def self.json_create hash
+      new(symbolize_keys(hash)[:contents])
+    end
+
+    def eq other
+      self == other
+    end
+
+    def == other
+      other.is_a?(SomethingLike) && other.contents == self.contents
+    end
+
+    def generate
+      contents
+    end
+  end
+end
+
+

data/lib/pact/support.rb

@@ -0,0 +1,9 @@
+require 'pact/support/version'
+require 'pact/consumer_contract'
+require 'pact/matchers'
+require 'pact/logging'
+require 'pact/term'
+require 'pact/something_like'
+require 'pact/configuration'
+require 'pact/reification'
+require 'pact/rspec'

data/lib/pact/support/version.rb

@@ -0,0 +1,5 @@
+module Pact
+  module Support
+    VERSION = "0.0.1"
+  end
+end

data/lib/pact/symbolize_keys.rb

@@ -0,0 +1,12 @@
+module Pact
+  module SymbolizeKeys
+
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def symbolize_keys hash
+      hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+    end
+  end
+end

data/lib/pact/term.rb

@@ -0,0 +1,85 @@
+require 'pact/shared/active_support_support'
+require 'json/add/regexp'
+
+module Pact
+  class Term
+
+    include Pact::ActiveSupportSupport
+
+    attr_reader :generate, :matcher
+
+    def self.json_create(obj)
+      new(generate: obj['data']['generate'], matcher: obj['data']['matcher'])
+    end
+
+    def self.unpack_regexps source
+      case source
+      when Pact::Term then source.matcher
+      when Array then unpack_regexps_from_array source
+      when Hash then unpack_regexps_from_hash source
+      else
+        source
+      end
+    end
+
+    def initialize(attributes = {})
+      @generate = attributes[:generate]
+      @matcher = attributes[:matcher]
+      raise "Please specify a matcher for the Term" unless @matcher != nil
+      raise "Please specify a value to generate for the Term" unless @generate != nil
+      raise "Value to generate \"#{@generate}\" does not match regular expression #{@matcher}" unless @generate =~ @matcher
+    end
+
+    def to_hash
+      { json_class: self.class.name, data: { generate: generate, matcher: fix_regexp(matcher)} }
+    end
+
+    def as_json(options = {})
+      to_hash
+    end
+
+
+    def to_json(options = {})
+      as_json.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.inspect}" + (generate.nil? ? "" : " generate: \"#{generate}\"")
+    end
+
+    def diff_with_actual(actual)
+      match(actual) ? nil : {
+        expected: self,
+        actual: actual
+      }
+    end
+
+    def empty?
+      false
+    end
+
+    private
+
+    def self.unpack_regexps_from_array source
+      source.each_with_object([]) do | item, destination |
+        destination << unpack_regexps(item)
+      end
+    end
+
+    def self.unpack_regexps_from_hash source
+      source.keys.each_with_object({}) do | key, destination |
+        destination[key] = unpack_regexps source[key]
+      end
+    end
+
+  end
+end

data/lib/tasks/pact.rake

@@ -0,0 +1,29 @@
+
+namespace :pact do
+
+  desc "Verifies the pact files configured in the pact_helper.rb against this service provider."
+  task :verify do
+
+    require 'pact/tasks/task_helper'
+
+    include Pact::TaskHelper
+
+    handle_verification_failure do
+      execute_pact_verify
+    end
+  end
+
+  desc "Verifies the pact at the given URI against this service provider."
+  task 'verify:at', :pact_uri do | t, args |
+    require 'term/ansicolor'
+    require 'pact/tasks/task_helper'
+
+    include Pact::TaskHelper
+
+    abort(::Term::ANSIColor.red("Please provide a pact URI. eg. rake pact:verify:at[../my-consumer/spec/pacts/my_consumer-my_provider.json]")) unless args[:pact_uri]
+    handle_verification_failure do
+      execute_pact_verify args[:pact_uri]
+    end
+  end
+
+end

data/pact-support.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pact/support/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pact-support"
+  gem.version       = Pact::Support::VERSION
+  gem.authors       = ["James Fraser", "Sergei Matheson", "Brent Snook", "Ronald Holshausen", "Beth Skurrie"]
+  gem.email         = ["james.fraser@alumni.swinburne.edu", "sergei.matheson@gmail.com", "brent@fuglylogic.com", "uglyog@gmail.com", "bskurrie@dius.com.au"]
+  gem.summary       = %q{Shared code for Pact gems}
+  gem.homepage      = "https://github.com/bethesque/pact-support"
+
+  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 'rspec', '>=2.14'
+  gem.add_runtime_dependency 'rack-test', '~> 0.6.2'
+  gem.add_runtime_dependency 'awesome_print', '~> 1.1'
+  gem.add_runtime_dependency 'json'
+  gem.add_runtime_dependency 'term-ansicolor', '~> 1.0'
+  gem.add_runtime_dependency 'find_a_port', '~> 1.0.1'
+  gem.add_runtime_dependency 'thor'
+
+  gem.add_development_dependency 'rake', '~> 10.0.3'
+  gem.add_development_dependency 'webmock', '~> 1.18.0'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'fakefs', '~> 0.4'
+  gem.add_development_dependency 'hashie', '~> 2.0'
+  gem.add_development_dependency 'activesupport'
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'support/shared_examples_for_request'
+require 'pact/consumer/request'
+
+module Pact
+  describe Consumer::Request::Actual do
+    it_behaves_like "a request"
+
+    let(:raw_request) do
+      {
+        'method' => 'get',
+        'path' => '/mallory'
+      }
+    end
+
+    describe "from_hash" do
+      context "when field are not defined" do
+        subject { described_class.from_hash(raw_request) }
+        it "raises an error" do
+          expect{subject}.to raise_error KeyError
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer_contract/active_support_support_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'pact/shared/active_support_support'
+
+module Pact
+  describe ActiveSupportSupport do
+
+    include ActiveSupportSupport
+
+
+    describe "fix_regexp" do
+      let(:regexp) { /moose/ }
+
+      subject { fix_regexp regexp }
+
+      it "returns the original regexp" do
+        expect(subject).to be(regexp)
+      end
+
+      it "fixes the as_json method for Regexp that ActiveSupport tramples beneath its destructive hooves of destruction" do
+        expect(subject.to_json).to eq("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"moose\"}")
+      end
+    end
+
+    describe "fix_all_the_things" do
+      let(:hash) do
+        { 'body' => Pact::Term.new(matcher: /a*b/, generate: 'abba'), array: [/blah/], thing: /alligator/ }
+      end
+
+      subject { fix_all_the_things(hash) }
+
+      it "returns the original object" do
+        expect(subject).to be(hash)
+      end
+
+      it "finds all the Regexp objects in hashes or Pact class attributes and fixes the as_json method" do
+        json = subject.to_json
+        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"a*b\"}")
+        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"blah\"}")
+        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"alligator\"}")
+      end
+    end
+
+    describe "fix_json_formatting" do
+      let(:active_support_affected_pretty_generated_json) { "{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"a*b\"}" }
+      let(:pretty_generated_json) do
+'{
+  "json_class": "Regexp",
+  "o": 0,
+  "s": "a*b"
+}'
+      end
+
+      it "pretty formats the json that has been not pretty formatted because of ActiveSupport" do
+        expect(fix_json_formatting(active_support_affected_pretty_generated_json)).to eq (pretty_generated_json.strip)
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer_contract/consumer_contract_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'pact/consumer_contract'
+
+module Pact
+  describe ConsumerContract do
+    describe "as_json" do
+
+      class MockInteraction
+        def as_json(options ={})
+          {:mock => "interaction"}
+        end
+      end
+
+      before do
+        allow(DateTime).to receive(:now).and_return(DateTime.strptime("2013-08-15T13:27:13+10:00"))
+      end
+
+      let(:service_consumer) { double('ServiceConsumer', :as_json => {:a => 'consumer'}) }
+      let(:service_provider) { double('ServiceProvider', :as_json => {:a => 'provider'}) }
+      let(:pact) { ConsumerContract.new({:interactions => [MockInteraction.new], :consumer => service_consumer, :provider => service_provider }) }
+      let(:expected_as_json) { {:provider=>{:a=>"provider"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pactSpecificationVersion=> "1.0.0" }} }
+
+      it "should return a hash representation of the Pact" do
+        expect(pact.as_json).to eq expected_as_json
+      end
+
+    end
+
+    describe ".from_json" do
+      let(:loaded_pact) { ConsumerContract.from_json(string) }
+      context "when the top level object is a ConsumerContract" do
+        let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}, "response": {"status" : 200}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
+
+        it "should create a Pact" do
+          expect(loaded_pact).to be_instance_of ConsumerContract
+        end
+
+        it "should have interactions" do
+          expect(loaded_pact.interactions).to be_instance_of Array
+        end
+
+        it "should have a consumer" do
+          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+        end
+
+        it "should have a provider" do
+          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+        end
+      end
+
+      context "with old 'producer' key" do
+        let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
+        it "should create a Pact" do
+          expect(loaded_pact).to be_instance_of ConsumerContract
+        end
+
+        it "should have interactions" do
+          expect(loaded_pact.interactions).to be_instance_of Array
+        end
+
+        it "should have a consumer" do
+          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+        end
+
+        it "should have a provider" do
+          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+          expect(loaded_pact.provider.name).to eq "an old producer"
+        end
+
+        it "should have a provider_state" do
+          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
+        end
+      end
+    end
+
+    describe "find_interactions" do
+      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
+      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
+      let(:interaction) { double('Pact::Interaction') }
+      subject { ConsumerContract.new(:interactions => [interaction], :consumer => consumer, :provider => provider) }
+      let(:criteria) { {:description => /blah/} }
+      before do
+        expect(interaction).to receive(:matches_criteria?).with(criteria).and_return(matches)
+      end
+      context "by description" do
+        context "when no interactions are found" do
+          let(:matches) { false }
+          it "returns an empty array" do
+            expect(subject.find_interactions(criteria)).to eql []
+          end
+        end
+        context "when interactions are found" do
+          let(:matches) { true }
+          it "returns an array of the matching interactions" do
+            expect(subject.find_interactions(criteria)).to eql [interaction]
+          end
+        end
+      end
+    end
+
+    describe "find_interaction" do
+      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
+      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
+      let(:interaction1) { double('Pact::Interaction') }
+      let(:interaction2) { double('Pact::Interaction') }
+      let(:criteria) { {:description => /blah/} }
+
+      before do
+        expect(interaction1).to receive(:matches_criteria?).with(criteria).and_return(matches1)
+        expect(interaction2).to receive(:matches_criteria?).with(criteria).and_return(matches2)
+      end
+
+      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :provider => provider) }
+      context "by description" do
+        context "when a match is found" do
+          let(:matches1) { true }
+          let(:matches2) { false }
+
+          it "returns the interaction" do
+            expect(subject.find_interaction criteria).to eql interaction1
+          end
+        end
+        context "when more than one match is found" do
+          let(:matches1) { true }
+          let(:matches2) { true }
+          it "raises an error" do
+            expect{ subject.find_interaction(criteria) }.to raise_error "Found more than 1 interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
+          end
+        end
+        context "when a match is not found" do
+          let(:matches1) { false }
+          let(:matches2) { false }
+          it "raises an error" do
+            expect{ subject.find_interaction(criteria) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
+          end
+        end
+      end
+    end
+
+  end
+end