pact 0.1.28 → 1.3.3

data/lib/pact/app.rb

@@ -1,32 +0,0 @@
-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/consumer/configuration_dsl.rb

@@ -1,71 +0,0 @@
-require_relative 'service_consumer'
-require_relative 'consumer_contract_builders'
-require_relative '../configuration'
-
-module Pact
-  module Consumer
-
-
-    module Configuration
-      def add_producer_verification &block
-        producer_verifications << block
-      end
-      def producer_verifications
-        @producer_verifications ||= []
-      end
-    end
-
-    module ConfigurationDSL
-
-      def consumer &block
-        if block_given?
-          @consumer = ConsumerDSL.new(&block).create_service_consumer
-        elsif @consumer
-          @consumer
-        else
-          raise "Please configure a consumer before configuring producers"
-        end
-      end
-
-      class ConsumerDSL
-
-        def initialize &block
-          @app = nil
-          @port = nil
-          @name = nil
-          instance_eval(&block)
-        end
-
-        def validate
-          raise "Please provide a consumer name" unless @name
-          raise "Please provide a port for the consumer app" if @app && !@port
-        end
-
-        def name name
-          @name = name
-        end
-
-        def app app
-          @app = app
-        end
-
-        def port port
-          @port = port
-        end
-
-        def create_service_consumer
-          validate
-          register_consumer_app if @app
-          Pact::Consumer::ServiceConsumer.new name: @name
-        end
-
-        def register_consumer_app
-          Pact::Consumer::AppManager.instance.register @app, @port
-        end
-      end
-    end
-  end
-end
-
-Pact::Configuration.send(:include, Pact::Consumer::ConfigurationDSL)
-Pact::Configuration.send(:include, Pact::Consumer::Configuration)

data/lib/pact/consumer/dsl.rb

@@ -1,98 +0,0 @@
-require_relative 'consumer_contract_builders'
-
-module Pact::Consumer
-   module DSL
-      def with_producer name, &block
-         Producer.new(name, &block).create_consumer_contract_builder
-      end
-
-      class Producer
-         def initialize name, &block
-            @name = name
-            @service = nil
-            instance_eval(&block)
-         end
-
-         def service name, &block
-            @service = Service.new(name, &block)
-         end
-
-         alias_method :mock_service, :service
-
-        def create_consumer_contract_builder
-          validate
-          consumer_contract_builder_from_attributes
-        end
-
-        def validate
-          raise "Please configure a service for #{@name}" unless @service
-        end
-
-        def consumer_contract_builder_from_attributes
-          consumer_contract_builder_fields = {
-            :consumer_name => Pact.configuration.consumer.name,
-            :producer_name => @name,
-            :pactfile_write_mode => Pact.configuration.pactfile_write_mode
-            }
-          @service.configure_consumer_contract_builder consumer_contract_builder_fields
-        end
-      end
-
-      class Service
-         def initialize name, &block
-            @name = name
-            @port = nil
-            @standalone = false
-            @verify = false
-            instance_eval(&block)
-         end
-
-         def port port
-            @port = port
-         end
-
-         def standalone standalone
-            @standalone = standalone
-         end
-
-         def verify verify
-            @verify = verify
-         end
-
-         def configure_consumer_contract_builder consumer_contract_builder_fields
-            validate
-            unless @standalone
-              AppManager.instance.register_mock_service_for consumer_contract_builder_fields[:producer_name], "http://localhost:#{@port}"
-            end
-            consumer_contract_builder = Pact::Consumer::ConsumerContractBuilder.new consumer_contract_builder_fields.merge({port: @port})
-            create_mock_services_module_method consumer_contract_builder
-            setup_verification(consumer_contract_builder) if @verify
-            consumer_contract_builder
-         end
-
-
-        def setup_verification consumer_contract_builder
-          Pact.configuration.add_producer_verification do | example_description |
-            consumer_contract_builder.verify example_description
-          end
-        end
-
-         private
-
-         # 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_mock_services_module_method consumer_contract_builder
-           Pact::Consumer::ConsumerContractBuilders.send(:define_method, @name.to_sym) do
-             consumer_contract_builder
-           end
-         end
-
-         def validate
-            raise "Please provide a port for service #{@name}" unless @port
-         end
-      end
-   end
-end
-
-Pact.send(:extend, Pact::Consumer::DSL)

data/lib/pact/consumer/interaction.rb

@@ -1,70 +0,0 @@
-require 'net/http'
-require 'pact/reification'
-require 'pact/request'
-#require 'json/add/core'
-
-module Pact
-  module Consumer
-
-    class Interaction
-
-      attr_accessor :description, :request, :response, :producer_state
-
-      def initialize options
-        @description = options[:description]
-        @request = options[:request]
-        @response = options[:response]
-        @producer_state = options[:producer_state]
-      end
-
-      def self.from_hash options
-        new(:description => options['description'],
-            :producer_state => options['producer_state'],
-            :request => Pact::Request::Expected.from_hash(options['request']),
-            :response => options['response']
-          )
-      end
-
-      def as_json
-        {
-          :description => @description,
-          :request => @request.as_json,
-          :response => @response,
-        }.tap{ | hash | hash[:producer_state] = @producer_state if @producer_state }
-      end
-
-      def to_json(options = {})
-        as_json.to_json(options)
-      end
-
-
-      def to_json_with_generated_response
-        as_json.tap { | hash | hash[:response] = Reification.from_term(response) }.to_json
-      end
-    end
-
-    class InteractionBuilder
-
-      attr_reader :interaction
-
-      def initialize(description, producer_state)
-        producer_state = producer_state.nil? ? nil : producer_state.to_s
-        @interaction = Interaction.new(:description => description, :producer_state => producer_state)
-      end
-
-      def with(request_details)
-        interaction.request = Request::Expected.from_hash(request_details)
-        self
-      end
-
-      def will_respond_with(response)
-        interaction.response = response
-        @callback.call interaction
-      end
-
-      def on_interaction_fully_defined &block
-        @callback = block
-      end
-    end
-  end
-end

data/lib/pact/consumer/run_condor.rb

@@ -1,4 +0,0 @@
-require_relative 'spawn_app'
-require_relative '../../../boot'
-
-spawn_app CondorAppAssets.new, APP_PORT

data/lib/pact/consumer/run_mock_contract_service.rb

@@ -1,13 +0,0 @@
-require 'net/http'
-require_relative 'spawn_app'
-require_relative 'mock_service'
-
-spawn_app MockService.new, 1234
-
-RSpec.configure do |c|
-  c.before(:each, :type => :feature) do
-    http = Net::HTTP.new('localhost', 1234)
-    request = Net::HTTP::Delete.new('/interactions')
-    response = http.request(request)
-  end
-end

data/lib/pact/consumer/service_consumer.rb

@@ -1,22 +0,0 @@
-module Pact
-  module Consumer
-    class ServiceConsumer
-      attr_accessor :name
-      def initialize options
-        @name = options[:name]
-      end
-
-      def to_s
-        name
-      end
-
-      def as_json options = {}
-        {name: name}
-      end
-
-      def self.from_hash obj
-        ServiceConsumer.new(:name => obj['name'])
-      end
-    end
-  end
-end

data/lib/pact/consumer/service_producer.rb

@@ -1,23 +0,0 @@
-module Pact
-  module Consumer
-    # This is a crap name, it's really just a object for serializing to JSON
-    class ServiceProducer
-      attr_accessor :name
-      def initialize options
-        @name = options[:name] || '[producer name unknown - please update the pact gem in the consumer project to the latest version and regenerate the pacts]'
-      end
-
-      def to_s
-        name
-      end
-
-      def as_json options = {}
-        {name: name}
-      end
-
-      def self.from_hash obj
-        ServiceProducer.new(:name => obj['name'])
-      end
-    end
-  end
-end

data/lib/pact/json_warning.rb

@@ -1,23 +0,0 @@
-require 'logger'
-require 'json/add/regexp'
-
-module Pact
-  module JsonWarning
-    def check_for_active_support_json
-      # Active support clobbers the as_json methods defined in the json/add directory of the json gem.
-      # These methods are required to serialize and deserialize the Regexp and Symbol classes properly.
-      # You can potentially fix this by making sure the json gem is required AFTER the active_support/json gem
-      # OR if you don't use the json part of activesupport you could only require the parts of active support you really need
-      # OR you can only use strings in your pacts.
-      # Good luck.
-
-      # If someone knows how to make sure the pact gem uses the json gem as_json methods when activesupport/json is used in the calling code,
-      # without breaking the calling code, which may depend on activesupport/json... then please fix this.
-      # Note: we can probably do this in Ruby 2.0 with refinements, but for now, we're all stuck on 1.9 :(
-
-      unless Regexp.new('').as_json.is_a?(Hash)
-        Logger.new($stderr).warn("It appears you are using ActiveSupport json in your project. You are now in rubygems hell. Please see Pact::JsonWarning for more info.")
-      end
-    end
-  end
-end

data/lib/pact/producer/configuration_dsl.rb

@@ -1,62 +0,0 @@
-require 'ostruct'
-
-
-module Pact
-  module Producer
-    module ConfigurationDSL
-
-      def producer &block
-        @producer ||= nil
-        if block_given?
-          @producer = ProducerDSL.new(&block).create_producer_config
-        elsif @producer
-          @producer
-        else
-          raise "Please configure your producer. See the Producer section in the README for examples."
-        end
-      end
-
-      class ProducerConfig
-        attr_accessor :name
-
-        def initialize name, &app_block
-          @name = name
-          @app_block = app_block
-        end
-
-        def app
-          @app_block.call
-        end
-      end
-
-      class ProducerDSL
-
-        def initialize &block
-          @app = nil
-          @name = nil
-          instance_eval(&block)
-        end
-
-        def validate
-          raise "Please provide a name for the Producer" unless @name
-          raise "Please configure an app for the Producer" unless @app_block
-        end
-
-        def name name
-          @name = name
-        end
-
-        def app &block
-          @app_block = block
-        end
-
-        def create_producer_config
-          validate
-          ProducerConfig.new(@name, &@app_block)
-        end
-      end
-    end
-  end
-end
-
-Pact::Configuration.send(:include, Pact::Producer::ConfigurationDSL)

data/lib/pact/producer/matchers.rb

@@ -1,22 +0,0 @@
-require 'pact/term'
-require 'awesome_print'
-require 'pact/matchers'
-require 'awesome_print'
-
-RSpec::Matchers.define :match_term do |expected|
-  include Pact::Matchers
-
-  match do |actual|
-    if (difference = diff(expected, actual)).any?
-      @message = difference
-      false
-    else
-      true
-    end
-  end
-
-  failure_message_for_should do | actual |
-    @message.ai
-  end
-
-end

data/lib/pact/producer/pact_spec_runner.rb

@@ -1,57 +0,0 @@
-require 'open-uri'
-require 'rspec'
-require 'rspec/core'
-require 'rspec/core/formatters/documentation_formatter'
-require_relative 'rspec'
-
-module Pact
-	module Producer
-		class PactSpecRunner
-
-			extend Pact::Producer::RSpec::ClassMethods
-
-			def self.run(spec_definitions, options = {})
-				initialize_specs spec_definitions
-				configure_rspec options
-				run_specs
-			end
-
-			private
-
-			def self.initialize_specs spec_definitions
-				spec_definitions.each do | spec_definition |
-					require spec_definition[:support_file] if spec_definition[:support_file]
-					options = {consumer: spec_definition[:consumer], save_pactfile_to_tmp: true}
-					honour_pactfile spec_definition[:uri], options
-				end
-			end
-
-			def self.configure_rspec options
-				config = ::RSpec.configuration
-				config.color = true
-
-				unless options[:silent]
-					config.error_stream = $stderr
-					config.output_stream = $stdout
-				end
-
-				formatter = ::RSpec::Core::Formatters::DocumentationFormatter.new(config.output)
-				reporter =  ::RSpec::Core::Reporter.new(formatter)
-				config.instance_variable_set(:@reporter, reporter)
-			end
-
-			def self.run_specs
-				config = ::RSpec.configuration
-				world = ::RSpec::world
-				config.reporter.report(world.example_count, nil) do |reporter|
-				  begin
-				    config.run_hook(:before, :suite)
-				    world.example_groups.ordered.map {|g| g.run(reporter)}.all? ? 0 : config.failure_exit_code
-				  ensure
-				    config.run_hook(:after, :suite)
-				  end
-				end
-			end
-		end
-	end
-end

data/lib/pact/producer/producer_state.rb

@@ -1,81 +0,0 @@
-module Pact
-  module Producer
-
-    module DSL
-      def producer_state name, &block
-        ProducerState.producer_state(name, &block).register
-      end
-
-      def with_consumer name, &block
-        ProducerState.current_namespaces << name
-        instance_eval(&block)
-        ProducerState.current_namespaces.pop
-      end
-    end
-
-    class ProducerState
-
-      attr_accessor :name
-      attr_accessor :namespace
-
-      def self.producer_state name, &block
-        ProducerState.new(name, current_namespaces.join('.'), &block)
-      end
-
-      def self.register name, producer_state
-        producer_states[name] = producer_state
-      end
-
-      def self.producer_states
-        @@producer_states ||= {}
-      end
-
-      def self.current_namespaces
-        @@current_namespaces ||= []
-      end
-
-      def self.get name, options = {}
-        fullname = options[:for] ? "#{options[:for]}.#{name}" : name
-        (producer_states[fullname] || producer_states[fullname.to_sym]) || producer_states[name]
-      end
-
-      def register
-        self.class.register(namespaced(name), self)
-      end
-
-      def initialize name, namespace, &block
-        @name = name
-        @namespace = namespace
-        instance_eval(&block)
-      end
-
-      def set_up &block
-        if block_given?
-          @set_up_block = block
-        elsif @set_up_block
-          instance_eval &@set_up_block
-        end
-      end
-
-      def tear_down &block
-        if block_given?
-          @tear_down_block = block
-        elsif @tear_down_block
-          instance_eval &@tear_down_block
-        end
-      end
-
-      private
-
-      def namespaced(name)
-        if namespace.empty?
-          name
-        else
-          "#{namespace}.#{name}"
-        end
-      end
-    end
-  end
-end
-
-Pact.send(:extend, Pact::Producer::DSL)