pact-mock_service 0.0.1

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

@@ -0,0 +1,68 @@
+require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+
+module Pact
+  module Consumer
+    class VerificationGet < MockServiceAdministrationEndpoint
+
+      include RackRequestHelper
+      attr_accessor :interaction_list, :log_description
+
+      def initialize name, logger, interaction_list, log_description
+        super name, logger
+        @interaction_list = interaction_list
+        @log_description = log_description
+      end
+
+      def request_path
+        '/interactions/verification'
+      end
+
+      def request_method
+        'GET'
+      end
+
+      def respond env
+        if interaction_list.all_matched?
+          logger.info "Verifying - interactions matched for example \"#{example_description(env)}\""
+          [200, {'Content-Type' => 'text/plain'}, ['Interactions matched']]
+        else
+          error_message = FailureMessage.new(interaction_list).to_s
+          logger.warn "Verifying - actual interactions do not match expected interactions for example \"#{example_description(env)}\". \n#{error_message}"
+          logger.warn error_message
+          [500, {'Content-Type' => 'text/plain'}, ["Actual interactions do not match expected interactions for mock #{name}.\n\n#{error_message}See #{log_description} for details."]]
+        end
+      end
+
+      def example_description env
+        params_hash(env)['example_description']
+      end
+
+      class FailureMessage
+
+        def initialize interaction_list
+          @interaction_list = interaction_list
+        end
+
+        def to_s
+          titles_and_summaries.collect do | title, summaries |
+            "#{title}:\n\t#{summaries.join("\n\t")}\n\n" if summaries.any?
+          end.compact.join
+
+        end
+
+        private
+
+        attr_reader :interaction_list
+
+        def titles_and_summaries
+          {
+            "Incorrect requests" => interaction_list.interaction_mismatches_summaries,
+            "Missing requests" => interaction_list.missing_interactions_summaries,
+            "Unexpected requests" => interaction_list.unexpected_requests_summaries,
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/consumer/mock_service.rb

@@ -0,0 +1,2 @@
+require 'pact/consumer/mock_service/app'
+

data/lib/pact/consumer/mock_service_client.rb

@@ -0,0 +1,65 @@
+require 'net/http'
+require 'pact/consumer/mock_service_interaction_expectation'
+
+module Pact
+  module Consumer
+    class MockServiceClient
+
+      MOCK_SERVICE_ADMINISTRATON_HEADERS = {'X-Pact-Mock-Service' => 'true'}
+
+      def initialize port
+        @http = Net::HTTP.new('localhost', port)
+      end
+
+      def verify example_description
+        response = http.request_get("/interactions/verification?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
+      end
+
+      def log msg
+        http.request_get("/log?msg=#{URI.encode(msg)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def wait_for_interactions wait_max_seconds, poll_interval
+        wait_until_true(wait_max_seconds, poll_interval) do
+          response = http.request_get("/interactions/missing", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+          JSON.parse(response.body)['size'] == 0
+        end
+      end
+
+      def clear_interactions example_description
+        http.delete("/interactions?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def add_expected_interaction interaction
+        response = http.request_post('/interactions', MockServiceInteractionExpectation.new(interaction).to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
+        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
+      end
+
+      def self.clear_interactions port, example_description
+        Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def write_pact pacticipant_details
+        response = http.request_post("/pact", pacticipant_details.to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
+        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
+        response.body
+      end
+
+      private
+
+      attr_reader :http
+
+      #todo: in need a better home (where can we move it?)
+      def wait_until_true timeout=3, interval=0.1
+        time_limit = Time.now + timeout
+        loop do
+          result =  yield
+          return if result || Time.now >= time_limit
+          sleep interval
+        end
+      end
+
+    end
+  end
+end

data/lib/pact/consumer/mock_service_interaction_expectation.rb

@@ -0,0 +1,37 @@
+require 'pact/reification'
+
+# Represents the Interaction in the form required by the MockService
+# The json generated will be posted to the MockService to register the expectation
+module Pact
+  module Consumer
+    class MockServiceInteractionExpectation
+
+
+      def initialize interaction
+        @interaction = interaction
+      end
+
+      def to_hash
+        hash = {:description => interaction.description}
+        hash[:provider_state] = interaction.provider_state if interaction.provider_state
+        options = interaction.request.options.empty? ? {} : { options: interaction.request.options}
+        hash[:request] = interaction.request.as_json.merge(options)
+        hash[:response] = interaction.response
+        hash
+      end
+
+      def as_json options = {}
+        to_hash
+      end
+
+      def to_json opts = {}
+        as_json.to_json(opts)
+      end
+
+      private
+
+      attr_reader :interaction
+
+    end
+  end
+end

data/lib/pact/consumer/request.rb

@@ -0,0 +1,27 @@
+require 'pact/shared/request'
+require 'pact/shared/key_not_found'
+
+module Pact
+  module Consumer
+    module Request
+      class Actual < Pact::Request::Base
+
+        def self.from_hash(hash)
+          sym_hash = symbolize_keys hash
+          method = sym_hash.fetch(:method)
+          path = sym_hash.fetch(:path)
+          query = sym_hash.fetch(:query)
+          headers = sym_hash.fetch(:headers)
+          body = sym_hash.fetch(:body, nil)
+          new(method, path, headers, body, query)
+        end
+
+        protected
+
+        def self.key_not_found
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/server.rb

@@ -0,0 +1,90 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+
+# Copied shamelessly from Capybara
+module Pact
+  class Server
+    class Middleware
+      attr_accessor :error
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == "/__identify__"
+          [200, {}, [@app.object_id.to_s]]
+        else
+          begin
+            @app.call(env)
+          rescue StandardError => e
+            @error = e unless @error
+            raise e
+          end
+        end
+      end
+    end
+
+    class << self
+      def ports
+        @ports ||= {}
+      end
+    end
+
+    attr_reader :app, :port
+
+    def initialize(app, port)
+      @app = app
+      @middleware = Middleware.new(@app)
+      @server_thread = nil # supress warnings
+      @port = port
+    end
+
+    def reset_error!
+      @middleware.error = nil
+    end
+
+    def error
+      @middleware.error
+    end
+
+    def host
+      "localhost"
+    end
+
+    def responsive?
+      return false if @server_thread && @server_thread.join(0)
+
+      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
+
+      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+        return res.body == @app.object_id.to_s
+      end
+    rescue SystemCallError
+      return false
+    end
+
+    def run_default_server(app, port)
+      require 'rack/handler/webrick'
+      Rack::Handler::WEBrick.run(app, :Port => port, :AccessLog => [], :Logger => WEBrick::Log::new(nil, 0))
+    end
+
+    def boot
+      unless responsive?
+        Pact::Server.ports[@app.object_id] = @port
+
+        @server_thread = Thread.new do
+          run_default_server(@middleware, @port)
+        end
+
+        Timeout.timeout(60) { @server_thread.join(0.1) until responsive? }
+      end
+    rescue Timeout::Error
+      raise "Rack application timed out during boot"
+    else
+      self
+    end
+
+  end
+end

data/lib/pact/consumer_contract/consumer_contract_writer.rb

@@ -0,0 +1,84 @@
+require 'pact/consumer_contract'
+require 'pact/consumer/interactions_filter'
+require 'pact/consumer_contract/file_name'
+
+module Pact
+
+  class ConsumerContractWriter
+
+    attr_reader :consumer_contract_details, :pactfile_write_mode, :interactions, :logger
+
+    def initialize consumer_contract_details, logger
+      @logger = logger
+      @consumer_contract_details = consumer_contract_details
+      @pactfile_write_mode = consumer_contract_details.fetch(:pactfile_write_mode, :overwrite).to_sym
+      @interactions = consumer_contract_details.fetch(:interactions)
+    end
+
+    def consumer_contract
+      @consumer_contract ||= Pact::ConsumerContract.new(
+        consumer: ServiceConsumer.new(name: consumer_contract_details[:consumer][:name]),
+        provider: ServiceProvider.new(name: consumer_contract_details[:provider][:name]),
+        interactions: interactions_for_new_consumer_contract)
+    end
+
+    def write
+      consumer_contract.update_pactfile
+      consumer_contract.to_json
+    end
+
+    def interactions_for_new_consumer_contract
+      if pactfile_write_mode == :update
+        merged_interactions = existing_interactions
+        filter = Consumer::UpdatableInteractionsFilter.new(merged_interactions)
+        interactions.each {|i| filter << i }
+        merged_interactions
+      else
+        interactions
+      end
+    end
+
+    def existing_interactions
+      interactions = []
+      if pactfile_exists?
+        begin
+          interactions = existing_consumer_contract.interactions
+          info_and_puts "*****************************************************************************"
+          info_and_puts "Updating existing file .#{pactfile_path.gsub(Dir.pwd, '')} as config.pactfile_write_mode is :update"
+          info_and_puts "Only interactions defined in this test run will be updated."
+          info_and_puts "As interactions are identified by description and provider state, pleased note that if either of these have changed, the old interactions won't be removed from the pact file until the specs are next run with :pactfile_write_mode => :overwrite."
+          info_and_puts "*****************************************************************************"
+        rescue StandardError => e
+          warn_and_stderr "Could not load existing consumer contract from #{pactfile_path} due to #{e}"
+          logger.error e
+          logger.error e.backtrace
+          warn_and_stderr "Creating a new file."
+        end
+      end
+      interactions
+    end
+
+    def pactfile_exists?
+      File.exist?(pactfile_path)
+    end
+
+    def pactfile_path
+      Pact::FileName.file_path consumer_contract_details[:consumer][:name], consumer_contract_details[:provider][:name]
+    end
+
+    def existing_consumer_contract
+      Pact::ConsumerContract.from_uri(pactfile_path)
+    end
+
+    def warn_and_stderr msg
+      Pact.configuration.error_stream.puts msg
+      logger.warn msg
+    end
+
+    def info_and_puts msg
+      $stdout.puts msg
+      logger.info msg
+    end
+  end
+
+end

data/lib/pact/mock_service/cli.rb

@@ -0,0 +1,49 @@
+require 'find_a_port'
+require 'thor'
+require 'thwait'
+require 'rack/handler/webrick'
+
+# TODO rename CLI so as not to clash
+
+module Pact
+  module MockService
+    class CLI < Thor
+
+      desc 'service', "Start 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
+        RunStandaloneMockService.call(options)
+      end
+
+      default_task :service
+
+      private
+
+      def log message
+        puts message unless options[:quiet]
+      end
+    end
+
+    class RunStandaloneMockService
+
+      def self.call options
+        require 'pact/consumer/mock_service/app'
+        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 = Pact::Consumer::MockService.new(service_options)
+        trap(:INT) { Rack::Handler::WEBrick.shutdown }
+        Rack::Handler::WEBrick.run(mock_service, :Port => port, :AccessLog => [])
+      end
+    end
+
+  end
+end

data/lib/pact/mock_service/version.rb

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

data/lib/pact/mock_service.rb

@@ -0,0 +1 @@
+require 'pact/consumer/mock_service'

data/pact-mock-service.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pact/mock_service/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pact-mock_service"
+  gem.version       = Pact::MockService::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{Provides a mock service for use with Pact}
+  gem.homepage      = "https://github.com/bethesque/pact-mock_service"
+
+  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 'rack'
+  gem.add_runtime_dependency 'rspec', '>=2.14'
+  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'
+  gem.add_runtime_dependency 'thor'
+  gem.add_runtime_dependency 'json' #Not locking down a version because buncher gem requires 1.6, while other projects use 1.7.
+  gem.add_runtime_dependency 'webrick'
+  gem.add_runtime_dependency 'term-ansicolor', '~> 1.0'
+
+  unless ENV['X_PACT_DEVELOPMENT']
+    gem.add_runtime_dependency 'pact-support', '~> 0.0.1'
+  end
+
+  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'
+  gem.add_development_dependency 'faraday'
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'pact/consumer/app_manager'
+
+module Pact::Consumer
+  describe AppManager do
+    before do
+      AppManager.instance.clear_all
+    end
+
+    describe "start_service_for" do
+      before do
+        allow_any_instance_of(AppRegistration).to receive(:spawn) # Don't want process actually spawning during the tests
+      end
+      let(:name) { 'some_service'}
+      context "for http://localhost" do
+        let(:url) { 'http://localhost:1234'}
+        it "starts a mock service at the given port on localhost" do
+          expect_any_instance_of(AppRegistration).to receive(:spawn)
+          AppManager.instance.register_mock_service_for name, url
+          AppManager.instance.spawn_all
+        end
+
+        it "registers the mock service as running on the given port" do
+          AppManager.instance.register_mock_service_for name, url
+          expect(AppManager.instance.app_registered_on?(1234)).to eq true
+        end
+      end
+      context "for https://" do
+        let(:url) { 'https://localhost:1234'}
+        it "should throw an unsupported error" do
+          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only http is supported"
+        end
+      end
+      context "for a host other than localhost" do
+        let(:url) { 'http://aserver:1234'}
+        it "should throw an unsupported error" do
+          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only services on localhost are supported"
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer/mock_service/app_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'rack/test'
+require 'tempfile'
+
+module Pact
+  module Consumer
+
+    describe MockService do
+
+      include Rack::Test::Methods
+
+      def app
+        MockService.new(log_file: temp_file)
+      end
+
+      let(:temp_file) { Tempfile.new('log') }
+
+      after do
+        temp_file.close
+        temp_file.unlink
+      end
+
+      context "when a StandardError is encountered" do
+        let(:response) { JSON.parse(last_response.body)}
+        let(:interaction_replay) { double(InteractionReplay, :match? => true)}
+
+        before do
+          expect(InteractionReplay).to receive(:new).and_return(interaction_replay)
+          expect(interaction_replay).to receive(:respond).and_raise("an error")
+        end
+
+        subject { get "/" }
+
+        it "returns a json error" do
+          subject
+          expect(last_response.content_type).to eq 'application/json'
+        end
+
+        it "includes the error message" do
+          subject
+          expect(response['message']).to eq "an error"
+        end
+
+        it "includes the backtrace" do
+          subject
+          expect(response['backtrace']).to be_instance_of Array
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/pact/consumer/mock_service/interaction_list_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'pact/consumer/mock_service/interaction_list'
+
+module Pact::Consumer
+
+  describe InteractionList do
+    shared_context "unexpected requests and missed interactions" do
+      let(:expected_interaction) { InteractionFactory.create }
+      let(:unexpected_request) { RequestFactory.create_actual method: 'put' }
+      let(:candidate_interaction) { double("Pact::Interaction") }
+      let(:candidate_interactions) { [candidate_interaction] }
+      let(:interaction_mismatch) { instance_double("Pact::Consumer::InteractionMismatch", :short_summary => 'blah', :candidate_interactions => candidate_interactions)}
+      subject {
+        interactionList = InteractionList.new
+        interactionList.add expected_interaction
+        interactionList.register_unexpected_request unexpected_request
+        interactionList.register_interaction_mismatch interaction_mismatch
+        interactionList
+       }
+    end
+
+    shared_context "no unexpected requests or missed interactions exist" do
+      let(:expected_interaction) { InteractionFactory.create }
+      subject {
+        interactionList = InteractionList.new
+        interactionList.add expected_interaction
+        interactionList.register_matched expected_interaction
+        interactionList
+       }
+    end
+
+    describe "interaction_diffs" do
+      context "when unexpected requests and missed interactions exist" do
+        include_context "unexpected requests and missed interactions"
+        let(:expected_diff) {
+          {:missing_interactions=>["GET /path"],
+            :unexpected_requests=>["PUT /path?query"],
+            :interaction_mismatches => ['blah']}
+        }
+        it "returns the unexpected requests and missed interactions" do
+          expect(subject.interaction_diffs).to eq expected_diff
+        end
+      end
+
+      context "when no unexpected requests or missed interactions exist" do
+        include_context "no unexpected requests or missed interactions exist"
+        let(:expected_diff) {
+          {}
+        }
+        it "returns an empty hash" do
+          expect(subject.interaction_diffs).to eq expected_diff
+        end
+      end
+    end
+
+    describe "all_matched?" do
+      context "when unexpected requests or missed interactions exist" do
+        include_context "unexpected requests and missed interactions"
+        it "returns false" do
+          expect(subject.all_matched?).to be false
+        end
+      end
+      context "when unexpected requests or missed interactions do not exist" do
+        include_context "no unexpected requests or missed interactions exist"
+        it "returns false" do
+          expect(subject.all_matched?).to be true
+        end
+      end
+    end
+
+    describe "missing_interactions_summaries" do
+      include_context "unexpected requests and missed interactions"
+      it "returns a list of the method and paths for each missing interaction" do
+        expect(subject.missing_interactions_summaries).to eq ["GET /path"]
+      end
+    end
+  end
+end