pacto 0.4.0.rc1 → 0.4.0.rc2

data/lib/pacto/generator/hint.rb

@@ -1,26 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  module Generator
-    class Hint < Pacto::RequestClause
-      property :service_name, required: true
-      property :target_file
-
-      def initialize(data)
-        super
-        self.target_file ||= "#{slugify(service_name)}.json"
-        self
-      end
-
-      def matches?(pacto_request)
-        return false if pacto_request.nil?
-        Pacto::RequestPattern.for(self).matches?(pacto_request)
-      end
-
-      private
-
-      def slugify(path)
-        path.downcase.gsub(' ', '_')
-      end
-    end
-  end
-end

data/lib/pacto/generator/native_contract_generator.rb

@@ -1,74 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'json/schema_generator'
-require 'pacto/contract_builder'
-
-module Pacto
-  module Generator
-    class NativeContractGenerator
-      include Logger
-
-      def initialize(_schema_version = 'draft3',
-        schema_generator = JSON::SchemaGenerator,
-        validator = Pacto::MetaSchema.new,
-        filters = Pacto::Generator::Filters.new,
-        consumer = Pacto::Consumer.new)
-        @contract_builder = ContractBuilder.new(schema_generator: schema_generator, filters: filters)
-        @consumer = consumer
-        @validator = validator
-      end
-
-      def generate(pacto_request, pacto_response)
-        return unless Pacto.generating?
-        logger.debug("Generating Contract for #{pacto_request}, #{pacto_response}")
-        begin
-          contract_file = load_contract_file(pacto_request)
-
-          unless File.exist? contract_file
-            uri = URI(pacto_request.uri)
-            FileUtils.mkdir_p(File.dirname contract_file)
-            raw_contract = save(uri, pacto_request, pacto_response)
-            File.write(contract_file, raw_contract)
-            logger.debug("Generating #{contract_file}")
-
-            Pacto.load_contract contract_file, uri.host
-          end
-        rescue => e
-          raise StandardError, "Error while generating Contract #{contract_file}: #{e.message}", e.backtrace
-        end
-      end
-
-      def generate_from_partial_contract(request_file, host)
-        contract = Pacto.load_contract request_file, host
-        request, response = @consumer.request(contract)
-        save(request_file, request, response)
-      end
-
-      def save(source, request, response)
-        @contract_builder.source = source
-        # TODO: Get rid of the generate_contract call, just use add_example/infer_all
-        @contract_builder.add_example('default', request, response).generate_contract(request, response) # .infer_all
-        @contract_builder.without_examples if Pacto.configuration.generator_options[:no_examples]
-        contract = @contract_builder.build_hash
-        pretty_contract = MultiJson.encode(contract, pretty: true)
-        # This is because of a discrepency w/ jruby vs MRI pretty json
-        pretty_contract.gsub!(/^$\n/, '')
-        @validator.validate pretty_contract
-        pretty_contract
-      end
-
-      private
-
-      def load_contract_file(pacto_request)
-        hint = Pacto::Generator.hint_for(pacto_request)
-        if hint.nil?
-          uri = URI(pacto_request.uri)
-          path = uri.path
-          basename = File.basename(path, '.json') + '.json'
-          File.join(Pacto.configuration.contracts_path, uri.host, File.dirname(path), basename)
-        else
-          File.expand_path(hint.target_file, Pacto.configuration.contracts_path)
-        end
-      end
-    end
-  end
-end

data/lib/pacto/native_contract_factory.rb

@@ -1,60 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  # Builds {Pacto::Contract} instances from Pacto's native Contract format.
-  class NativeContractFactory
-    attr_reader :schema
-
-    def initialize(options = {})
-      @schema = options[:schema] || MetaSchema.new
-    end
-
-    def build_from_file(contract_path, host)
-      contract_definition = File.read(contract_path)
-      definition = JSON.parse(contract_definition)
-      schema.validate definition
-      definition['request'].merge!('host' => host)
-      body_to_schema(definition, 'request', contract_path)
-      body_to_schema(definition, 'response', contract_path)
-      method_to_http_method(definition, contract_path)
-      request = RequestClause.new(definition['request'])
-      response = ResponseClause.new(definition['response'])
-      Contract.new(request: request, response: response, file: contract_path, name: definition['name'], examples: definition['examples'])
-    end
-
-    def files_for(contracts_dir)
-      full_path = Pathname.new(contracts_dir).realpath
-
-      if  full_path.directory?
-        all_json_files = "#{full_path}/**/*.json"
-        Dir.glob(all_json_files).map do |f|
-          Pathname.new(f)
-        end
-      else
-        [full_path]
-      end
-    end
-
-    private
-
-    def body_to_schema(definition, section, file)
-      schema = definition[section].delete 'body'
-      return nil unless schema
-
-      Pacto::UI.deprecation "Contract format deprecation: #{section}:body will be moved to #{section}:schema (#{file})"
-      definition[section]['schema'] = schema
-    end
-
-    def method_to_http_method(definition, file)
-      method = definition['request'].delete 'method'
-      return nil unless method
-
-      Pacto::UI.deprecation "Contract format deprecation: request:method will be moved to request:http_method (#{file})"
-      definition['request']['http_method'] = method
-    end
-  end
-end
-
-factory = Pacto::NativeContractFactory.new
-
-Pacto::ContractFactory.add_factory(:native, factory)
-Pacto::ContractFactory.add_factory(:default, factory)

data/lib/pacto/swagger_contract_factory.rb

@@ -1,90 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'swagger'
-
-module Pacto
-  # Builds {Pacto::Contract} instances from Swagger documents
-  class SwaggerContractFactory
-    include Logger
-
-    def load_hints(contract_path, host = nil)
-      app = Swagger.load(contract_path)
-      app.operations.map do |op|
-        Pacto::Generator::Hint.new(request_clause_hash(op, host).merge(
-          service_name: op.fetch(:summary)
-        ))
-      end
-    end
-
-    def build_from_file(contract_path, host = nil)
-      app = Swagger.load(contract_path)
-      app.operations.map do |op|
-        default_response = op.default_response
-        request = Pacto::RequestClause.new(request_clause_hash(op, host))
-        response = Pacto::ResponseClause.new(response_clause_hash(op, default_response, host))
-        Contract.new(
-          id: op.operationId,
-          name: op.full_name,
-          file: contract_path,
-          request: request, response: response,
-          examples: build_examples(op, default_response)
-        )
-      end
-    rescue ArgumentError => e
-      raise "Could not load #{contract_path}: #{e.message}"
-    end
-
-    def files_for(contracts_dir)
-      full_path = Pathname.new(contracts_dir).realpath
-
-      if  full_path.directory?
-        all_json_files = "#{full_path}/**/*.{json,yaml,yml}"
-        Dir.glob(all_json_files).map do |f|
-          Pathname.new(f)
-        end
-      else
-        [full_path]
-      end
-    end
-
-    private
-
-    def request_clause_hash(op, host)
-      {
-        host: op.host || host,
-        http_method: op.verb,
-        path: op.path
-      }
-    end
-
-    def response_clause_hash(op, response, _host)
-      if response.nil?
-        logger.warn("No response defined for #{op.full_name}")
-        return Pacto::ResponseClause.new(status: 200)
-      end
-
-      {}.tap do | response_clause |
-        response_clause[:status] = response.status_code || 200
-        response_clause[:schema] = response.schema.parse unless response.schema.nil?
-      end
-    end
-
-    def build_examples(op, response)
-      return nil if response.nil? || response.examples.nil? || response.examples.empty?
-
-      {
-        default: {
-          request: {}, # Swagger doesn't have a clear way to capture request examples
-          response: {
-            body: response.examples.values.first.parse
-          }
-        }
-      }
-    rescue => e # FIXME: Only parsing errors?
-      logger.warn("Error while trying to parse response example for #{op.full_name}")
-      logger.debug("  Error details: #{e.inspect}")
-      nil
-    end
-  end
-end
-
-Pacto::ContractFactory.add_factory(:swagger, Pacto::SwaggerContractFactory.new)

data/spec/pacto/dummy_server.rb

@@ -1,4 +0,0 @@
-# -*- encoding : utf-8 -*-
-require_relative 'dummy_server/dummy'
-require_relative 'dummy_server/playback_servlet'
-require_relative 'dummy_server/jruby_workaround_helper'

data/spec/pacto/dummy_server/dummy.rb

@@ -1,51 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'webrick'
-require 'forwardable'
-require 'tempfile'
-
-module Pacto
-  module DummyServer
-    class Servlet < WEBrick::HTTPServlet::AbstractServlet
-      extend Forwardable
-
-      def initialize(server, json)
-        super(server)
-
-        @doer = PlaybackServlet.new(
-          status: 200,
-          headers: { 'Content-Type' => 'application/json', 'Vary' => 'Accept' },
-          body: json
-        )
-      end
-
-      def_delegator :@doer, :do_GET # rubocop:disable SymbolName
-    end
-
-    class Dummy
-      def initialize(port, path, response)
-        log_file = File.exist?('/dev/null') ? '/dev/null' : Tempfile.new('log') # So tests run on Windows
-        params = {
-          Port: port,
-          AccessLog: [],
-          Logger: WEBrick::Log.new(log_file, 7)
-        }
-        @server = WEBrick::HTTPServer.new params
-        @server.mount path, Servlet, response
-      end
-
-      def start
-        @pid = Thread.new do
-          trap 'INT' do
-            @server.shutdown
-          end
-          @server.start
-        end
-      end
-
-      def terminate
-        @server.shutdown
-        @pid.kill
-      end
-    end
-  end
-end

data/spec/pacto/dummy_server/jruby_workaround_helper.rb

@@ -1,23 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  module DummyServer
-    module JRubyWorkaroundHelper
-      include Pacto::TestHelper
-
-      def run_pacto
-        WebMock.allow_net_connect!
-        # There are issues with EventMachine on JRuby, so it can't currently us with_pacto
-        if RUBY_PLATFORM == 'java'
-          @server = Pacto::DummyServer::Dummy.new 8000, '/hello', '{"message": "Hello World!"}'
-          @server.start
-          yield
-          @server.terminate
-        else
-          with_pacto(port: 8000, strip_port: true) do
-            yield
-          end
-        end
-      end
-    end
-  end
-end

data/spec/pacto/dummy_server/playback_servlet.rb

@@ -1,22 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  module DummyServer
-    class PlaybackServlet
-      attr_reader :status, :headers, :body
-
-      def initialize(attributes)
-        @status = attributes.fetch(:status, 200)
-        @headers = attributes.fetch(:headers, [])
-        @body = attributes.fetch(:body, nil)
-      end
-
-      def do_GET(_request, response) # rubocop:disable MethodName
-        response.status = status
-        headers.each do |key, value|
-          response[key] = value
-        end
-        response.body = body
-      end
-    end
-  end
-end

data/spec/unit/pacto/contract_builder_spec.rb

@@ -1,89 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  describe ContractBuilder do
-    let(:data) { subject.build_hash }
-    describe '#name' do
-      it 'sets the contract name' do
-        subject.name = 'foo'
-        expect(data).to include(name: 'foo')
-      end
-    end
-
-    describe '#add_example' do
-      let(:examples) { subject.build_hash[:examples] }
-      it 'adds named examples to the contract' do
-        subject.add_example 'foo', Fabricate(:pacto_request), Fabricate(:pacto_response)
-        subject.add_example 'bar', Fabricate(:pacto_request), Fabricate(:pacto_response)
-        expect(examples).to be_a(Hash)
-        expect(examples.keys).to include('foo', 'bar')
-        expect(examples['foo'][:response]).to include(status: 200)
-        expect(data)
-      end
-    end
-
-    context 'without examples' do
-      describe '#infer_schemas' do
-        it 'does not add schemas' do
-          subject.name = 'test'
-          subject.infer_schemas
-          expect(data[:request][:schema]).to be_nil
-          expect(data[:response][:schema]).to be_nil
-        end
-      end
-    end
-
-    context 'with examples' do
-      before(:each) do
-        subject.add_example 'success', Fabricate(:pacto_request), Fabricate(:pacto_response)
-        subject.add_example 'not found', Fabricate(:pacto_request), Fabricate(:pacto_response)
-      end
-
-      describe '#without_examples' do
-        it 'stops the builder from including examples in the final data' do
-          expect(subject.build_hash.keys).to include(:examples)
-          expect(subject.without_examples.build_hash.keys).to_not include(:examples)
-        end
-      end
-
-      describe '#infer_schemas' do
-        it 'adds schemas' do
-          subject.name = 'test'
-          subject.infer_schemas
-          contract = subject.build
-          expect(contract.request.schema).to_not be_nil
-          expect(contract.request.schema).to_not be_nil
-        end
-      end
-    end
-
-    context 'generating from interactions' do
-      let(:request) { Fabricate(:pacto_request) }
-      let(:response) { Fabricate(:pacto_response) }
-      let(:data) { subject.generate_response(request, response).build_hash }
-      let(:contract) { subject.generate_contract(request, response).build }
-
-      describe '#generate_response' do
-        it 'sets the response status' do
-          expect(data[:response]).to include(
-                                               status: 200
-                                             )
-        end
-
-        it 'sets response headers' do
-          expect(data[:response][:headers]).to be_a(Hash)
-        end
-      end
-
-      describe '#infer_schemas' do
-        it 'sets the schemas based on the examples' do
-          expect(contract.request.schema).to_not be_nil
-          expect(contract.request.schema).to_not be_nil
-        end
-      end
-    end
-
-    skip '#add_request_header'
-    skip '#add_response_header'
-    skip '#filter'
-  end
-end