soaspec 0.2.23 → 0.2.24

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/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

data/lib/soaspec/exchange_handlers/rest_exchanger_factory.rb

@@ -1,109 +1,109 @@
-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
+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