soaspec 0.2.23 → 0.2.24

data/lib/soaspec/exchange/exchange_extractor.rb

@@ -1,83 +1,83 @@
-module Soaspec
-  # Methods for extracting aspects of the traffic for a request / response
-  # in an exchange from the ExchangeHandler that it's tied to
-  module ExchangeExtractor
-    # Request of API call. Either intended request or actual request
-    # @return [Object] Object representing request of API
-    def request
-      exchange_handler.request(@response)
-    end
-
-    # Get status code from api class. This is http response code for Web Api
-    # @return [Integer] Status code from api class
-    def status_code
-      exchange_handler.status_code_for(response)
-    end
-
-    # Extract value from path api class
-    # @example Extract unique value
-    #   @exchange['unique_value_name']
-    # @example Extract value via JSON path
-    #   @exchange['$..path.to.element']
-    # @example Extract value via XPath
-    #   @exchange['//path/to/element']
-    # @param [Object] path Path to return element for api class E.g - for SOAP this is XPath string. For JSON, this is Hash dig Array
-    # @return [String] Value at path
-    def [](path)
-      exchange_handler.value_from_path(response, path.to_s)
-    end
-
-    alias_method :value_from_path, :[]
-
-    # Using same path syntax as []. Returns true of false depending on whether an element is found
-    # @return [Boolean] Whether an element exists at the path
-    def element?(path)
-      self[path]
-      true
-    rescue NoElementAtPath
-      false
-    end
-
-    # @example Counting items in a JSON list
-    #   # Say there is JSON response {"notes":[{"title":"note1","note":"A note"},{"title":"note2"}]}
-    #   titles = @exchange.values_at_path('$..title')
-    #   expect(titles.count).to eq 2
-    #   expect(titles.first).to eq 'note1'
-    # @param [String] path XPath, JSONPath to extract value
-    # @param [String] attribute Attribute to obtain from XML element
-    # @return [Array] List of values found at path
-    def values_from_path(path, attribute: nil)
-      exchange_handler.values_from_path(response, path, attribute: attribute)
-    end
-
-    # Return the response equivalent of the response. XML, JSON will be converted to a Hash
-    # @example Counting items in a JSON list
-    #   # Say there is JSON response {"notes":[{"title":"note1","note":"A note"},{"title":"note2"}]}
-    #   hash = @exchange.to_hash
-    #   expect(hash['notes'].count).to eq 2
-    #   expect(hash['notes'].first['title']).to eq 'note1'
-    # @return [Hash] Hash representing the response of the API
-    def to_hash
-      exchange_handler.to_hash(response)
-    end
-
-    private
-
-    # Used to define methods on an exchange based on what's defined by the ExchangeHandler's methods
-    # @param [String] element Element to define methods for
-    def methods_for_element(element)
-      element_name = element.to_s.split('__custom_path_').last
-      define_singleton_method(element_name) do
-        exchange_handler.__send__(element, response) # Forward the call onto handler to retrieve the element for the response
-      end
-      define_singleton_method("#{element_name}?") do
-        begin
-          __send__ element_name
-          true
-        rescue NoElementAtPath
-          false
-        end
-      end
-    end
-  end
-end
+module Soaspec
+  # Methods for extracting aspects of the traffic for a request / response
+  # in an exchange from the ExchangeHandler that it's tied to
+  module ExchangeExtractor
+    # Request of API call. Either intended request or actual request
+    # @return [Object] Object representing request of API
+    def request
+      exchange_handler.request(@response)
+    end
+
+    # Get status code from api class. This is http response code for Web Api
+    # @return [Integer] Status code from api class
+    def status_code
+      exchange_handler.status_code_for(response)
+    end
+
+    # Extract value from path api class
+    # @example Extract unique value
+    #   @exchange['unique_value_name']
+    # @example Extract value via JSON path
+    #   @exchange['$..path.to.element']
+    # @example Extract value via XPath
+    #   @exchange['//path/to/element']
+    # @param [Object] path Path to return element for api class E.g - for SOAP this is XPath string. For JSON, this is Hash dig Array
+    # @return [String] Value at path
+    def [](path)
+      exchange_handler.value_from_path(response, path.to_s)
+    end
+
+    alias_method :value_from_path, :[]
+
+    # Using same path syntax as []. Returns true of false depending on whether an element is found
+    # @return [Boolean] Whether an element exists at the path
+    def element?(path)
+      self[path]
+      true
+    rescue NoElementAtPath
+      false
+    end
+
+    # @example Counting items in a JSON list
+    #   # Say there is JSON response {"notes":[{"title":"note1","note":"A note"},{"title":"note2"}]}
+    #   titles = @exchange.values_at_path('$..title')
+    #   expect(titles.count).to eq 2
+    #   expect(titles.first).to eq 'note1'
+    # @param [String] path XPath, JSONPath to extract value
+    # @param [String] attribute Attribute to obtain from XML element
+    # @return [Array] List of values found at path
+    def values_from_path(path, attribute: nil)
+      exchange_handler.values_from_path(response, path, attribute: attribute)
+    end
+
+    # Return the response equivalent of the response. XML, JSON will be converted to a Hash
+    # @example Counting items in a JSON list
+    #   # Say there is JSON response {"notes":[{"title":"note1","note":"A note"},{"title":"note2"}]}
+    #   hash = @exchange.to_hash
+    #   expect(hash['notes'].count).to eq 2
+    #   expect(hash['notes'].first['title']).to eq 'note1'
+    # @return [Hash] Hash representing the response of the API
+    def to_hash
+      exchange_handler.to_hash(response)
+    end
+
+    private
+
+    # Used to define methods on an exchange based on what's defined by the ExchangeHandler's methods
+    # @param [String] element Element to define methods for
+    def methods_for_element(element)
+      element_name = element.to_s.split('__custom_path_').last
+      define_singleton_method(element_name) do
+        exchange_handler.__send__(element, response) # Forward the call onto handler to retrieve the element for the response
+      end
+      define_singleton_method("#{element_name}?") do
+        begin
+          __send__ element_name
+          true
+        rescue NoElementAtPath
+          false
+        end
+      end
+    end
+  end
+end

data/lib/soaspec/exchange/exchange_properties.rb

@@ -1,26 +1,26 @@
-module Soaspec
-  # Convenience methods to set Exchange specific properties
-  # Will be used when creating a subclass of Exchange
-  module ExchangeProperties
-    # Set default exchange handler for this exchange
-    # This is helpful for when you need a new exchange handler created for each exchange
-    # @param [Class] handler_class Class of ExchangeHandler to set Exchange to use
-    # @param [String] name Name to call handler when it's instantiated (Defaults to class name)
-    # @param [Hash] params Hash of parameters to set for instance of ExchangeHandler
-    def default_handler(handler_class, name = handler_class.to_s, params = '')
-      define_method('default_handler_used') do
-        params_used = Hash[params.map do |k, param|
-          [k, param.is_a?(String) ? ERB.new(param).result(binding) : param]
-        end]
-        handler_class.new name, params_used
-      end
-    end
-
-    # Set retry_for_success to true, retrying response until a successful status code is returned
-    # @param [Integer] retry_count Times to retry to get a positive response
-    def expect_positive_status(retry_count: 3)
-      define_method('retry_count') { retry_count }
-      define_method('retry_for_success?') { true }
-    end
-  end
-end
+module Soaspec
+  # Convenience methods to set Exchange specific properties
+  # Will be used when creating a subclass of Exchange
+  module ExchangeProperties
+    # Set default exchange handler for this exchange
+    # This is helpful for when you need a new exchange handler created for each exchange
+    # @param [Class] handler_class Class of ExchangeHandler to set Exchange to use
+    # @param [String] name Name to call handler when it's instantiated (Defaults to class name)
+    # @param [Hash] params Hash of parameters to set for instance of ExchangeHandler
+    def default_handler(handler_class, name = handler_class.to_s, params = '')
+      define_method('default_handler_used') do
+        params_used = Hash[params.map do |k, param|
+          [k, param.is_a?(String) ? ERB.new(param).result(binding) : param]
+        end]
+        handler_class.new name, params_used
+      end
+    end
+
+    # Set retry_for_success to true, retrying response until a successful status code is returned
+    # @param [Integer] retry_count Times to retry to get a positive response
+    def expect_positive_status(retry_count: 3)
+      define_method('retry_count') { retry_count }
+      define_method('retry_for_success?') { true }
+    end
+  end
+end

data/lib/soaspec/exchange/exchange_repeater.rb

@@ -1,19 +1,19 @@
-module Soaspec
-  # Ways of repeating an exchange to reach a desired outcome
-  module ExchangeRepeater
-    # Wait until the passed block returns true
-    # @param [Hash] opts Options for this instance
-    # @option opts [Numeric] :timeout (5) Seconds to wait before timing out.
-    # @option opts [Numeric] :interval (0.2) Seconds to sleep between polls.
-    # @option opts [String] :message Exception message if timed out.
-    # @option opts [Array, Exception] :ignore Exceptions to ignore while polling (default: Error::NoSuchElementError)
-    # @return [Self] Returns itself so operations can be done on the exchange after it's done waiting
-    def until(opts = {}, &script)
-      Soaspec::Wait.until(opts) do
-        @response = nil # Reset response so it can be made repeatedly
-        instance_eval(&script)
-      end
-      self
-    end
-  end
-end
+module Soaspec
+  # Ways of repeating an exchange to reach a desired outcome
+  module ExchangeRepeater
+    # Wait until the passed block returns true
+    # @param [Hash] opts Options for this instance
+    # @option opts [Numeric] :timeout (5) Seconds to wait before timing out.
+    # @option opts [Numeric] :interval (0.2) Seconds to sleep between polls.
+    # @option opts [String] :message Exception message if timed out.
+    # @option opts [Array, Exception] :ignore Exceptions to ignore while polling (default: Error::NoSuchElementError)
+    # @return [Self] Returns itself so operations can be done on the exchange after it's done waiting
+    def until(opts = {}, &script)
+      Soaspec::Wait.until(opts) do
+        @response = nil # Reset response so it can be made repeatedly
+        instance_eval(&script)
+      end
+      self
+    end
+  end
+end

data/lib/soaspec/exchange/request_builder.rb

@@ -1,68 +1,68 @@
-module Soaspec
-  # Methods to help build a Request
-  module RequestBuilder
-    # Specify a url to add onto the base_url of the ExchangeHandler used
-    # @param [String] url Url to add onto the base_url of the ExchangeHandler used
-    def suburl=(url)
-      @override_parameters[:suburl] = url
-    end
-
-    # Specify HTTP method to use. Default is :post
-    # @param [Symbol] method HTTP method. E.g, :get, :patch
-    def method=(method)
-      @override_parameters[:method] = method
-    end
-
-    # Set a parameter request in the request body.
-    # Can be used to build a request over several steps (e.g Cucumber)
-    # Will be used with FactoryBot
-    #
-    # @example
-    #   exchange['name'] = 'tester'
-    #   # Will set { name: tester } in the response, formatting as JSON or XML depending on REST / SOAP
-    # @param [String, Symbol] key Name of request element to set
-    # @param [String] value Value to set request element to
-    def []=(key, value)
-      @override_parameters[:body] ||= {}
-      @override_parameters[:body][key] = value
-    end
-
-    # Implement undefined setter with []= for FactoryBot to use without needing to define params to set
-    # @param [Object] method_name Name of method not defined
-    # @param [Object] args Arguments passed to method
-    # @param [Object] block Block passed to method
-    def method_missing(method_name, *args, &block)
-      set_value = args.first
-      if method_name[-1] == '=' # A setter method
-        getter_name = method_name[0..-2]
-        if set_value.class < Exchange # This would be prerequisite exchange
-          define_singleton_method(getter_name) { set_value }
-          self[getter_name] = set_value.id if set_value.respond_to?(:id)
-        else
-          self[getter_name] = set_value
-        end
-      else
-        super
-      end
-    end
-
-    # Used for setters that are not defined
-    # @param [String] method_name Name of method
-    # @param [Array] args List of arguments to method
-    def respond_to_missing?(method_name, *args)
-      method_name[-1] == '=' || super
-    end
-
-    # Makes request, caching the response and returning self
-    # Used by FactoryBot
-    # @return [Self] Return itself so methods can be called on itself afterwards
-    def save!
-      @retry_for_success = @fail_factory ? false : true
-      previous_setting = Soaspec.log_warnings
-      Soaspec.log_warnings = false # Don't log this warning as result of call not being used
-      call
-      Soaspec.log_warnings = previous_setting
-      self
-    end
-  end
-end
+module Soaspec
+  # Methods to help build a Request
+  module RequestBuilder
+    # Specify a url to add onto the base_url of the ExchangeHandler used
+    # @param [String] url Url to add onto the base_url of the ExchangeHandler used
+    def suburl=(url)
+      @override_parameters[:suburl] = url
+    end
+
+    # Specify HTTP method to use. Default is :post
+    # @param [Symbol] method HTTP method. E.g, :get, :patch
+    def method=(method)
+      @override_parameters[:method] = method
+    end
+
+    # Set a parameter request in the request body.
+    # Can be used to build a request over several steps (e.g Cucumber)
+    # Will be used with FactoryBot
+    #
+    # @example
+    #   exchange['name'] = 'tester'
+    #   # Will set { name: tester } in the response, formatting as JSON or XML depending on REST / SOAP
+    # @param [String, Symbol] key Name of request element to set
+    # @param [String] value Value to set request element to
+    def []=(key, value)
+      @override_parameters[:body] ||= {}
+      @override_parameters[:body][key] = value
+    end
+
+    # Implement undefined setter with []= for FactoryBot to use without needing to define params to set
+    # @param [Object] method_name Name of method not defined
+    # @param [Object] args Arguments passed to method
+    # @param [Object] block Block passed to method
+    def method_missing(method_name, *args, &block)
+      set_value = args.first
+      if method_name[-1] == '=' # A setter method
+        getter_name = method_name[0..-2]
+        if set_value.class < Exchange # This would be prerequisite exchange
+          define_singleton_method(getter_name) { set_value }
+          self[getter_name] = set_value.id if set_value.respond_to?(:id)
+        else
+          self[getter_name] = set_value
+        end
+      else
+        super
+      end
+    end
+
+    # Used for setters that are not defined
+    # @param [String] method_name Name of method
+    # @param [Array] args List of arguments to method
+    def respond_to_missing?(method_name, *args)
+      method_name[-1] == '=' || super
+    end
+
+    # Makes request, caching the response and returning self
+    # Used by FactoryBot
+    # @return [Self] Return itself so methods can be called on itself afterwards
+    def save!
+      @retry_for_success = @fail_factory ? false : true
+      previous_setting = Soaspec.log_warnings
+      Soaspec.log_warnings = false # Don't log this warning as result of call not being used
+      call
+      Soaspec.log_warnings = previous_setting
+      self
+    end
+  end
+end

data/lib/soaspec/exchange/variable_storer.rb

@@ -1,22 +1,22 @@
-module Soaspec
-  # Enables Exchange to store and retrieve variables so that one
-  # exchange can make assertions based on a previous one
-  module VariableStorer
-    # Stores a value in the api handler 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 Path to value to store
-    def store(name, value)
-      exchange_handler.store(name, self[value])
-    end
-
-    # Retrieve the stored value from the Api Handler
-    # @param [String, Symbol] name Name of value to retrieve
-    # @return [Object] value from the Api Handler stored previously
-    def retrieve(name)
-      method = '__stored_val__' + name.to_s
-      raise ArgumentError('Value not stored at ') unless exchange_handler.respond_to? method
-
-      exchange_handler.send(method)
-    end
-  end
-end
+module Soaspec
+  # Enables Exchange to store and retrieve variables so that one
+  # exchange can make assertions based on a previous one
+  module VariableStorer
+    # Stores a value in the api handler 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 Path to value to store
+    def store(name, value)
+      exchange_handler.store(name, self[value])
+    end
+
+    # Retrieve the stored value from the Api Handler
+    # @param [String, Symbol] name Name of value to retrieve
+    # @return [Object] value from the Api Handler stored previously
+    def retrieve(name)
+      method = '__stored_val__' + name.to_s
+      raise ArgumentError('Value not stored at ') unless exchange_handler.respond_to? method
+
+      exchange_handler.send(method)
+    end
+  end
+end

data/lib/soaspec/exchange_handlers/exchange_handler.rb

@@ -1,126 +1,126 @@
-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
-
-    def self.use
-      new.use
-    end
-
-    # 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 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
-      @request_option = :hash
-      raise ArgumentError, 'Cannot define both template_name and default_hash' if respond_to?(:template_name_value) && respond_to?(:default_hash_value)
-
-      @template_name = respond_to?(:template_name_value) ? template_name_value : ''
-      @default_hash = respond_to?(:default_hash_value) ? default_hash_value : {}
-      @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 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 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) { value }
-    end
-
-    # Set instance variable for each key in hash remove it from Hash
-    # @param [Hash] hash with items to remove from
-    # @param [Array] keys List of keys to remove from hash, setting each one
-    def set_remove_keys(hash, keys)
-      keys.each { |key| set_remove_key(hash, key) }
-    end
-
-    # Set instance variable and remove it from Hash
-    # @param [Hash] hash Hash to remove/retrieve keys from
-    # @param [String,Symbol] key Key to remove and to set instance variable for
-    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
-
-    # Request of API call. Either intended request or actual request
-    # @param [Object] response Response from calling exchange
-    def request(response)
-      return "Request not yet sent Request option is #{@request_option}" unless response
-
-      'Specific API handler should implement this'
-    end
-  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
+
+    def self.use
+      new.use
+    end
+
+    # 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 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
+      @request_option = :hash
+      raise ArgumentError, 'Cannot define both template_name and default_hash' if respond_to?(:template_name_value) && respond_to?(:default_hash_value)
+
+      @template_name = respond_to?(:template_name_value) ? template_name_value : ''
+      @default_hash = respond_to?(:default_hash_value) ? default_hash_value : {}
+      @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 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 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) { value }
+    end
+
+    # Set instance variable for each key in hash remove it from Hash
+    # @param [Hash] hash with items to remove from
+    # @param [Array] keys List of keys to remove from hash, setting each one
+    def set_remove_keys(hash, keys)
+      keys.each { |key| set_remove_key(hash, key) }
+    end
+
+    # Set instance variable and remove it from Hash
+    # @param [Hash] hash Hash to remove/retrieve keys from
+    # @param [String,Symbol] key Key to remove and to set instance variable for
+    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
+
+    # Request of API call. Either intended request or actual request
+    # @param [Object] response Response from calling exchange
+    def request(response)
+      return "Request not yet sent Request option is #{@request_option}" unless response
+
+      'Specific API handler should implement this'
+    end
+  end
+end