pact-v2 2.0.0.pre.preview1

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 REA Group Ltd
+
+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/bin/pact

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

data/lib/pact/cli/generate_pact_docs.rb

@@ -0,0 +1,4 @@
+require 'pact/doc/doc_file'
+require 'pact/doc/generate'
+require 'pact/doc/markdown/generator'
+require 'pact/consumer'

data/lib/pact/cli/run_pact_verification.rb

@@ -0,0 +1,99 @@
+require 'pact/cli/spec_criteria'
+
+module Pact
+  module Cli
+    class RunPactVerification
+      attr_reader :options
+
+      def initialize options
+        @options = options
+      end
+
+      def self.call options
+        new(options).call
+      end
+
+      def call
+        configure_output
+        initialize_rspec
+        setup_load_path
+        load_pact_helper
+        run_specs
+      end
+
+      private
+
+      def initialize_rspec
+        # With RSpec3, if the pact_helper loads a library that adds its own formatter before we set one,
+        # we will get a ProgressFormatter too, and get little dots sprinkled throughout our output.
+        # Load a NilFormatter here to prevent that.
+        require 'rspec'
+        require 'pact/rspec'
+        ::RSpec.configuration.add_formatter Pact::RSpec.formatter_class.const_get('NilFormatter')
+      end
+
+      def setup_load_path
+        require 'pact/provider/pact_spec_runner'
+        lib = File.join(Dir.pwd, "lib") # Assume we are running from within the project root. RSpec is smarter about this.
+        spec = File.join(Dir.pwd, "spec")
+        $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+        $LOAD_PATH.unshift(spec) if Dir.exist?(spec) && !$LOAD_PATH.include?(spec)
+      end
+
+      def load_pact_helper
+        load options[:pact_helper]
+      end
+
+      def run_specs
+        exit_code = if options[:pact_uri].is_a?(String)
+          run_with_pact_url_string
+        elsif options[:pact_uri]
+          run_with_pact_uri_object # from pact-provider-verifier
+        else
+          run_with_configured_pacts_from_pact_helper
+        end
+        exit exit_code
+      end
+
+      def run_with_pact_url_string
+        pact_repository_uri_options = {}
+        pact_repository_uri_options[:username] = ENV['PACT_BROKER_USERNAME'] if ENV['PACT_BROKER_USERNAME']
+        pact_repository_uri_options[:password] = ENV['PACT_BROKER_PASSWORD'] if ENV['PACT_BROKER_PASSWORD']
+        pact_repository_uri_options[:token] = ENV['PACT_BROKER_TOKEN']
+        pact_repository_uri_options[:username] = options[:pact_broker_username] if options[:pact_broker_username]
+        pact_repository_uri_options[:password] = options[:pact_broker_password] if options[:pact_broker_password]
+        pact_uri = ::Pact::Provider::PactURI.new(options[:pact_uri], pact_repository_uri_options)
+        Pact::Provider::PactSpecRunner.new([pact_uri], pact_spec_options).run
+      end
+
+      def run_with_pact_uri_object
+        Pact::Provider::PactSpecRunner.new([options[:pact_uri]], pact_spec_options).run
+      end
+
+      def run_with_configured_pacts_from_pact_helper
+        pact_urls = Pact.provider_world.pact_urls
+        Pact::Provider::PactSpecRunner.new(pact_urls, pact_spec_options).run
+      end
+
+      def pact_spec_options
+        {
+          full_backtrace: options[:backtrace],
+          verbose: options[:verbose] || ENV['VERBOSE'] == 'true',
+          criteria: SpecCriteria.call(options),
+          format: options[:format],
+          out: options[:out],
+          ignore_failures: options[:ignore_failures],
+          request_customizer: options[:request_customizer]
+        }
+      end
+
+      def configure_output
+        if options[:format] == 'json' && !options[:out]
+          # Don't want to mess up the JSON parsing with messages to stdout, so send it to stderr
+          require 'pact/configuration'
+          Pact.configuration.output_stream = Pact.configuration.error_stream
+        end
+      end
+    end
+  end
+end

data/lib/pact/cli/spec_criteria.rb

@@ -0,0 +1,26 @@
+module Pact
+  module Cli
+    class SpecCriteria
+
+      def self.call options
+        criteria = {}
+
+        criteria[:description] = Regexp.new(options[:description]) if options[:description]
+        criteria[:_id] = options[:pact_broker_interaction_id] if options[:pact_broker_interaction_id]
+        criteria[:index] = options[:interaction_index] if options[:interaction_index]
+
+        provider_state = options[:provider_state]
+
+        if provider_state
+          if provider_state.length == 0
+            criteria[:provider_state] = nil #Allow PACT_PROVIDER_STATE="" to mean no provider state
+          else
+            criteria[:provider_state] = Regexp.new(provider_state)
+          end
+        end
+
+        criteria
+      end
+    end
+  end
+end

data/lib/pact/cli.rb

@@ -0,0 +1,45 @@
+require 'thor'
+require 'pact/consumer/configuration'
+require 'pact/provider/configuration'
+
+module Pact
+  class CLI < Thor
+    def self.exit_on_failure? # Thor 1.0 deprecation guard
+      false
+    end
+
+    desc 'verify', "Verify a pact"
+    method_option :pact_helper, aliases: "-h", desc: "Pact helper file", :required => true
+    method_option :pact_uri, aliases: "-p", desc: "Pact URI"
+    method_option :ignore_failures, type: :boolean, default: false, desc: "Process will always exit with exit code 0", hide: true
+    method_option :pact_broker_username, aliases: "-u", desc: "Pact broker user name"
+    method_option :pact_broker_password, aliases: "-w", desc: "Pact broker password"
+    method_option :pact_broker_token, aliases: "-k", desc: "Pact broker token"
+    method_option :backtrace, aliases: "-b", desc: "Show full backtrace", :default => false, :type => :boolean
+    method_option :verbose, aliases: "-v", desc: "Show verbose HTTP logging", :default => false, :type => :boolean
+    method_option :interactions_replay_order, aliases: "-o",
+                  desc: "Interactions replay order: randomised or recorded (default)",
+                  default: Pact.configuration.interactions_replay_order
+    method_option :description, aliases: "-d", desc: "Interaction description filter"
+    method_option :provider_state, aliases: "-s", desc: "Provider state filter"
+    method_option :interaction_index, type: :numeric, desc: "Index filter"
+    method_option :pact_broker_interaction_id, desc: "Pact Broker interaction ID filter"
+    method_option :format, aliases: "-f", banner: "FORMATTER", desc: "RSpec formatter. Defaults to custom Pact formatter. [j]son may also be used."
+    method_option :out, aliases: "-o", banner: "FILE", desc: "Write output to a file instead of $stdout."
+
+    def verify
+      require 'pact/cli/run_pact_verification'
+      Cli::RunPactVerification.call(options)
+    end
+
+    desc 'docs', "Generate Pact documentation in markdown"
+    method_option :pact_dir, desc: "Directory containing the pacts", default: Pact.configuration.pact_dir
+    method_option :doc_dir, desc: "Documentation directory", default: Pact.configuration.doc_dir
+
+    def docs
+      require 'pact/cli/generate_pact_docs'
+      require 'pact/doc/generator'
+      Pact::Doc::Generate.call(options[:pact_dir], options[:doc_dir], [Pact::Doc::Markdown::Generator])
+    end
+  end
+end

data/lib/pact/consumer/configuration/configuration_extensions.rb

@@ -0,0 +1,90 @@
+require 'pact/configuration'
+require 'pact/doc/markdown/generator'
+
+module Pact
+  module Consumer
+    module Configuration
+
+      module ConfigurationExtensions
+
+        DOC_GENERATORS = { markdown: Pact::Doc::Markdown::Generator }
+
+        def doc_dir
+          @doc_dir ||= File.expand_path("./doc/pacts")
+        end
+
+        def doc_dir= doc_dir
+          @doc_dir = doc_dir
+        end
+
+        def reports_dir
+          @reports_dir ||= default_reports_dir
+        end
+
+        def default_reports_dir
+          File.expand_path("./reports/pacts")
+        end
+
+        def reports_dir= reports_dir
+          @reports_dir = reports_dir
+        end
+
+        def add_provider_verification &block
+          provider_verifications << block
+        end
+
+        def provider_verifications
+          @provider_verifications ||= []
+        end
+
+        def doc_generator= doc_generator
+          add_doc_generator doc_generator
+        end
+
+        def add_doc_generator doc_generator
+          doc_generators << begin
+            if DOC_GENERATORS[doc_generator]
+              DOC_GENERATORS[doc_generator]
+            elsif doc_generator.respond_to?(:call)
+              doc_generator
+            else
+              raise "doc_generator needs to respond to call, or be in the preconfigured list: #{DOC_GENERATORS.keys}"
+            end
+          end
+        end
+
+        def doc_generators
+          @doc_generators  ||= []
+        end
+
+        def pactfile_write_mode
+          @pactfile_write_mode ||= :overwrite
+          if @pactfile_write_mode == :smart
+            is_rake_running? ? :overwrite : :update
+          else
+            @pactfile_write_mode
+          end
+        end
+
+        def pactfile_write_mode= pactfile_write_mode
+          @pactfile_write_mode = pactfile_write_mode
+        end
+
+        def pactfile_write_order
+          @pactfile_write_order ||= :chronological #or :alphabetical
+        end
+
+        def pactfile_write_order= pactfile_write_order
+          @pactfile_write_order = pactfile_write_order.to_sym
+        end
+
+        private
+
+        #Would love a better way of determining this! It sure won't work on windows.
+        def is_rake_running?
+          `ps -ef | grep rake | grep #{Process.ppid} | grep -v 'grep'`.size > 0
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/dsl.rb

@@ -0,0 +1,11 @@
+require 'pact/consumer/configuration/service_consumer'
+
+module Pact
+  module Consumer
+    module DSL
+      def service_consumer name, &block
+        Configuration::ServiceConsumer.build(name, &block)
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/mock_service.rb

@@ -0,0 +1,112 @@
+require 'pact/mock_service/version'
+require 'pact/mock_service/app_manager'
+require 'pact/consumer/consumer_contract_builder'
+require 'pact/consumer/consumer_contract_builders'
+require 'pact/consumer/world'
+
+module Pact
+  module Consumer
+    module Configuration
+      class MockService
+
+        extend Pact::DSL
+
+        attr_accessor :port, :host, :standalone, :verify, :provider_name, :consumer_name, :pact_specification_version
+
+        def initialize name, consumer_name, provider_name
+          @name = name
+          @consumer_name = consumer_name
+          @provider_name = provider_name
+          @port = nil
+          @host = "localhost"
+          @standalone = false
+          @verify = true
+          @pact_specification_version = '2'
+          @finalized = false
+        end
+
+        dsl do
+          def port port
+            self.port = port
+          end
+
+          def host host
+            self.host = host
+          end
+
+          def standalone standalone
+            self.standalone = standalone
+          end
+
+          def verify verify
+            self.verify = verify
+          end
+
+          def pact_specification_version pact_specification_version
+            self.pact_specification_version = pact_specification_version
+          end
+        end
+
+        def finalize
+          raise 'Already finalized!' if @finalized
+          register_mock_service
+          configure_consumer_contract_builder
+          @finalized = true
+        end
+
+        private
+
+        def register_mock_service
+          unless standalone
+            url = "http://#{host}#{port.nil? ? '' : ":#{port}"}"
+            ret = Pact::MockService::AppManager.instance.register_mock_service_for(provider_name, url, mock_service_options)
+            raise "pact-mock_service(v#{Pact::MockService::VERSION}) does not support 'find available port' feature" unless ret
+            @port = ret
+          end
+        end
+
+        def configure_consumer_contract_builder
+          consumer_contract_builder = create_consumer_contract_builder
+          create_consumer_contract_builders_method consumer_contract_builder
+          setup_verification(consumer_contract_builder) if verify
+          consumer_contract_builder
+        end
+
+        def create_consumer_contract_builder
+          consumer_contract_builder_fields = {
+            :consumer_name => consumer_name,
+            :provider_name => provider_name,
+            :pactfile_write_mode => Pact.configuration.pactfile_write_mode,
+            :port => port,
+            :host => host,
+            :pact_dir => Pact.configuration.pact_dir
+          }
+          Pact::Consumer::ConsumerContractBuilder.new consumer_contract_builder_fields
+        end
+
+        def setup_verification consumer_contract_builder
+          Pact.configuration.add_provider_verification do | example_description |
+            consumer_contract_builder.verify example_description
+          end
+        end
+
+         # This makes the consumer_contract_builder available via a module method with the given identifier
+         # as the method name.
+         # I feel this should be defined somewhere else, but I'm not sure where
+        def create_consumer_contract_builders_method consumer_contract_builder
+          Pact::Consumer::ConsumerContractBuilders.send(:define_method, @name.to_sym) do
+            consumer_contract_builder
+          end
+          Pact.consumer_world.add_consumer_contract_builder consumer_contract_builder
+        end
+
+        def mock_service_options
+          {
+            pact_specification_version: pact_specification_version,
+            find_available_port: port.nil?,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/service_consumer.rb

@@ -0,0 +1,51 @@
+require 'pact/shared/dsl'
+
+module Pact
+  module Consumer
+    module Configuration
+      class ServiceConsumer
+
+        extend Pact::DSL
+
+        attr_accessor :app, :port, :name
+
+        def initialize name
+          @name = name
+          @app = nil
+          @port = nil
+        end
+
+        dsl do
+          def app app
+            self.app = app
+          end
+
+          def port port
+            self.port = port
+          end
+
+          def has_pact_with service_provider_name, &block
+            ServiceProvider.build(service_provider_name, name, &block)
+          end
+        end
+
+        def finalize
+          validate
+          register_consumer_app if @app
+        end
+
+        private
+
+        def validate
+          raise "Please provide a consumer name" unless (name && !name.empty?)
+          raise "Please provide a port for the consumer app" if app && !port
+        end
+
+
+        def register_consumer_app
+          Pact::MockService::AppManager.instance.register app, port
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/service_provider.rb

@@ -0,0 +1,40 @@
+require 'pact/shared/dsl'
+require 'pact/consumer/configuration/mock_service'
+
+module Pact
+  module Consumer
+    module Configuration
+      class ServiceProvider
+
+        extend Pact::DSL
+
+        attr_accessor :service, :consumer_name, :name
+
+        def initialize name, consumer_name
+          @name = name
+          @service = nil
+          @consumer_name = consumer_name
+        end
+
+        dsl do
+          def mock_service name, &block
+            self.service = MockService.build(name, consumer_name, self.name, &block)
+          end
+        end
+
+        def finalize
+          validate
+        end
+
+        private
+
+        def validate
+          raise "Please configure a service for #{name}" unless service
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/pact/consumer/configuration.rb

@@ -0,0 +1,10 @@
+require 'pact/configuration'
+require 'pact/consumer/consumer_contract_builders'
+require 'pact/consumer/consumer_contract_builder'
+require 'pact/consumer/configuration/service_consumer'
+require 'pact/consumer/configuration/service_provider'
+require 'pact/consumer/configuration/dsl'
+require 'pact/consumer/configuration/configuration_extensions'
+
+Pact.send(:extend, Pact::Consumer::DSL)
+Pact::Configuration.send(:include, Pact::Consumer::Configuration::ConfigurationExtensions)

data/lib/pact/consumer/consumer_contract_builder.rb

@@ -0,0 +1,82 @@
+require 'uri'
+require 'json/add/regexp'
+require 'pact/logging'
+require 'pact/mock_service/client'
+require 'pact/consumer/interaction_builder'
+
+module Pact
+  module Consumer
+
+    class ConsumerContractBuilder
+
+      include Pact::Logging
+
+      attr_reader :mock_service_base_url
+
+      def initialize(attributes)
+        @interaction_builder = nil
+        @consumer_contract_details = {
+          consumer: {name: attributes[:consumer_name]},
+          provider: {name: attributes[:provider_name]},
+          pactfile_write_mode: attributes[:pactfile_write_mode].to_s,
+          pact_dir: attributes.fetch(:pact_dir)
+        }
+        @mock_service_client = Pact::MockService::Client.new(attributes[:port], attributes[:host])
+        @mock_service_base_url = "http://#{attributes[:host]}:#{attributes[:port]}"
+      end
+
+      def without_writing_to_pact
+        interaction_builder.without_writing_to_pact
+      end
+
+      def given(provider_state)
+        interaction_builder.given(provider_state)
+      end
+
+      def upon_receiving(description)
+        interaction_builder.upon_receiving(description)
+      end
+
+      def verify example_description
+        mock_service_client.verify example_description
+      end
+
+      def log msg
+        mock_service_client.log msg
+      end
+
+      def write_pact
+        mock_service_client.write_pact @consumer_contract_details
+      end
+
+      def wait_for_interactions options = {}
+        wait_max_seconds = options.fetch(:wait_max_seconds, 3)
+        poll_interval = options.fetch(:poll_interval, 0.1)
+        mock_service_client.wait_for_interactions wait_max_seconds, poll_interval
+      end
+
+      # @raise Pact::InvalidInteractionError
+      def handle_interaction_fully_defined interaction
+        interaction.validate!
+        mock_service_client.add_expected_interaction interaction #TODO: What will happen if duplicate added?
+        self.interaction_builder = nil
+      end
+
+      private
+
+      attr_reader :mock_service_client
+      attr_writer :interaction_builder
+
+      def interaction_builder
+        @interaction_builder ||=
+        begin
+          interaction_builder = InteractionBuilder.new do | interaction |
+            handle_interaction_fully_defined(interaction)
+          end
+          interaction_builder
+        end
+      end
+
+    end
+  end
+end

data/lib/pact/consumer/consumer_contract_builders.rb

@@ -0,0 +1,10 @@
+module Pact
+  module Consumer
+    module ConsumerContractBuilders
+      # Placeholder for mock service methods which will be dynamically created
+      # from the Pact configuration.
+
+      # To be included in RSpec
+    end
+  end
+end

data/lib/pact/consumer/interaction_builder.rb

@@ -0,0 +1,45 @@
+require 'net/http'
+require 'pact/reification'
+require 'pact/consumer_contract/interaction'
+
+module Pact
+  module Consumer
+    class InteractionBuilder
+
+      attr_reader :interaction
+
+      def initialize &block
+        @interaction = Interaction.new
+        @callback = block
+      end
+
+      def without_writing_to_pact
+        interaction.metadata ||= {}
+        interaction.metadata[:write_to_pact] = false
+        self
+      end
+
+      def upon_receiving description
+        @interaction.description = description
+        self
+      end
+
+      def given provider_state
+        @interaction.provider_state = provider_state.nil? ? nil : provider_state.to_s
+        self
+      end
+
+      def with(request_details)
+        interaction.request = Pact::Request::Expected.from_hash(request_details)
+        self
+      end
+
+      def will_respond_with(response)
+        interaction.response = Pact::Response.new(response)
+        @callback.call interaction
+        self
+      end
+
+    end
+  end
+end