soaspec 0.2.32 → 0.2.33

data/lib/soaspec/exchange_handlers/request/soap_request.rb

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-module Soaspec
-  # Models a request made to a SOAP API
-  class SoapRequest
-    # @example SOAP operation
-    #   :login
-    # @return [Symbol] SOAP operation used
-    attr_accessor :operation
-    # Hash representing what will be sent to Savon. Either the exact xml (if using a template)
-    # or a message Hash that will be converted to XML by Savon
-    # @example
-    #   { xml: "<env:Envelope xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" ...</env:Body>\n</env:Envelope> " }
-    # @return [Hash] Body of request sent
-    attr_accessor :body
-    # @return [Symbol] Method of building the request (:hash, :template)
-    attr_accessor :request_option
-    # @return [String] Name given to test to describe it
-    attr_accessor :test_name
-
-    # @param [Symbol] operation Soap operation used
-    # @param [Hash] body Hash with method of SOAP generated contained
-    # @param [Symbol] request_option Method of building the request (:hash, :template)
-    def initialize(operation, body, request_option)
-      self.body = body
-      self.operation = operation
-      self.request_option = request_option
-    end
-
-    # @param [String, Symbol] value Message to send to object retrieving a value
-    # @return [Object] Result of retrieving value
-    def [](value)
-      send(value)
-    end
-
-    # @return [String] Show inspection of all parameters
-    def to_s
-      inspect
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Soaspec
+  # Models a request made to a SOAP API
+  class SoapRequest
+    # @example SOAP operation
+    #   :login
+    # @return [Symbol] SOAP operation used
+    attr_accessor :operation
+    # Hash representing what will be sent to Savon. Either the exact xml (if using a template)
+    # or a message Hash that will be converted to XML by Savon
+    # @example
+    #   { xml: "<env:Envelope xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" ...</env:Body>\n</env:Envelope> " }
+    # @return [Hash] Body of request sent
+    attr_accessor :body
+    # @return [Symbol] Method of building the request (:hash, :template)
+    attr_accessor :request_option
+    # @return [String] Name given to test to describe it
+    attr_accessor :test_name
+
+    # @param [Symbol] operation Soap operation used
+    # @param [Hash] body Hash with method of SOAP generated contained
+    # @param [Symbol] request_option Method of building the request (:hash, :template)
+    def initialize(operation, body, request_option)
+      self.body = body
+      self.operation = operation
+      self.request_option = request_option
+    end
+
+    # @param [String, Symbol] value Message to send to object retrieving a value
+    # @return [Object] Result of retrieving value
+    def [](value)
+      send(value)
+    end
+
+    # @return [String] Show inspection of all parameters
+    def to_s
+      inspect
+    end
+  end
+end

data/lib/soaspec/exchange_handlers/response_extractor.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-
-module Soaspec
-  # Enables extracting a response according to type / path
-  module ResponseExtractor
-    # Convert XML or JSON response into a Hash. Doesn't accept empty body
-    # @param [String] response Response as a String (either in XML or JSON)
-    # @return [Hash] Extracted Hash from response
-    def extract_hash(response)
-      raise NoElementAtPath, "Empty Body. Can't assert on it" if response.body.empty?
-
-      case Interpreter.response_type_for response
-      when :xml then parse_xml(response.body.to_s)
-      when :json
-        converted = JSON.parse(response.body)
-        return converted.transform_keys_to_symbols if converted.is_a? Hash
-        return converted.map!(&:transform_keys_to_symbols) if converted.is_a? Array
-
-        raise 'Incorrect Type produced ' + converted.class
-      else
-        raise "Neither XML nor JSON detected. It is #{type}. Don't know how to parse It is #{response.body}"
-      end
-    end
-
-    # @param [Object] response Response object
-    # @return [Hash] Hash representing response body
-    def to_hash(response)
-      case Interpreter.response_type_for(response)
-      when :xml then IndifferentHash.new(parse_xml(response.body.to_s))
-      when :json
-        IndifferentHash.new(JSON.parse(response.body.to_s))
-      else
-        raise "Unable to interpret type of '#{response.body}'. Could be because of: #{Interpreter.diagnose_error}"
-      end
-    end
-
-    private
-
-    # @param [String] xml XML to convert
-    # @return [Hash] Hash representing XML
-    def parse_xml(xml)
-      parser = Nori.new(strip_namespaces: strip_namespaces?, convert_tags_to: ->(tag) { tag.snakecase.to_sym })
-      parser.parse(xml)
-    end
-
-    # This enables shortcut xpaths to be used. If no '/' is given, one is appended to the start of the path
-    # If attribute value is set then this is also adjusted
-    # @return [String] New Xpath adjusted according to any add ons
-    def prefix_xpath(xpath, attribute)
-      xpath = "//*[@#{attribute}]" unless attribute.nil?
-      if xpath[0] != '/'
-        xpath = convert_to_pascal_case(xpath) if pascal_keys?
-        xpath = '//' + xpath
-      end
-      xpath
-    end
-
-    # Convert snakecase to PascalCase
-    # @return [String] PascalCase converted path
-    def convert_to_pascal_case(key)
-      return key if /[[:upper:]]/ =~ key[0] # If first character already capital, don't do conversion
-
-      key.split('_').map(&:capitalize).join
-    end
-
-    # Find element with name specified or pascal case equivalent
-    # @return [String] String to find paths with pascal converted or given path
-    def add_pascal_path(json_path)
-      return json_path unless pascal_keys?
-
-      json_path.split(',').collect do |sub_path|
-        "#{sub_path},#{convert_to_pascal_case(sub_path)}"
-      end.join(',')
-    end
-
-    # @param [String] json_path Path set from Exchange
-    # @return [String] JSON Path
-    def prefix_json_path(json_path)
-      return json_path if json_path[0] == '$'
-
-      "$..#{json_path}"
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Soaspec
+  # Enables extracting a response according to type / path
+  module ResponseExtractor
+    # Convert XML or JSON response into a Hash. Doesn't accept empty body
+    # @param [String] response Response as a String (either in XML or JSON)
+    # @return [Hash] Extracted Hash from response
+    def extract_hash(response)
+      raise NoElementAtPath, "Empty Body. Can't assert on it" if response.body.empty?
+
+      case Interpreter.response_type_for response
+      when :xml then parse_xml(response.body.to_s)
+      when :json
+        converted = JSON.parse(response.body)
+        return converted.transform_keys_to_symbols if converted.is_a? Hash
+        return converted.map!(&:transform_keys_to_symbols) if converted.is_a? Array
+
+        raise 'Incorrect Type produced ' + converted.class
+      else
+        raise "Neither XML nor JSON detected. It is #{type}. Don't know how to parse It is #{response.body}"
+      end
+    end
+
+    # @param [Object] response Response object
+    # @return [Hash] Hash representing response body
+    def to_hash(response)
+      case Interpreter.response_type_for(response)
+      when :xml then IndifferentHash.new(parse_xml(response.body.to_s))
+      when :json
+        IndifferentHash.new(JSON.parse(response.body.to_s))
+      else
+        raise "Unable to interpret type of '#{response.body}'. Could be because of: #{Interpreter.diagnose_error}"
+      end
+    end
+
+    private
+
+    # @param [String] xml XML to convert
+    # @return [Hash] Hash representing XML
+    def parse_xml(xml)
+      parser = Nori.new(strip_namespaces: strip_namespaces?, convert_tags_to: ->(tag) { tag.snakecase.to_sym })
+      parser.parse(xml)
+    end
+
+    # This enables shortcut xpaths to be used. If no '/' is given, one is appended to the start of the path
+    # If attribute value is set then this is also adjusted
+    # @return [String] New Xpath adjusted according to any add ons
+    def prefix_xpath(xpath, attribute)
+      xpath = "//*[@#{attribute}]" unless attribute.nil?
+      if xpath[0] != '/'
+        xpath = convert_to_pascal_case(xpath) if pascal_keys?
+        xpath = '//' + xpath
+      end
+      xpath
+    end
+
+    # Convert snakecase to PascalCase
+    # @return [String] PascalCase converted path
+    def convert_to_pascal_case(key)
+      return key if /[[:upper:]]/ =~ key[0] # If first character already capital, don't do conversion
+
+      key.split('_').map(&:capitalize).join
+    end
+
+    # Find element with name specified or pascal case equivalent
+    # @return [String] String to find paths with pascal converted or given path
+    def add_pascal_path(json_path)
+      return json_path unless pascal_keys?
+
+      json_path.split(',').collect do |sub_path|
+        "#{sub_path},#{convert_to_pascal_case(sub_path)}"
+      end.join(',')
+    end
+
+    # @param [String] json_path Path set from Exchange
+    # @return [String] JSON Path
+    def prefix_json_path(json_path)
+      return json_path if json_path[0] == '$'
+
+      "$..#{json_path}"
+    end
+  end
+end

data/lib/soaspec/exchange_handlers/rest_exchanger_factory.rb

@@ -1,111 +1,111 @@
-# frozen_string_literal: true
-
-module Soaspec
-  # Convenience methods for once off usage of a REST request
-  module RestExchangeFactory
-    # Make REST Exchange with 'post' method within this Handler context
-    # @param [Hash, String] params Exchange parameters. If String is used it will be for the request payload
-    # @option params [String] :name Name to appear in traffic logs
-    # @option params [Hash] :params Extra parameters (E.g. headers)
-    # @option params [String] :suburl URL appended to base_url of class
-    # @option params [Hash] :q Query for REST
-    # Following are for the body of the request
-    # @option params [Hash] :body Hash to be converted to JSON in request body
-    # @option params [String] :payload String to be passed directly in request body
-    # @option params [String] :template_name Path to file to be read via ERB and passed in request body
-    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
-    def post(params = {})
-      perform_exchange_with(:post, params)
-    end
-
-    # Make REST Exchange with 'patch' method within this Handler context
-    # @param [Hash, String] params Exchange parameters. If String is used it will be for the request payload
-    # @option params [String] :name Name to appear in traffic logs
-    # @option params [Hash] :params Extra parameters (E.g. headers)
-    # @option params [String] suburl URL appended to base_url of class
-    # @option params [Hash] :q Query for REST
-    # Following are for the body of the request
-    # @option params [Hash] :body Hash to be converted to JSON in request body
-    # @option params [String] :payload String to be passed directly in request body
-    # @option params [String] :template_name Path to file to be read via ERB and passed in request body
-    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
-    def patch(params)
-      perform_exchange_with(:patch, params)
-    end
-
-    # Make REST Exchange with 'put' method within this Handler context
-    # @param [Hash, String] params Exchange parameters. If String is used it will be for the request payload
-    # @option params [String] :name Name to appear in traffic logs
-    # @option params [Hash] :params Extra parameters (E.g. headers)
-    # @option params [String] :suburl URL appended to base_url of class
-    # @option params [Hash] :q Query for REST
-    # Following are for the body of the request
-    # @option params [Hash] :body Hash to be converted to JSON in request body
-    # @option params [String] :payload String to be passed directly in request body
-    # @option params [String] :template_name Path to file to be read via ERB and passed in request body
-    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
-    def put(params = {})
-      perform_exchange_with(:put, params)
-    end
-
-    # Make REST Exchange with 'get' method within this Handler context.
-    # If merely a string is passed it will be used as the URL appended to base_url (same as suburl). Otherwise a Hash is expected
-    # @param [Hash, String] params Exchange parameters. If String is used it will be for suburl
-    # @option params [String] :name Name to appear in traffic logs
-    # @option params [String] :suburl URL appended to base_url of class
-    # @option params [Hash] :params Extra parameters (E.g. headers)
-    # @option params [Hash] :q Query for REST
-    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
-    def get(params = {})
-      perform_exchange_with(:get, params)
-    end
-
-    # Make REST Exchange with 'delete' method within this Handler context.
-    # If merely a string is passed it will be used as the URL appended to base_url (same as suburl). Otherwise a Hash is expected
-    # @param [Hash, String] params Exchange parameters. If String is used it will be for suburl
-    # @option params [String] :name Name to appear in traffic logs
-    # @option params [String] :suburl URL appended to base_url of class
-    # @option params [Hash] :q Query for REST
-    # @option params [Hash] :params Extra parameters (E.g. headers)
-    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
-    def delete(params = {})
-      perform_exchange_with(:delete, params)
-    end
-
-    private
-
-    # Make REST Exchange within this Handler context
-    # @param [Symbol] rest_method HTTP rest method to use
-    # @param [Hash, String] params Exchange parameters.
-    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
-    def perform_exchange_with(rest_method, params = {})
-      params = determine_params_for(rest_method, params)
-      params[:name] ||= rest_method.to_s
-      exchange_params = { name: params[:name] }
-      if params[:template_name]
-        exchange_params[:template_name] = params[:template_name]
-        params.delete :template_name
-      end
-      new(exchange_params)
-      exchange = Exchange.new(params[:name], method: rest_method, **params)
-      yield exchange if block_given?
-      exchange
-    end
-
-    # @param [Symbol] method HTTP rest method to use
-    # @param [Hash, String] params Exchange parameters.
-    # @return [Hash] Exchange Parameters after setting shorthand parameters
-    def determine_params_for(method, params)
-      return params if params.is_a? Hash
-
-      case method
-      when :get, :delete
-        { suburl: params.to_s }
-      when :post, :put, :patch
-        { payload: params.to_s }
-      else
-        raise "'#{params}' needs to be a 'Hash' but is a #{params.class}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Soaspec
+  # Convenience methods for once off usage of a REST request
+  module RestExchangeFactory
+    # Make REST Exchange with 'post' method within this Handler context
+    # @param [Hash, String] params Exchange parameters. If String is used it will be for the request payload
+    # @option params [String] :name Name to appear in traffic logs
+    # @option params [Hash] :params Extra parameters (E.g. headers)
+    # @option params [String] :suburl URL appended to base_url of class
+    # @option params [Hash] :q Query for REST
+    # Following are for the body of the request
+    # @option params [Hash] :body Hash to be converted to JSON in request body
+    # @option params [String] :payload String to be passed directly in request body
+    # @option params [String] :template_name Path to file to be read via ERB and passed in request body
+    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
+    def post(params = {})
+      perform_exchange_with(:post, params)
+    end
+
+    # Make REST Exchange with 'patch' method within this Handler context
+    # @param [Hash, String] params Exchange parameters. If String is used it will be for the request payload
+    # @option params [String] :name Name to appear in traffic logs
+    # @option params [Hash] :params Extra parameters (E.g. headers)
+    # @option params [String] suburl URL appended to base_url of class
+    # @option params [Hash] :q Query for REST
+    # Following are for the body of the request
+    # @option params [Hash] :body Hash to be converted to JSON in request body
+    # @option params [String] :payload String to be passed directly in request body
+    # @option params [String] :template_name Path to file to be read via ERB and passed in request body
+    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
+    def patch(params)
+      perform_exchange_with(:patch, params)
+    end
+
+    # Make REST Exchange with 'put' method within this Handler context
+    # @param [Hash, String] params Exchange parameters. If String is used it will be for the request payload
+    # @option params [String] :name Name to appear in traffic logs
+    # @option params [Hash] :params Extra parameters (E.g. headers)
+    # @option params [String] :suburl URL appended to base_url of class
+    # @option params [Hash] :q Query for REST
+    # Following are for the body of the request
+    # @option params [Hash] :body Hash to be converted to JSON in request body
+    # @option params [String] :payload String to be passed directly in request body
+    # @option params [String] :template_name Path to file to be read via ERB and passed in request body
+    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
+    def put(params = {})
+      perform_exchange_with(:put, params)
+    end
+
+    # Make REST Exchange with 'get' method within this Handler context.
+    # If merely a string is passed it will be used as the URL appended to base_url (same as suburl). Otherwise a Hash is expected
+    # @param [Hash, String] params Exchange parameters. If String is used it will be for suburl
+    # @option params [String] :name Name to appear in traffic logs
+    # @option params [String] :suburl URL appended to base_url of class
+    # @option params [Hash] :params Extra parameters (E.g. headers)
+    # @option params [Hash] :q Query for REST
+    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
+    def get(params = {})
+      perform_exchange_with(:get, params)
+    end
+
+    # Make REST Exchange with 'delete' method within this Handler context.
+    # If merely a string is passed it will be used as the URL appended to base_url (same as suburl). Otherwise a Hash is expected
+    # @param [Hash, String] params Exchange parameters. If String is used it will be for suburl
+    # @option params [String] :name Name to appear in traffic logs
+    # @option params [String] :suburl URL appended to base_url of class
+    # @option params [Hash] :q Query for REST
+    # @option params [Hash] :params Extra parameters (E.g. headers)
+    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
+    def delete(params = {})
+      perform_exchange_with(:delete, params)
+    end
+
+    private
+
+    # Make REST Exchange within this Handler context
+    # @param [Symbol] rest_method HTTP rest method to use
+    # @param [Hash, String] params Exchange parameters.
+    # @return [Exchange] Instance of Exchange class. Assertions are made by default on the response body
+    def perform_exchange_with(rest_method, params = {})
+      params = determine_params_for(rest_method, params)
+      params[:name] ||= rest_method.to_s
+      exchange_params = { name: params[:name] }
+      if params[:template_name]
+        exchange_params[:template_name] = params[:template_name]
+        params.delete :template_name
+      end
+      new(exchange_params)
+      exchange = Exchange.new(params[:name], method: rest_method, **params)
+      yield exchange if block_given?
+      exchange
+    end
+
+    # @param [Symbol] method HTTP rest method to use
+    # @param [Hash, String] params Exchange parameters.
+    # @return [Hash] Exchange Parameters after setting shorthand parameters
+    def determine_params_for(method, params)
+      return params if params.is_a? Hash
+
+      case method
+      when :get, :delete
+        { suburl: params.to_s }
+      when :post, :put, :patch
+        { payload: params.to_s }
+      else
+        raise "'#{params}' needs to be a 'Hash' but is a #{params.class}"
+      end
+    end
+  end
+end