soaspec 0.0.85 → 0.0.86

data/lib/soaspec/exchange_handlers/exchange_handler.rb

@@ -1,104 +1,104 @@
-
-require_relative 'handler_accessors'
-
-module Soaspec
-
-  # Inherit this for a class describing how to implement a particular exchange.
-  # Has basic methods common for methods defining RSpec tests in YAML
-  class ExchangeHandler
-    extend Soaspec::HandlerAccessors
-
-    # Retrieve the name of the template file to be used in the API request
-    attr_reader :template_name
-
-    # Explicitly defined elements for which a path has been predefined
-    def elements
-      public_methods.select { |i| i[/__custom_path_.+/] }
-    end
-
-    # Set the default hash representing data to be used in making a request
-    # This will set the @request_option instance variable too
-    def default_hash=(hash)
-      @request_option = :hash
-      @default_hash = Soaspec.always_use_keys? ? hash.transform_keys_to_symbols : hash
-    end
-
-    # Set instance variable name
-    # @param [String, Symbol] name Name used when describing API test
-    # @param [Hash] options Parameters defining handler. Used in descendants
-    def initialize(name = self.class.to_s, options = {})
-      use
-      @name = name
-    end
-
-    # Set Api handler used by Exchange class to this handler
-    # @return [Self]
-    def use
-      Soaspec.api_handler = self
-      self
-    end
-
-    # Sets api handler variable globally. This is used in 'Exchange' class
-    # @return [String] Name set upon initialisation
-    def to_s
-      use
-      @name.to_s
-    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)
-      @request_option = :template
-      @template_name = name
-    end
-
-    # Will be used in 'success_scenarios' shared examples.
-    # Set though 'mandatory_elements' method
-    # @return [Array] Array of symbols specifying element names
-    def expected_mandatory_elements
-      []
-    end
-
-    # Change this through 'mandatory_xpath_values' method to specify xpath results that must be present in the response
-    # Will be used in 'success_scenarios' shared examples
-    # @return [Hash] Hash of 'xpath' => 'expected value' pairs
-    def expected_mandatory_xpath_values
-      {}
-    end
-
-    # Change this through 'mandatory_json_values' method to specify json results that must be present in the response
-    # Will be used in 'success_scenarios' shared examples
-    # @return [Hash] Hash of 'json/path' => 'expected value' pairs
-    def expected_mandatory_json_values
-      {}
-    end
-
-    # @return [Boolean] Whether all xpaths will be done with XML that is converted to lower case
-    def convert_to_lower?
-      false
-    end
-
-    # Stores a value in a method that can be accessed by the provided name
-    # @param [Symbol] name Name of method to use to access this value within handler
-    # @param [String] value Value to store
-    def store(name, value)
-      define_singleton_method('__stored_val__' + name.to_s) do
-        value
-      end
-    end
-
-    # Set instance variable and remove it from Hash
-    def set_remove_key(hash, key)
-      return unless hash.key? key
-      __send__("#{key}=", hash[key])
-      hash.delete key
-    end
-
-    # @return [Boolean] Whether to remove namespaces in xpath assertion automatically
-    def strip_namespaces?
-      false
-    end
-
-  end
+
+require_relative 'handler_accessors'
+
+module Soaspec
+
+  # Inherit this for a class describing how to implement a particular exchange.
+  # Has basic methods common for methods defining RSpec tests in YAML
+  class ExchangeHandler
+    extend Soaspec::HandlerAccessors
+
+    # Retrieve the name of the template file to be used in the API request
+    attr_reader :template_name
+
+    # Explicitly defined elements for which a path has been predefined
+    def elements
+      public_methods.select { |i| i[/__custom_path_.+/] }
+    end
+
+    # Set the default hash representing data to be used in making a request
+    # This will set the @request_option instance variable too
+    def default_hash=(hash)
+      @request_option = :hash
+      @default_hash = Soaspec.always_use_keys? ? hash.transform_keys_to_symbols : hash
+    end
+
+    # Set instance variable name
+    # @param [String, Symbol] name Name used when describing API test
+    # @param [Hash] options Parameters defining handler. Used in descendants
+    def initialize(name = self.class.to_s, options = {})
+      use
+      @name = name
+    end
+
+    # Set Api handler used by Exchange class to this handler
+    # @return [Self]
+    def use
+      Soaspec.api_handler = self
+      self
+    end
+
+    # Sets api handler variable globally. This is used in 'Exchange' class
+    # @return [String] Name set upon initialisation
+    def to_s
+      use
+      @name.to_s
+    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)
+      @request_option = :template
+      @template_name = name
+    end
+
+    # Will be used in 'success_scenarios' shared examples.
+    # Set though 'mandatory_elements' method
+    # @return [Array] Array of symbols specifying element names
+    def expected_mandatory_elements
+      []
+    end
+
+    # Change this through 'mandatory_xpath_values' method to specify xpath results that must be present in the response
+    # Will be used in 'success_scenarios' shared examples
+    # @return [Hash] Hash of 'xpath' => 'expected value' pairs
+    def expected_mandatory_xpath_values
+      {}
+    end
+
+    # Change this through 'mandatory_json_values' method to specify json results that must be present in the response
+    # Will be used in 'success_scenarios' shared examples
+    # @return [Hash] Hash of 'json/path' => 'expected value' pairs
+    def expected_mandatory_json_values
+      {}
+    end
+
+    # @return [Boolean] Whether all xpaths will be done with XML that is converted to lower case
+    def convert_to_lower?
+      false
+    end
+
+    # Stores a value in a method that can be accessed by the provided name
+    # @param [Symbol] name Name of method to use to access this value within handler
+    # @param [String] value Value to store
+    def store(name, value)
+      define_singleton_method('__stored_val__' + name.to_s) do
+        value
+      end
+    end
+
+    # Set instance variable and remove it from Hash
+    def set_remove_key(hash, key)
+      return unless hash.key? key
+      __send__("#{key}=", hash[key])
+      hash.delete key
+    end
+
+    # @return [Boolean] Whether to remove namespaces in xpath assertion automatically
+    def strip_namespaces?
+      false
+    end
+
+  end
 end

data/lib/soaspec/exchange_handlers/handler_accessors.rb

@@ -1,107 +1,107 @@
-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'
-    #
-    # In test
-    # describe Exchange(:name) do
-    #   it_behaves_like 'success scenario' # Includes xpath pair validation
-    # end
-    #
-    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') do
-        xpath_value_pairs
-      end
-    end
-
-    # Defines mandatory json path value pairs to be included in 'success scenario' shared example
-    #
-    # @example Inside class
-    #   mandatory_json_values '$..GetWeatherResult' => 'Found'
-    #
-    # In test
-    # describe Exchange(:name) do
-    #   it_behaves_like 'success scenario' # Includes json pair validation
-    # end
-    #
-    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') do
-        json_value_pairs
-      end
-    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)
-    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. If not set, this will default to @name
-    def attribute(name, attribute = nil)
-      attribute_used = attribute ? 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
-    def convert_to_lower(set)
-      return unless set
-      define_method('convert_to_lower?') do
-        true
-      end
-    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
-    def strip_namespaces(set)
-      return unless set
-      # Whether to remove namespaces in xpath assertion automatically
-      define_method('strip_namespaces?') do
-        true
-      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'
+    #
+    # In test
+    # describe Exchange(:name) do
+    #   it_behaves_like 'success scenario' # Includes xpath pair validation
+    # end
+    #
+    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') do
+        xpath_value_pairs
+      end
+    end
+
+    # Defines mandatory json path value pairs to be included in 'success scenario' shared example
+    #
+    # @example Inside class
+    #   mandatory_json_values '$..GetWeatherResult' => 'Found'
+    #
+    # In test
+    # describe Exchange(:name) do
+    #   it_behaves_like 'success scenario' # Includes json pair validation
+    # end
+    #
+    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') do
+        json_value_pairs
+      end
+    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)
+    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. If not set, this will default to @name
+    def attribute(name, attribute = nil)
+      attribute_used = attribute ? 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
+    def convert_to_lower(set)
+      return unless set
+      define_method('convert_to_lower?') do
+        true
+      end
+    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
+    def strip_namespaces(set)
+      return unless set
+      # Whether to remove namespaces in xpath assertion automatically
+      define_method('strip_namespaces?') do
+        true
+      end
+    end
+  end
 end

data/lib/soaspec/exchange_handlers/rest_accessors.rb

@@ -1,84 +1,98 @@
-module Soaspec
-  # Accessors specific to REST handler
-  module RestAccessors
-
-    # Defines method 'base_url_value' containing base URL used in REST requests
-    # @param [String] url Base Url to use in REST requests. Suburl is appended to this
-    def base_url(url)
-      define_method('base_url_value') do
-        url
-      end
-    end
-
-    # Will create access_token method based on passed parameters
-    def oauth2(params)# client_id: nil, client_secret: nil, token_url: nil, username: nil, password: nil, security_token: nil)
-      define_method('oauth_response') do
-        params[:username] = api_username || ERB.new(params[:username]).result(binding) if params[:username]
-        params[:security_token] = ERB.new(params[:security_token]).result(binding) if params[:security_token]
-        params[:token_url] = ERB.new(params[:token_url]).result(binding) if params[:token_url]
-        params[:password] = ERB.new(params[:password]).result(binding) if params[:password]
-        payload = if params[:password] && params[:username]
-                    {
-                      grant_type: 'password',
-                      client_id: params[:client_id],
-                      client_secret: params[:client_secret],
-                      username: params[:username],
-                      password: params[:security_token] ? (params[:password] + params[:security_token]) : params[:password],
-                      multipart: true
-                    }
-                  else
-                    {
-                      grant_type: 'client_credentials',
-                      client_id: params[:client_id],
-                      client_secret: params[:client_secret]
-                    }
-                  end
-        retry_count = 0
-        begin
-          Soaspec::SpecLogger.add_to 'request_params: ' + payload.to_s
-          response = RestClient.post(params[:token_url], payload, cache_control: 'no_cache', verify_ssl: false)
-        rescue RestClient::Exception => e
-          Soaspec::SpecLogger.add_to("oauth_error: #{e.message}")
-          Soaspec::SpecLogger.add_to("oauth_error: #{e.response}")
-          retry_count += 1
-          retry if retry_count < 3
-          raise e
-        end
-        Soaspec::SpecLogger.add_to("response_headers: #{response.headers}")
-        Soaspec::SpecLogger.add_to("response_body: #{response.body}")
-        JSON.parse(response)
-      end
-
-      define_method('access_token') do
-        oauth_response['access_token']
-      end
-      define_method('instance_url') do
-        oauth_response['instance_url']
-      end
-    end
-
-    # Pass path to YAML file containing OAuth2 parameters
-    # @param [String] path_to_filename Will have Soaspec.credentials_folder appended to it if set
-    def oauth2_file(path_to_filename)
-      full_path = Soaspec.credentials_folder ? File.join(Soaspec.credentials_folder, path_to_filename + '.yml') : path_to_filename + '.yml'
-      file_hash = YAML.load_file(full_path)
-      raise 'File at ' + full_path + ' is not a hash ' unless file_hash.is_a? Hash
-      oauth_hash = file_hash.transform_keys_to_symbols
-      oauth2 **oauth_hash
-    end
-
-    # @param [Hash] headers Hash of REST headers used in RestClient
-    def headers(headers)
-      define_method('rest_client_headers') do
-        headers
-      end
-    end
-
-    # Convert each key from snake_case to PascalCase
-    def pascal_keys(set)
-      define_method('pascal_keys?') do
-        set
-      end
-    end
-  end
+module Soaspec
+  # Accessors specific to REST handler
+  module RestAccessors
+
+    # Defines method 'base_url_value' containing base URL used in REST requests
+    # @param [String] url Base Url to use in REST requests. Suburl is appended to this
+    def base_url(url)
+      define_method('base_url_value') do
+        url
+      end
+    end
+
+
+
+    # Will create access_token method based on passed parameters
+    # @param [Hash] params Params client_id: nil, client_secret: nil, token_url: nil, username: nil, password: nil, security_token: nil
+    def oauth2(params)
+      define_method('oauth_payload') do |params|
+        if params[:password] && params[:username]
+          {
+            grant_type: 'password',
+            client_id: params[:client_id],
+            client_secret: params[:client_secret],
+            username: params[:username],
+            password: params[:security_token] ? (params[:password] + params[:security_token]) : params[:password],
+            multipart: true
+          }
+        else
+          {
+            grant_type: 'client_credentials',
+            client_id: params[:client_id],
+            client_secret: params[:client_secret]
+          }
+        end
+      end
+
+      define_method('oauth_response') do
+        params[:username] = api_username || ERB.new(params[:username]).result(binding) if params[:username]
+        params[:security_token] = ERB.new(params[:security_token]).result(binding) if params[:security_token]
+        params[:token_url] = ERB.new(params[:token_url]).result(binding) if params[:token_url]
+        params[:password] = ERB.new(params[:password]).result(binding) if params[:password]
+        payload = oauth_payload(params)
+        if Soaspec.debug_oauth?
+          request_message = "request_params: #{payload}"
+        else
+          params[:username] ? "User '#{params[:username]}'" : 'client_credentials'
+        end
+        Soaspec::SpecLogger.info request_message
+        retry_count = 0
+        begin
+          response = RestClient.post(params[:token_url], payload, cache_control: 'no_cache', verify_ssl: false)
+        rescue RestClient::Exception => e
+          Soaspec::SpecLogger.info("oauth_error: #{e.message}")
+          Soaspec::SpecLogger.info("oauth_response: #{e.response}")
+          retry_count += 1
+          retry if retry_count < 3
+          raise e
+        end
+        if Soaspec.debug_oauth?
+          Soaspec::SpecLogger.info("response_headers: #{response.headers}")
+          Soaspec::SpecLogger.info("response_body: #{response.body}")
+        end
+        JSON.parse(response)
+      end
+
+      define_method('access_token') do
+        oauth_response['access_token']
+      end
+      define_method('instance_url') do
+        oauth_response['instance_url']
+      end
+    end
+
+    # Pass path to YAML file containing OAuth2 parameters
+    # @param [String] path_to_filename Will have Soaspec.credentials_folder appended to it if set
+    def oauth2_file(path_to_filename)
+      full_path = Soaspec.credentials_folder ? File.join(Soaspec.credentials_folder, path_to_filename + '.yml') : path_to_filename + '.yml'
+      file_hash = YAML.load_file(full_path)
+      raise 'File at ' + full_path + ' is not a hash ' unless file_hash.is_a? Hash
+      oauth_hash = file_hash.transform_keys_to_symbols
+      oauth2 **oauth_hash
+    end
+
+    # @param [Hash] headers Hash of REST headers used in RestClient
+    def headers(headers)
+      define_method('rest_client_headers') do
+        headers
+      end
+    end
+
+    # Convert each key from snake_case to PascalCase
+    def pascal_keys(set)
+      define_method('pascal_keys?') do
+        set
+      end
+    end
+  end
 end