pact 0.1.28

data/.gitignore

@@ -0,0 +1,28 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+.bin
+tags
+.rbenv-version
+spec/pacts
+.rvmrc
+*.iml
+.rakeTasks
+*~
+.ruby-gemset
+.ruby-version
+log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+source 'http://rea-rubygems'
+
+# Specify your gem's dependencies in pact.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    pact (0.1.28)
+      awesome_print (~> 1.1.0)
+      capybara (~> 2.1.0)
+      find_a_port (~> 1.0.1)
+      hashie (~> 2.0.5)
+      json
+      rack-test (~> 0.6.2)
+      randexp (~> 0.1.7)
+      rspec (~> 2.12)
+      thin
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  remote: http://rea-rubygems/
+  specs:
+    addressable (2.3.5)
+    awesome_print (1.1.0)
+    capybara (2.1.0)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.3.3)
+      rack (>= 1.0.0)
+      rack-test (>= 0.5.4)
+      xpath (~> 2.0)
+    coderay (1.0.9)
+    crack (0.4.0)
+      safe_yaml (~> 0.9.0)
+    daemons (1.1.9)
+    diff-lcs (1.2.4)
+    eventmachine (1.0.3)
+    find_a_port (1.0.1)
+    geminabox-client (0.0.2)
+      multipart-post
+    hashie (2.0.5)
+    json (1.8.0)
+    method_source (0.8.1)
+    mime-types (1.23)
+    mini_portile (0.5.1)
+    multipart-post (1.2.0)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.0.4)
+    randexp (0.1.7)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.1)
+    safe_yaml (0.9.4)
+    slop (3.4.5)
+    thin (1.5.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    thor (0.18.1)
+    webmock (1.9.3)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+    xpath (2.0.0)
+      nokogiri (~> 1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  geminabox-client
+  pact!
+  pry
+  rake (~> 10.0.3)
+  webmock (~> 1.9.3)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 James Fraser, Sergei Matheson, Brent Snook
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,238 @@
+# Pact
+
+Define a pact between service consumers and providers.
+
+
+Pact provides an RSpec DSL for service consumers to define the request they will make to a service producer and the
+response they expect back. This expectation is used in the consumers specs to provide a mock producer, and is also
+played back in the producer specs to ensure the producer actually does provide the response the consumer expects.
+
+This allows you to test both sides of an integration point using fast unit tests.
+
+## Installation
+
+Put it in your Gemfile. You know how.
+
+## Usage
+
+### Consumer project
+
+#### Configuration
+
+Pact.configure do | config |
+  config.pact_dir = "???" # Optional, default is ./spec/pacts
+  config.log_dir = "???" # Optional, default is ./log
+  config.logger = "??"
+  config.logger.level = Logger::DEBUG #By default this is INFO, bump this up to debug for more detailed logs
+end
+
+#### Create a Consumer (Driven) Contract
+
+```ruby
+require 'pact/consumer/rspec'
+
+class SomeServiceClient
+  include HTTParty
+  # Load your base_uri from a stub-able source
+  base_uri App.configuration.some_service_base_uri
+
+  def get_something
+    JSON.parse(self.class.get("/something").body)
+  end
+end
+
+Pact.configure do | config |
+  config.consumer do
+    name 'My Consumer'
+  end
+end
+
+# The following block creates a service on localhost:1234 which will respond to your application's queries
+# over HTTP as if it were the real "My Producer" app. It also creats a mock producer object
+# which you will use to set up your expectations. The method name to access the mock producer
+# will be what ever name you give as the service argument - in this case "my_producer"
+
+Pact.with_producer "My Producer" do
+  mock_service :my_producer do
+    port 1234
+  end
+end
+
+# Use the :pact => true describe metadata to include all the pact generation functionality in your spec.
+
+describe "a pact with My Producer", :pact => true do
+
+  before do
+    # Configure your client to point to the stub service on localhost using the port you have specified
+    Application.configuration.stub(:some_service_base_uri).and_return('localhost:1234')
+  end
+
+  it "returns something when requested" do
+    my_producer.
+      given("something exists").
+        upon_receiving("a request for something").
+          with({ method: :get, path: '/something' }).
+            will_respond_with({
+              status: 200,
+              headers: { 'Content-Type' => 'application/json' },
+              body: {something: 'A thing!', something_else: 'Woot!'}
+            })
+    # Use your service's client to make the request, rather than hand crafting a HTTP request,
+    # so that you can be sure that the request that you expect to
+    # be constructed is actually constructed by your client.
+    # Do a quick sanity test to ensure client passes back the response properly.
+    expect(SomeServiceClient.get_something).to eql({something: 'A thing!'})
+  end
+end
+
+```
+
+Running the consumer spec will generate a pact file in the configured pact dir (spec/pacts by default).
+Logs will be output to the configured log dir that can be useful when diagnosing problems.
+
+To run your consumer app as a process during your test (eg for a Capybara test):
+
+```ruby
+Pact.configure do | config |
+  config.consumer do
+    name 'My Consumer'
+    app my_consumer_rack_app
+    port 4321
+  end
+```
+
+### Producer project
+
+#### Configure your producer rack app
+
+```ruby
+
+Pact.configure do | config |
+  config.producer do
+    name "My Producer"
+    app { MyApp.new }
+  end
+end
+
+```
+
+#### Set up the producer states
+
+Having different producer states allows you to test the same request with different expected responses.
+
+For example, some code that creates the pact in a consumer project might look like this:
+
+```ruby
+my_service.
+   given("a thing exists").
+     upon_receiving("a request for a thing").
+        with({method: 'get', path: '/thing'}).
+          will_respond_with({status: 200, :body => {thing: "yay!"} })
+
+my_service.
+  given("a thing does not exist").
+   upon_receiving("a request for a thing").
+      with({method: 'get', path: '/thing'}).
+        will_respond_with({status: 404, :body => {error: "There is no thing :("} })
+```
+
+To define producer states that create the right data for "a thing exists" and "a thing does not exist", write the following in the producer project.
+Note that these states have been defined only for the 'My Consumer' consumer by using the Pact.with_consumer block.
+
+
+```ruby
+# The consumer name here must match the name of the consumer configured in your consumer project
+# for it to use these states.
+
+Pact.with_consumer 'My Consumer' do
+  producer_state "a thing exists" do
+    set_up do
+      # Create a thing here using your factory of choice
+    end
+
+    tear_down do
+      # Any tear down steps to clean up your code (or use RSpec.after(:each))
+    end
+  end
+
+  producer_state "a thing does not exist" do
+    set_up do
+      # Well, probably not much to do here, but you get the picture.
+    end
+  end
+end
+
+```
+
+If a state should be used for all consumers, the top level Pact.with_consumer can be skipped, and a global Pact.producer_state can be defined on its own. 
+
+#### Create a rake task to verify that the producer honours the pact
+
+You'll need to create one or more pact:verify:xxx tasks, that allow the currently checked out producer to be tested against other versions of its consumers - most importantly, head and production.
+
+Here is an example pact:verify:head task, pointing the the pact file for "some_consumer", found in the build artifacts of the latest successful build of "MY-CONSUMER" project.
+
+```ruby
+Pact::VerificationTask.new(:head) do | pact |
+  pact.uri 'http://our_build_server/MY-CONSUMER-BUILD/latestSuccessful/artifact/Pacts/some_consumer-this_producer.json',
+    support_file: './spec/consumers/pact_helper'
+end
+```
+
+```ruby
+# Ideally we'd like to be able to create a production task like this, but firewalls are making this tricky right now.
+Pact::VerificationTask.new(:production) do | pact |
+  pact.uri 'http://our_prod_server/pacts/some_consumer-this_producer.json',
+    support_file: './spec/consumers/pact_helper', consumer: 'some_consumer'
+end
+```
+
+The pact.uri may be a local file system path or a remote URL.
+
+The consumer is optional, and specifies which consumer namespace to use when looking up the producer states, if consumer namespaces have been used.
+
+The support_file should include the code that makes your rack app available for the rack testing framework, and should load all its dependencies (eg include spec_helper)
+
+Multiple pact.uri may be defined in the same rake task if a producer has more than one consumer.
+
+#### Verify that the producer honours the pact
+
+    rake pact:verify:head
+    rake pact:verify # will run all verify tasks
+
+
+### Running a standalone mock server
+A pact service can be run locally and is really useful for debugging purposes.
+
+    $ bundle exec pact service -p <port-num>
+
+The service prints messages it recieves to stdout which can be really useful
+when diagnosing issues with pacts.
+
+## TODO
+
+Short term:
+- Rename ConsumerContract to ConsumerContract (Done)
+- Simplify set up for consumer (Done)
+  - Move server spawning into to the "at" method (Done)
+  - automatically register before and after hooks in consumer (Done)
+- Provide before and after hooks and a place to define the app for Pact configuration in producer (remove Rspc from interface of Pact setup) (Done)
+  - Set_up for state
+  - Tear_down for state
+  - Before hook for all
+  - After hook for all
+- Make producer state lookup try consumer defined state first, then fall back to global one (Done)
+- Put producer and consumer name into pact file (Done)
+- Remove consumer name from the rake task, as it should now be able to be determined from the pact file. (Done)
+
+Long term:
+- Decouple Rspec from Pact and make rspec-pact gem for easy integration
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,33 @@
+require 'bundler/gem_helper'
+module Bundler
+  class GemHelper
+    def install
+      desc "Build #{name}-#{version}.gem into the pkg directory"
+      task 'build' do
+        build_gem
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems"
+      task 'install' do
+        install_gem
+      end
+
+      GemHelper.instance = self
+    end
+  end
+end
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+require 'geminabox-client'
+
+Dir.glob('lib/tasks/**/*.rake').each { |task| load task }
+Dir.glob('tasks/**/*.rake').each { |task| load task }
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec, 'pact:tests']
+
+desc "Release to REA gems host"
+task :publish => :build do
+  gem_file = "pkg/pact-#{Pact::VERSION}.gem"
+  Geminabox::Client.new('http://rea-rubygems').upload(gem_file)
+end

data/bin/pact

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'pact/app'
+Pact::App.start

data/lib/pact/app.rb

@@ -0,0 +1,32 @@
+require 'find_a_port'
+require 'thor'
+require 'thin'
+require 'thwait'
+require 'pact/consumer'
+
+module Pact
+  class App < Thor
+
+    desc 'service', "starts a mock service"
+    method_option :port, aliases: "-p", desc: "Port on which to run the service"
+    method_option :log, aliases: "-l", desc: "File to which to log output"
+    method_option :quiet, aliases: "-q", desc: "If true, no admin messages will be shown"
+
+    def service
+      service_options = {}
+      if options[:log]
+        log = File.open(options[:log], 'w')
+        log.sync = true
+        service_options[:log_file] = log
+      end
+      port = options[:port] || FindAPort.available_port
+      mock_service = Consumer::MockService.new(service_options)
+      Thin::Server.start("0.0.0.0", port, mock_service)
+    end
+
+    private
+    def log message
+      puts message unless options[:quiet]
+    end
+  end
+end

data/lib/pact/configuration.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+require 'logger'
+
+module Pact
+
+  class Configuration
+    attr_accessor :pact_dir
+    attr_accessor :log_dir
+    attr_accessor :logger
+    attr_accessor :tmp_dir
+    attr_accessor :pactfile_write_mode
+
+    def log_path
+      log_dir + "/pact_gem.log"
+    end
+  end
+
+  def self.configuration
+    @configuration ||= default_configuration
+  end
+
+  def self.configure
+    yield configuration
+    FileUtils::mkdir_p configuration.tmp_dir
+  end
+
+  def self.clear_configuration
+    @configuration = default_configuration
+  end
+
+  private
+
+  def self.default_configuration
+    c = Configuration.new
+    c.pact_dir = File.expand_path('./spec/pacts')
+    c.tmp_dir = File.expand_path('./tmp/pacts')
+    c.log_dir = default_log_dir
+    c.logger = default_logger c.log_path
+    c.pactfile_write_mode = defined?(Rake) ? :overwrite : :update
+    c
+  end
+
+  def self.default_log_dir
+    File.expand_path("./log")
+  end
+
+  def self.default_logger path
+    FileUtils::mkdir_p File.dirname(path)
+    logger = Logger.new(path)
+    logger.level = Logger::INFO
+    logger
+  end
+
+end

data/lib/pact/consumer/app_manager.rb

@@ -0,0 +1,177 @@
+require 'thwait'
+require 'capybara'
+
+require 'net/http'
+require 'uri'
+require 'find_a_port'
+require 'pact/logging'
+
+module Pact
+  module Consumer
+    class AppManager
+
+      include Pact::Logging
+
+      include Singleton
+
+      def initialize
+        @apps_spawned = false
+        @app_registrations = []
+      end
+
+      def register_mock_service_for name, url
+        uri = URI(url)
+        raise "Currently only http is supported" unless uri.scheme == 'http'
+        raise "Currently only services on localhost are supported" unless uri.host == 'localhost'
+
+        register(MockService.new(log_file: create_log_file(name), name: name), uri.port)
+      end
+
+      def register(app, port = FindAPort.available_port)
+        existing = existing_app_on_port port
+        raise "Port #{port} is already being used by #{existing}" if existing and not existing == app
+        app_registration = register_app app, port
+        app_registration.spawn if @apps_spawned
+        port
+      end
+
+      def existing_app_on_port port
+        app_registration = @app_registrations.find { |app_registration| app_registration.port == port }
+        app_registration ? app_registration.app : nil
+      end
+
+      def app_registered_on?(port)
+        app_registrations.any? { |app_registration| app_registration.port == port }
+      end
+
+      def ports_of_mock_services
+        app_registrations.find_all(&:is_a_mock_service?).collect(&:port)
+      end
+
+      def kill_all
+        app_registrations.find_all(&:spawned?).collect(&:kill)
+        @apps_spawned = false
+      end
+
+      def clear_all
+        kill_all
+        @app_registrations = []
+      end
+
+      def spawn_all
+        app_registrations.find_all(&:not_spawned?).collect(&:spawn)
+        @apps_spawned = true
+      end
+
+      private
+
+      def create_log_file service_name
+        FileUtils::mkdir_p Pact.configuration.log_dir
+        log = File.open(log_file_path(service_name), 'w')
+        log.sync = true
+        log
+      end
+
+      def log_file_path service_name
+        File.join(Pact.configuration.log_dir, "#{log_file_name(service_name)}.log")
+      end
+
+      def log_file_name service_name
+        lower_case_name = service_name.downcase.gsub(/\s+/, '_')
+        if lower_case_name.include?('_service')
+          lower_case_name.gsub('_service', '_mock_service')
+        else
+          lower_case_name + '_mock_service'
+        end        
+      end
+
+      def app_registrations
+        @app_registrations
+      end
+
+      def register_app app, port
+        app_registration = AppRegistration.new :app => app, :port => port
+        app_registrations << app_registration
+        app_registration
+      end
+    end
+
+    class AppRegistration
+      include Pact::Logging
+      attr_accessor :port
+      attr_accessor :app
+      attr_accessor :pid
+
+      def initialize opts
+        @max_wait = 10
+        @port = opts[:port]
+        @pid = opts[:pid]
+        @app = opts[:app]
+      end
+
+      def kill
+        logger.info "Killing #{self}"
+        Process.kill(9, pid)
+        Process.wait(pid)
+        self.pid = nil
+      end
+
+      def not_spawned?
+        !spawned?
+      end
+
+      def spawned?
+        self.pid != nil
+      end
+
+      def is_a_mock_service?
+        app.is_a? MockService
+      end
+
+      def to_s
+        "#{app} on port #{port}" + (@pid ? " with pid #{pid}" : "")
+      end
+
+      def spawn
+        # following stolen from https://github.com/jwilger/kookaburra
+        logger.info "Starting app #{self}..."
+        self.pid = fork do
+          begin
+            Capybara.server_port = port
+            Capybara::Server.new(app).boot
+
+            # This ensures that this forked process keeps running, because the
+            # actual server is started in a thread by Capybara.
+            ThreadsWait.all_waits(Thread.list)
+          rescue Exception => e
+            logger.error "Error starting up #{self}"
+            $stderr.puts "Error starting up #{self}"
+            raise e
+          end
+        end
+
+
+        wait_until do
+          begin
+            Net::HTTP.get_response(URI.parse("http://localhost:#{port}/index.html"))
+          rescue Errno::ECONNREFUSED
+            false
+          end
+        end
+        logger.info "Started with pid #{pid}"
+      end
+
+      def wait_until
+        waited = 0
+        wait_time = 0.1
+        while waited < @max_wait do
+          break if yield
+          sleep wait_time
+          waited += wait_time
+          raise "Waited longer than #{@max_wait} seconds" if waited >= @max_wait
+        end
+      end
+
+    end
+  end
+end