pacto 0.4.0.rc1 → 0.4.0.rc2

data/lib/pacto/formats/legacy/generator/filters.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      module Generator
+        class Filters
+          CONNECTION_CONTROL_HEADERS = %w(
+            Via
+            Server
+            Connection
+            Transfer-Encoding
+            Content-Length
+          )
+
+          FRESHNESS_HEADERS =
+          %w(
+            Date
+            Last-Modified
+            ETag
+          )
+
+          HEADERS_TO_FILTER = CONNECTION_CONTROL_HEADERS + FRESHNESS_HEADERS
+
+          def filter_request_headers(request, response)
+            # FIXME: Do we need to handle all these cases in real situations, or just because of stubbing?
+            vary_headers = response.headers['vary'] || response.headers['Vary'] || []
+            vary_headers = [vary_headers] if vary_headers.is_a? String
+            vary_headers = vary_headers.map do |h|
+              h.split(',').map(&:strip)
+            end.flatten
+
+            request.headers.select do |header|
+              vary_headers.map(&:downcase).include? header.downcase
+            end
+          end
+
+          def filter_response_headers(_request, response)
+            Pacto::Extensions.normalize_header_keys(response.headers).reject do |header|
+              (HEADERS_TO_FILTER.include? header) || (header.start_with?('X-'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/legacy/generator_hint.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      class GeneratorHint < Pacto::Dash
+        extend Forwardable
+
+        property :request_clause
+        coerce_key :request_clause, RequestClause
+        property :service_name, required: true
+        property :target_file
+
+        def_delegators :request_clause, *RequestClause::Data.properties.map(&:to_sym)
+
+        def initialize(data)
+          data[:request_clause] = RequestClause::Data.properties.each_with_object({}) do | prop, hash |
+            hash[prop] = data.delete prop
+          end
+          super
+          self.target_file ||= "#{slugify(service_name)}.json"
+        end
+
+        def matches?(pacto_request)
+          return false if pacto_request.nil?
+          Pacto::RequestPattern.for(request_clause).matches?(pacto_request)
+        end
+
+        private
+
+        def slugify(path)
+          path.downcase.gsub(' ', '_')
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/legacy/request_clause.rb

@@ -0,0 +1,39 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      class RequestClause < Pacto::Dash
+        include Pacto::RequestClause
+        extend Forwardable
+        attr_reader :data
+        def_delegators :data, :to_hash
+        def_delegators :data, :host, :http_method, :schema, :path, :headers, :params
+        def_delegators :data, :host=, :http_method=, :schema=, :path=, :headers=, :params=
+
+        class Data < Pacto::Dash
+          property :host # required?
+          property :http_method, required: true
+          property :schema, default: {}
+          property :path, default: '/'
+          property :headers, default: {}
+          property :params, default: {}
+        end
+
+        def initialize(data)
+          skip_freeze = data.delete(:skip_freeze)
+          mash = Hashie::Mash.new data
+          mash['http_method'] = normalize(mash['http_method'])
+          @data = Data.new(mash)
+          freeze unless skip_freeze
+          super({})
+          @pattern = Pacto::RequestPattern.for(self)
+        end
+
+        def freeze
+          @data.freeze
+          self
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/legacy/response_clause.rb

@@ -0,0 +1,31 @@
+module Pacto
+  module Formats
+    module Legacy
+      class ResponseClause
+        include Pacto::ResponseClause
+        extend Forwardable
+        attr_reader :data
+        def_delegators :data, :to_hash
+        def_delegators :data, :status, :headers, :schema
+        def_delegators :data, :status=, :headers=, :schema=
+
+        class Data < Pacto::Dash
+          property :status
+          property :headers, default: {}
+          property :schema, default: {}
+        end
+
+        def initialize(data)
+          skip_freeze = data.delete(:skip_freeze)
+          @data = Data.new(data)
+          freeze unless skip_freeze
+        end
+
+        def freeze
+          @data.freeze
+          self
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/swagger/contract.rb

@@ -0,0 +1,86 @@
+# -*- encoding : utf-8 -*-
+
+require 'pacto/formats/swagger/request_clause'
+require 'pacto/formats/swagger/response_clause'
+
+module Pacto
+  module Formats
+    module Swagger
+      class Contract < Pacto::Dash
+        include Pacto::Contract
+
+        attr_reader :swagger_api_operation
+
+        property :id
+        property :file
+        property :request,  required: true
+        # Although I'd like response to be required, it complicates
+        # the partial contracts used the rake generation task...
+        # yet another reason I'd like to deprecate that feature
+        property :response # , required: true
+        property :values, default: {}
+        # Gotta figure out how to use test doubles w/ coercion
+        coerce_key :request,  RequestClause
+        coerce_key :response, ResponseClause
+        property :examples
+        property :name, required: true
+        property :adapter, default: proc { Pacto.configuration.adapter }
+        property :consumer, default: proc { Pacto.configuration.default_consumer }
+        property :provider, default: proc { Pacto.configuration.default_provider }
+
+        def initialize(swagger_api_operation, base_data = {}) # rubocop:disable Metrics/MethodLength
+          if base_data[:file]
+            base_data[:file] = Addressable::URI.convert_path(File.expand_path(base_data[:file])).to_s
+            base_data[:name] ||= base_data[:file]
+          end
+          base_data[:id] ||= (base_data[:summary] || base_data[:file])
+
+          @swagger_api_operation = swagger_api_operation
+          host = base_data.delete(:host) || swagger_api_operation.host
+          default_response = swagger_api_operation.default_response
+          request_clause = Pacto::Formats::Swagger::RequestClause.new(swagger_api_operation, host: host)
+
+          if default_response.nil?
+            logger.warn("No response defined for #{swagger_api_operation.full_name}")
+            response_clause = ResponseClause.new(status: 200)
+          else
+            response_clause = ResponseClause.new(default_response)
+          end
+
+          examples = build_examples(default_response)
+          super base_data.merge(
+                  id: swagger_api_operation.operationId,
+                  name: swagger_api_operation.full_name,
+                  request: request_clause, response: response_clause,
+                  examples: examples
+                )
+        end
+
+        private
+
+        def build_examples(response)
+          return nil if response.nil? || response.examples.nil? || response.examples.empty?
+
+          if response.examples.empty?
+            response_body = nil
+          else
+            response_body = response.examples.values.first
+          end
+
+          {
+            default: {
+              request: {}, # Swagger doesn't have a clear way to capture request examples
+              response: {
+                body: response_body
+              }
+            }
+          }
+        rescue => e # FIXME: Only parsing errors?
+          logger.warn("Error while trying to parse response example for #{swagger_api_operation.full_name}")
+          logger.debug("  Error details: #{e.inspect}")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/swagger/contract_factory.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+require 'swagger'
+require 'pacto/formats/swagger/contract'
+
+module Pacto
+  module Formats
+    module Swagger
+      # Builds {Pacto::Formats::Swagger::Contract} instances from Swagger documents
+      class ContractFactory
+        include Logger
+
+        def load_hints(_contract_path, _host = nil)
+          fail NotImplementedError, 'Contract generation from hints is not currently supported for Swagger'
+        end
+
+        def build_from_file(contract_path, host = nil)
+          app = ::Swagger.load(contract_path)
+          app.operations.map do |op|
+            Contract.new(op,
+                         file: contract_path,
+                         host: host
+            )
+          end
+        rescue ArgumentError => e
+          logger.error(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
+      end
+      Pacto::ContractFactory.add_factory(:swagger, ContractFactory.new)
+    end
+  end
+end

data/lib/pacto/formats/swagger/request_clause.rb

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Swagger
+      class RequestClause
+        include Pacto::RequestClause
+
+        extend Forwardable
+        attr_writer :host
+        attr_reader :swagger_api_operation
+        def_delegator :swagger_api_operation, :verb, :http_method
+        def_delegators :swagger_api_operation, :path
+
+        def initialize(swagger_api_operation, base_data = {})
+          @swagger_api_operation = swagger_api_operation
+          @host = base_data[:host] || swagger_api_operation.host
+          @pattern = Pacto::RequestPattern.for(self)
+        end
+
+        def schema
+          return nil if body_parameter.nil?
+          return nil if body_parameter.schema.nil?
+          body_parameter.schema.parse
+        end
+
+        def params
+          return {} if swagger_api_operation.parameters.nil?
+
+          swagger_api_operation.parameters.select { |p| p.in == 'query' }
+        end
+
+        def headers
+          return {} if swagger_api_operation.parameters.nil?
+
+          swagger_api_operation.parameters.select { |p| p.in == 'header' }
+        end
+
+        def to_hash
+          [:http_method, :schema, :path, :headers, :params].each_with_object({}) do | key, hash |
+            hash[key.to_s] = send key
+          end
+        end
+
+        private
+
+        def body_parameter
+          return nil if swagger_api_operation.parameters.nil?
+          swagger_api_operation.parameters.find { |p| p.in == 'body' }
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/swagger/response_clause.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Swagger
+      class ResponseClause
+        extend Forwardable
+        include Pacto::ResponseClause
+        attr_reader :swagger_response
+
+        def_delegators :swagger_response, :schema
+
+        def initialize(swagger_response, _base_data = {})
+          @swagger_response = swagger_response
+        end
+
+        def status
+          swagger_response.status_code || 200
+        end
+
+        def headers
+          swagger_response.headers || {}
+        end
+
+        def schema
+          return nil unless swagger_response.schema
+          swagger_response.schema.parse
+        end
+      end
+    end
+  end
+end

data/lib/pacto/generator.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
-require 'pacto/generator/native_contract_generator'
-require 'pacto/generator/hint'
+require 'pacto/formats/legacy/contract_generator'
+require 'pacto/formats/legacy/generator_hint'
 
 module Pacto
   module Generator
@@ -9,7 +9,7 @@ module Pacto
     class << self
       # Factory method to return the active contract generator implementation
       def contract_generator
-        NativeContractGenerator.new
+        Pacto::Formats::Legacy::ContractGenerator.new
       end
 
       # Factory method to return the active contract generator implementation
@@ -38,7 +38,7 @@ module Pacto
       end
 
       def hint(name, hint_data)
-        @hints << Pacto::Generator::Hint.new(hint_data.merge(service_name: name))
+        @hints << Formats::Legacy::GeneratorHint.new(hint_data.merge(service_name: name))
       end
     end
   end

data/lib/pacto/handlers/json_handler.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module Pacto
+  module Handlers
+    module JSONHandler
+      class << self
+        def raw(body)
+          JSON.dump(body)
+        end
+
+        def parse(body)
+          JSON.parse(body)
+        end
+
+        # TODO: Something like validate(contract, body)
+      end
+    end
+  end
+end

data/lib/pacto/handlers/text_handler.rb

@@ -0,0 +1,17 @@
+module Pacto
+  module Handlers
+    module TextHandler
+      class << self
+        def raw(body)
+          body.to_s
+        end
+
+        def parse(body)
+          body.to_s
+        end
+
+        # TODO: Something like validate(contract, body)
+      end
+    end
+  end
+end

data/lib/pacto/request_clause.rb

@@ -1,33 +1,23 @@
 # -*- encoding : utf-8 -*-
 module Pacto
-  class RequestClause < Pacto::Dash
+  module RequestClause
     include Logger
-    property :host # required?
-    property :http_method, required: true
-    property :schema, default: {}
-    property :path, default: '/'
-    property :headers
-    property :params, default: {}
-    property :request_pattern_provider, default: Pacto::RequestPattern
-
-    def initialize(definition)
-      mash = Hashie::Mash.new definition
-      mash['http_method'] = normalize(mash['http_method'])
-      super mash
-    end
+    attr_reader :host
+    attr_reader :http_method
+    attr_reader :schema
+    attr_reader :path
+    attr_reader :headers
+    attr_reader :params
+    attr_reader :pattern
 
     def http_method=(method)
       normalize(method)
     end
 
-    def pattern
-      @pattern ||= request_pattern_provider.for(self)
-    end
-
     def uri(values = {})
       values ||= {}
       uri_template = pattern.uri_template
-      missing_keys = uri_template.keys - values.keys
+      missing_keys = uri_template.keys.map(&:to_sym) - values.keys.map(&:to_sym)
       values[:scheme] = 'http' if missing_keys.delete(:scheme)
       values[:server] = 'localhost' if missing_keys.delete(:server)
       logger.warn "Missing keys for building a complete URL: #{missing_keys.inspect}" unless missing_keys.empty?