soaspec 0.2.24 → 0.2.25

data/lib/soaspec/exchange_handlers/handler_accessors.rb

@@ -1,130 +1,130 @@
-module Soaspec
-  # Describes methods test handlers use to easily set attributes
-  # Some are included in 'success scenarios' and to configure the request sent
-  module HandlerAccessors
-    # Defines expected_mandatory_elements method used in 'success_scenario' shared examples
-    # to indicate certain elements must be present
-    # @param [Array] elements Array of symbols specifying expected element names for 'success scenario' in snakecase
-    #
-    # @example Inside class
-    #   mandatory_elements :GetWeatherResult
-    #
-    # Or for a list
-    #
-    # @example Inside class
-    #   mandatory_elements [:GetWeatherResult, :GetResultStatus]
-    #
-    # In test
-    # describe Exchange(:name) do
-    #   it_behaves_like 'success scenario' # Includes checks for mandatory elements
-    # end
-    def mandatory_elements(elements)
-      define_method('expected_mandatory_elements') do
-        return [elements] if elements.is_a?(String) || elements.is_a?(Symbol)
-
-        elements
-      end
-    end
-
-    # Defines mandatory xpaths value pairs to be included in 'success scenario' shared example
-    #
-    # @example Inside class
-    #   mandatory_xpath_values '//xmlns:GetWeatherResult' => 'Data Not Found'
-    #
-    # @example In test
-    #   describe Exchange(:name) do
-    #     it_behaves_like 'success scenario' # Includes xpath pair validation
-    #   end
-    #
-    # @param [Hash] xpath_value_pairs Hash of element => expected value that must appear
-    #                                 in a successful response body
-    def mandatory_xpath_values(xpath_value_pairs)
-      raise ArgumentError('Hash of {xpath => expected values} expected ') unless xpath_value_pairs.is_a? Hash
-
-      define_method('expected_mandatory_xpath_values') { xpath_value_pairs }
-    end
-
-    # Defines mandatory json path value pairs to be included in 'success scenario' shared example
-    #
-    # @example Inside class
-    #   mandatory_json_values '$..GetWeatherResult' => 'Found'
-    #
-    # @example In test
-    #   describe Exchange(:name) do
-    #     it_behaves_like 'success scenario' # Includes json pair validation
-    #   end
-    #
-    # @param [Hash] json_value_pairs Hash of element => expected value that must appear
-    #                                in a successful response body
-    def mandatory_json_values(json_value_pairs)
-      raise ArgumentError("Hash of {'jsonpath' => expected values} expected") unless json_value_pairs.is_a? Hash
-
-      define_method('expected_mandatory_json_values') { json_value_pairs }
-    end
-
-    # Links a particular path to a meaningful method that can be accessed from Exchange class.
-    # This will use the 'value_from_path' method which
-    # should be implemented by each ExchangeHandler
-    # @param [String, Symbol] name Method name used to access element
-    # @param [String, Symbol] path Path to find object (e.g, XPath, JSONPath).
-    #                              For JSONPath a ',' can be put to get an element either path
-    def element(name, path)
-      define_method("__custom_path_#{name}") do |response|
-        value_from_path(response, path.to_s)
-      end
-    end
-
-    # Links an attribute to a meaningful method that can be accessed from Exchange class.
-    # This will use the 'value_from_path' method which
-    # should be implemented by each ExchangeHandler
-    # @param [String, Symbol] name Method name used to access attribute
-    # @param [String, nil, Hash] attribute Attribute name to extract from xml. If not set, this will default to @name
-    def attribute(name, attribute = nil)
-      attribute_used = attribute || name.to_s
-      define_method("__custom_path_#{name}") do |response|
-        value_from_path(response, 'implicit', attribute: attribute_used)
-      end
-    end
-
-    # All xpath will be done with XML that is converted to lower case
-    # You must then use lower case in the xpath's to obtain the desired values
-    # @param [Boolean] set Whether to convert all xml in response to lower case before performing XPath
-    def convert_to_lower(set)
-      return unless set
-
-      define_method('convert_to_lower?') { true }
-    end
-
-    # Whether to remove namespaces from response in Xpath assertion automatically
-    # For why this may not be a good thing in general see
-    # http://tenderlovemaking.com/2009/04/23/namespaces-in-xml.html
-    # This will be overridden if xpath has a ':' in it
-    # @param [Boolean] set Whether to strip namespaces form XML response
-    def strip_namespaces(set)
-      return unless set
-
-      # Whether to remove namespaces in xpath assertion automatically
-      define_method('strip_namespaces?') { true }
-    end
-
-    # Set the default hash representing data to be used in making a request
-    # This will set the @request_option instance variable too
-    # @param [Hash] hash Default hash of request
-    def default_hash(hash)
-      define_method('default_hash_value') do
-        @request_option = :hash
-        Soaspec.always_use_keys? ? hash.transform_keys_to_symbols : hash
-      end
-    end
-
-    # Set the request option type and the template name
-    # Erb is used to parse the template file, executing Ruby code in `<%= %>` blocks to work out the final request
-    # @param [String] name Name of file inside 'template' folder excluding extension
-    def template_name(name)
-      define_method('template_name_value') do
-        @request_option = :template
-        name
-      end
-    end
-  end
-end
+module Soaspec
+  # Describes methods test handlers use to easily set attributes
+  # Some are included in 'success scenarios' and to configure the request sent
+  module HandlerAccessors
+    # Defines expected_mandatory_elements method used in 'success_scenario' shared examples
+    # to indicate certain elements must be present
+    # @param [Array] elements Array of symbols specifying expected element names for 'success scenario' in snakecase
+    #
+    # @example Inside class
+    #   mandatory_elements :GetWeatherResult
+    #
+    # Or for a list
+    #
+    # @example Inside class
+    #   mandatory_elements [:GetWeatherResult, :GetResultStatus]
+    #
+    # In test
+    # describe Exchange(:name) do
+    #   it_behaves_like 'success scenario' # Includes checks for mandatory elements
+    # end
+    def mandatory_elements(elements)
+      define_method('expected_mandatory_elements') do
+        return [elements] if elements.is_a?(String) || elements.is_a?(Symbol)
+
+        elements
+      end
+    end
+
+    # Defines mandatory xpaths value pairs to be included in 'success scenario' shared example
+    #
+    # @example Inside class
+    #   mandatory_xpath_values '//xmlns:GetWeatherResult' => 'Data Not Found'
+    #
+    # @example In test
+    #   describe Exchange(:name) do
+    #     it_behaves_like 'success scenario' # Includes xpath pair validation
+    #   end
+    #
+    # @param [Hash] xpath_value_pairs Hash of element => expected value that must appear
+    #                                 in a successful response body
+    def mandatory_xpath_values(xpath_value_pairs)
+      raise ArgumentError('Hash of {xpath => expected values} expected ') unless xpath_value_pairs.is_a? Hash
+
+      define_method('expected_mandatory_xpath_values') { xpath_value_pairs }
+    end
+
+    # Defines mandatory json path value pairs to be included in 'success scenario' shared example
+    #
+    # @example Inside class
+    #   mandatory_json_values '$..GetWeatherResult' => 'Found'
+    #
+    # @example In test
+    #   describe Exchange(:name) do
+    #     it_behaves_like 'success scenario' # Includes json pair validation
+    #   end
+    #
+    # @param [Hash] json_value_pairs Hash of element => expected value that must appear
+    #                                in a successful response body
+    def mandatory_json_values(json_value_pairs)
+      raise ArgumentError("Hash of {'jsonpath' => expected values} expected") unless json_value_pairs.is_a? Hash
+
+      define_method('expected_mandatory_json_values') { json_value_pairs }
+    end
+
+    # Links a particular path to a meaningful method that can be accessed from Exchange class.
+    # This will use the 'value_from_path' method which
+    # should be implemented by each ExchangeHandler
+    # @param [String, Symbol] name Method name used to access element
+    # @param [String, Symbol] path Path to find object (e.g, XPath, JSONPath).
+    #                              For JSONPath a ',' can be put to get an element either path
+    def element(name, path)
+      define_method("__custom_path_#{name}") do |response|
+        value_from_path(response, path.to_s)
+      end
+    end
+
+    # Links an attribute to a meaningful method that can be accessed from Exchange class.
+    # This will use the 'value_from_path' method which
+    # should be implemented by each ExchangeHandler
+    # @param [String, Symbol] name Method name used to access attribute
+    # @param [String, nil, Hash] attribute Attribute name to extract from xml. If not set, this will default to @name
+    def attribute(name, attribute = nil)
+      attribute_used = attribute || name.to_s
+      define_method("__custom_path_#{name}") do |response|
+        value_from_path(response, 'implicit', attribute: attribute_used)
+      end
+    end
+
+    # All xpath will be done with XML that is converted to lower case
+    # You must then use lower case in the xpath's to obtain the desired values
+    # @param [Boolean] set Whether to convert all xml in response to lower case before performing XPath
+    def convert_to_lower(set)
+      return unless set
+
+      define_method('convert_to_lower?') { true }
+    end
+
+    # Whether to remove namespaces from response in Xpath assertion automatically
+    # For why this may not be a good thing in general see
+    # http://tenderlovemaking.com/2009/04/23/namespaces-in-xml.html
+    # This will be overridden if xpath has a ':' in it
+    # @param [Boolean] set Whether to strip namespaces form XML response
+    def strip_namespaces(set)
+      return unless set
+
+      # Whether to remove namespaces in xpath assertion automatically
+      define_method('strip_namespaces?') { true }
+    end
+
+    # Set the default hash representing data to be used in making a request
+    # This will set the @request_option instance variable too
+    # @param [Hash] hash Default hash of request
+    def default_hash(hash)
+      define_method('default_hash_value') do
+        @request_option = :hash
+        Soaspec.always_use_keys? ? hash.transform_keys_to_symbols : hash
+      end
+    end
+
+    # Set the request option type and the template name
+    # Erb is used to parse the template file, executing Ruby code in `<%= %>` blocks to work out the final request
+    # @param [String] name Name of file inside 'template' folder excluding extension
+    def template_name(name)
+      define_method('template_name_value') do
+        @request_option = :template
+        name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Soaspec
+  # Models a request made to a REST API
+  class RestRequest
+    # @example GET method
+    #   :get
+    # @return [Symbol] REST method used
+    attr_accessor :method
+    # @example JSON body
+    #   {"test":5}
+    # @return [String] Body of request sent
+    attr_accessor :body
+    # @return [String] Name given to test to describe it
+    attr_accessor :test_name
+    # @return [String] User used in basic auth
+    attr_accessor :basic_auth_user
+    # @return [String] Password used in basic auth
+    attr_accessor :basic_auth_password
+    # @return [String] Url appended to base_url
+    attr_accessor :suburl
+    # @return [Hash] Miscellaneous parameters
+    attr_accessor :other_params
+    # Headers. Keys that are `symbols` will be converted from `snake_case` to `Word-Word2`
+    # @return [Hash] Headers sent as part of request
+    attr_accessor :headers
+
+    def initialize(overall, options, body)
+      overall_params = overall.dup # Must duplicate hash as deletion occurring
+      self.body = body
+      self.method = overall_params.delete(:method)
+      self.suburl = overall_params.delete(:suburl)
+      self.test_name = overall_params.delete(:name)
+      self.other_params = overall_params
+      self.basic_auth_user = options[:user]
+      self.basic_auth_password = options[:password]
+      self.headers = options[:headers]
+    end
+
+    # @param [String, Symbol] value Message to send to object retrieving a value
+    # @return [Object] Result of retrieving value
+    def [](value)
+      self.send(value)
+    end
+
+    # @return [String] Show inspection of all parameters
+    def to_s
+      inspect
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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)
+      self.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,82 +1,82 @@
-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}"
-      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
+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}"
+      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