rb-net_http-client 0.0.4

data/lib/rb-net_http-client.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'client/client'
+require_relative 'version'

data/lib/request/ext.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../core/core'
+require_relative 'schema'
+
+module NetHTTP
+  module Request
+    module Ext
+      def call_web_service(opts = {})
+        logger = Core.assign_logger(self.logger ||= opts[:logger])
+
+        Core.schema_validation(opts, NetHTTP::Request::Schema, logger) unless opts[:enforce_schema_validation] == false
+
+        method = (opts[:method] ||= opts[:req_method] ||= opts[:request_method] ||= 'post').to_s.upcase
+        uri = Core.parse_uri(opts[:uri] ||= opts[:url] ||= self.uri)
+        path = opts[:path] ||= opts[:req_path] ||= opts[:request_path] ||= opts[:path] ||= uri.path ||= self.path
+        path = (path + '?' + uri.query) unless uri.query.nil? || path.include?('?')
+        headers = opts[:headers] ||= opts[:req_headers] ||= opts[:request_headers] ||= {}
+        body = opts[:body] ||= opts[:req_body] ||= opts[:request_body] ||= nil
+
+        resp = case method
+               when 'DELETE'
+                 logger.debug('Request Method => ' + method)
+                 logger.debug('Request Host => ' + uri.host.to_s)
+                 logger.debug('Request Path => ' + path)
+                 delete(path)
+               when 'GET'
+                 logger.debug('Request Method => ' + method)
+                 logger.debug('Request Host => ' + uri.host.to_s)
+                 logger.debug('Request Path => ' + path)
+                 logger.debug('Request Headers =>')
+                 logger.debug(headers)
+                 get(path, headers)
+               when 'POST'
+                 logger.debug('Request Method => ' + method)
+                 logger.debug('Request Host => ' + uri.host.to_s)
+                 logger.debug('Request Path => ' + path)
+                 logger.debug('Request Headers =>')
+                 logger.debug(headers)
+                 logger.debug('Request Body =>')
+                 logger.debug(body)
+                 post(path, body, headers)
+               when 'POST_FORM', 'POST_FORM_DATA'
+                 logger.debug('Request Method => ' + method)
+                 logger.debug('Request Host => ' + uri.host.to_s)
+                 logger.debug('Request Path => ' + path)
+                 logger.debug('Request Headers =>')
+                 logger.debug(headers)
+                 logger.debug('Request Body =>')
+                 logger.debug(URI.encode_www_form(body))
+                 post(uri, URI.encode_www_form(body), headers)
+               when 'PUT'
+                 logger.debug('Request Method => ' + method)
+                 logger.debug('Request Host => ' + uri.host.to_s)
+                 logger.debug('Request Path => ' + path)
+                 logger.debug('Request Headers =>')
+                 logger.debug(headers)
+                 logger.debug('Request Body =>')
+                 logger.debug(body)
+                 put(path, body, headers)
+               else
+                 logger.debug("Request method => '#{method}' not yet supported.")
+                 raise "Request method => '#{method}' not yet supported."
+               end
+        logger.debug('Response Code => ' + resp.code)
+        logger.debug('Response Headers => ')
+        logger.debug(resp.headers)
+        logger.debug('Response Body => ')
+        logger.debug(resp.body)
+        resp
+      end
+
+      alias call_api call_web_service
+      alias call_service call_web_service
+      alias execute_request call_web_service
+      alias send_request call_web_service
+      alias submit_request call_web_service
+    end
+  end
+end
+
+module Net
+  class HTTP
+    include NetHTTP::Core
+    include NetHTTP::Request::Ext
+  end
+end

data/lib/request/schema.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-validation'
+
+module NetHTTP
+  module Request
+    Schema = Dry::Validation.Schema do
+      optional(:req_method).filled(type?: String)
+      optional(:method).filled(type?: String)
+      optional(:req_headers).maybe(type?: Hash)
+      optional(:headers).maybe(type?: Hash)
+      optional(:req_body).maybe
+      optional(:body).maybe
+
+      rule(if_url_and_uri_are_nil_must_provide_path: [:uri, :url, :path]) do |uri, url, path|
+        uri.empty?.then(url.empty?.then(path.filled?))
+      end
+    end
+  end
+end

data/lib/response/ext.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'nokogiri'
+require 'ostruct'
+require_relative '../core/core'
+require_relative '../core/utilities'
+
+module NetHTTP
+  module Response
+    module Ext
+      def resp_code
+        code
+      end
+
+      alias response_code resp_code
+
+      def headers
+        resp_headers = {}
+        headers = to_hash
+        headers.each do |key, value|
+          resp_headers[key] = value.flatten[0].to_s
+        end
+      end
+
+      alias resp_headers headers
+      alias response_headers headers
+
+      def headers_hash
+        NetHTTP::Core::Utilities.convert_hash_keys(
+          object: headers,
+          format: 'snake',
+          type: 'symbol'
+        )
+      end
+
+      alias resp_headers_hash headers_hash
+      alias response_headers_hash headers_hash
+
+      def headers_os
+        JSON.parse(headers_hash.to_json, object_class: OpenStruct)
+      end
+
+      alias resp_headers_os headers_os
+      alias response_headers_os headers_os
+      alias headers_open_struct headers_os
+      alias resp_headers_struct headers_os
+      alias response_headers_open_struct headers_os
+
+      def resp_body
+        body
+      end
+
+      alias response_body resp_body
+
+      def body_hash
+        begin
+          return NetHTTP::Core::Utilities.json_2_hash(body, 'symbol', logger) if valid_json?
+        rescue JSON::ParserError => err
+          logger.debug(err)
+        end
+        begin
+          return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_xml?
+        rescue Nokogiri::XML::SyntaxError => err
+          logger.debug(err)
+        end
+        begin
+          # TODO: update this to work if necessary
+          # probably makes more sense to parse HTML using nokogiri
+          return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_html?
+        rescue Nokogiri::XML::SyntaxError => err
+          logger.debug(err)
+        end
+
+        {}
+      end
+
+      alias resp_body_hash body_hash
+      alias response_body_hash body_hash
+
+      def body_os
+        JSON.parse(body_hash.to_json, object_class: OpenStruct)
+      end
+
+      alias resp_body_os body_os
+      alias response_body_os body_os
+      alias body_open_struct body_os
+      alias resp_body_open_struct body_os
+      alias response_body_open_struct body_os
+
+      def valid_json?
+        NetHTTP::Core::Utilities.valid_json?(body, logger)
+      end
+
+      def valid_xml?
+        NetHTTP::Core::Utilities.valid_xml?(body, logger)
+      end
+
+      def valid_html?
+        NetHTTP::Core::Utilities.valid_html?(body, logger)
+      end
+    end
+  end
+end
+
+module Net
+  class HTTPResponse
+    include NetHTTP::Core
+    include NetHTTP::Response::Ext
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NetHTTP
+  VERSION = '0.0.4'
+end

data/spec/integration/net_http/client/client_ext_spec.rb

@@ -0,0 +1,7 @@
+require_relative '../../../spec_helper'
+
+describe NetHTTP::Client::Ext do
+  # it '' do
+  #
+  # end
+end

data/spec/integration/net_http/client/client_spec.rb

@@ -0,0 +1,7 @@
+require_relative '../../../spec_helper'
+
+describe 'NetHTTP.client' do
+  # it '' do
+  #
+  # end
+end

data/spec/integration/net_http/net_http_core_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../spec_helper'
+
+describe NetHTTP::Core do
+  it 'returns schema validation errors when invalid options are used to instantiate a NetHTTP client' do
+    client_opts = {}
+
+    expect { NetHTTP.client(client_opts) } .to raise_error('NetHTTP::Core::Error - schema input validation failed.')
+  end
+
+  it 'returns schema validation errors when invalid options are used to instantiate a NetHTTP client with logger' do
+    client_opts = {}
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    client_opts[:logger] = logger
+
+    expect { NetHTTP.client(client_opts) } .to raise_error('NetHTTP::Core::Error - schema input validation failed.')
+  end
+end

data/spec/integration/net_http/request/request_ext_spec.rb

@@ -0,0 +1,342 @@
+require_relative '../../../spec_helper'
+describe 'NetHTTP::Request::Ext.call_web_service' do
+	it 'performs a GET request from http://eelslap.com/' do
+		client_opts = {}
+		client_opts[:uri] = 'http://eelslap.com/'
+		client_opts[:use_ssl] = false
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:req_headers] = {}
+		request_opts[:req_method] = 'get'
+		request_opts[:req_path] = '/'
+
+		resp = client.call_web_service(request_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_html?).to eq(true)
+		expect(NetHTTP::Core.valid_html?(resp.body, nil)).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash).to eq({})
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash).to eq({})
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+
+	it 'performs a GET request from http://eelslap.com/ with logger' do
+		client_opts = {}
+		client_opts[:uri] = 'http://eelslap.com/'
+		client_opts[:use_ssl] = false
+
+		logger = Logger.new(STDOUT)
+		logger.level = Logger::DEBUG
+		client_opts[:logger] = logger
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:logger] = client.logger
+		request_opts[:req_headers] = {}
+		request_opts[:req_method] = 'get'
+		request_opts[:req_path] = '/'
+
+		resp = client.call_web_service(request_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_html?).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash).to eq({})
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash).to eq({})
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+
+	it 'performs a GET request from http://eelslap.com/ without uri' do
+		client_opts = {}
+		client_opts[:host] = 'eelslap.com'
+		client_opts[:port] = 80
+		client_opts[:path] = '/'
+		client_opts[:use_ssl] = false
+
+		logger = Logger.new(STDOUT)
+		logger.level = Logger::INFO
+		client_opts[:logger] = logger
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:logger] = client.logger
+		request_opts[:req_headers] = {}
+		request_opts[:req_method] = 'get'
+		request_opts[:req_path] = '/'
+
+		resp = client.call_web_service(request_opts)
+
+		logger.debug('Response Code => ' + resp.code)
+		logger.debug('Response Headers =>')
+		logger.debug(resp.headers)
+		logger.debug('')
+		logger.debug('Response Body =>')
+		logger.debug(resp.body)
+		logger.debug('')
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_html?).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash).to eq({})
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash).to eq({})
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+
+	it 'performs a POST request for a valid oAuth token from ESG' do
+		client_opts = {}
+		client_opts[:uri] = 'https://esg-qa-oauth2-internal.fmr.com/as/resourceOwner'
+		client_opts[:use_ssl] = true
+
+		logger = Logger.new(STDOUT)
+		logger.level = Logger::INFO
+		client_opts[:logger] = logger
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:logger] = client.logger
+		request_opts[:req_method] = 'post'
+		request_opts[:req_headers] = {'Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8'}
+
+		user_id = ENV['USER_ID']
+		password = ENV['PASSWORD']
+		client_id = 'd6bcd5e1-29d7-4ec0-9b96-215b3a317fd6'
+		client_secret = 'e391e6aa-4d60-4470-b351-0f84f11495a8'
+		grant_type = 'password'
+		scope = 'AppIdClaimsTrust'
+		request_opts[:req_body] = "username=#{user_id}&password=#{password}&client_id=#{client_id}&client_secret=#{client_secret}&grant_type=#{grant_type}&scope=#{scope}"
+		request_opts[:req_path] = '/as/resourceOwner'
+
+		resp = client.call_web_service(request_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_json?).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash.empty?).to eq(false)
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash.empty?).to eq(false)
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+
+	it 'performs a POST request for a valid oAuth token from ESG with scheme without uri' do
+		client_opts = {}
+		client_opts[:use_ssl] = true
+		client_opts[:scheme] = 'https'
+		client_opts[:host] = 'esg-qa-oauth2-internal.fmr.com'
+		client_opts[:path] = '/as/resourceOwner'
+
+		logger = Logger.new(STDOUT)
+		logger.level = Logger::INFO
+		client_opts[:logger] = logger
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:logger] = client.logger
+		request_opts[:req_method] = 'post'
+		request_opts[:req_headers] = {'Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8'}
+
+		user_id = ENV['USER_ID']
+		password = ENV['PASSWORD']
+		client_id = 'd6bcd5e1-29d7-4ec0-9b96-215b3a317fd6'
+		client_secret = 'e391e6aa-4d60-4470-b351-0f84f11495a8'
+		grant_type = 'password'
+		scope = 'AppIdClaimsTrust'
+		request_opts[:req_body] = "username=#{user_id}&password=#{password}&client_id=#{client_id}&client_secret=#{client_secret}&grant_type=#{grant_type}&scope=#{scope}"
+		request_opts[:req_path] = '/as/resourceOwner'
+
+		resp = client.call_web_service(request_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_json?).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash.empty?).to eq(false)
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash.empty?).to eq(false)
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+
+	it 'performs a POST request for a valid oAuth token from ESG without scheme without uri' do
+		client_opts = {}
+		client_opts[:use_ssl] = true
+		client_opts[:host] = 'esg-qa-oauth2-internal.fmr.com'
+		client_opts[:port] = 443
+		client_opts[:path] = '/as/resourceOwner'
+
+		logger = Logger.new(STDOUT)
+		logger.level = Logger::INFO
+		client_opts[:logger] = logger
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:logger] = client.logger
+		request_opts[:req_method] = 'post'
+		request_opts[:req_headers] = {'Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8'}
+
+		user_id = ENV['USER_ID']
+		password = ENV['PASSWORD']
+		client_id = 'd6bcd5e1-29d7-4ec0-9b96-215b3a317fd6'
+		client_secret = 'e391e6aa-4d60-4470-b351-0f84f11495a8'
+		grant_type = 'password'
+		scope = 'AppIdClaimsTrust'
+		request_opts[:req_body] = "username=#{user_id}&password=#{password}&client_id=#{client_id}&client_secret=#{client_secret}&grant_type=#{grant_type}&scope=#{scope}"
+		request_opts[:req_path] = '/as/resourceOwner'
+
+		resp = client.call_web_service(request_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_json?).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash.empty?).to eq(false)
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash.empty?).to eq(false)
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+
+	it 'performs a POST request to MAUI to retrieve account users using ssl and cert' do
+		client_opts = {}
+		client_opts[:uri] = 'https://alpha-mmk.fmr.com:9980/XML_FEB_S_A'
+		client_opts[:ssl_path] = '/apps/security'
+		client_opts[:ca_file] = 'cacert.pem'
+		client_opts[:pkcs12_file] = 'dev-b2b-fidcom.p12'
+		client_opts[:pkcs12_passphrase] = ENV['PKCS12_PASSPHRASE']
+		client_opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+
+		# logger = Logger.new(STDOUT)
+		# logger.level = Logger::DEBUG
+		# client_opts[:logger] = logger
+
+		client = NetHTTP.client(client_opts)
+
+		req_opts = {}
+		req_opts[:req_method] = 'post'
+		req_opts[:req_headers] = {'Content-Type' => 'application/xml'}
+		req_opts[:req_body] = '<?xml version="1.0" encoding="utf-16"?>
+<DCLCUST0_REQUEST>
+  <PSL_VIEW>DCLCUST0.VIEW</PSL_VIEW>
+  <REQUESTOR_ID>024300218</REQUESTOR_ID>
+  <PRODUCT_ID>W</PRODUCT_ID>
+  <MESSAGE_TYPE>F</MESSAGE_TYPE>
+  <FUNCTION_INDICATOR>V</FUNCTION_INDICATOR>
+  <PARTITION_ID>RETAIL</PARTITION_ID>
+  <RELATIONSHIP_TYPE/>
+  <INCLUDE_4P_REL>Y</INCLUDE_4P_REL>
+  <PRM_KEY_TYPE>B</PRM_KEY_TYPE>
+  <PRIMARY_KEY>X01000833</PRIMARY_KEY>
+  <RETURN_PRODUCT_G_NBR_IND/>
+  <INPUT_VIEW>
+    <PAGING>
+      <PAGING_MAX_COUNT>All</PAGING_MAX_COUNT>
+      <PAGING_DIRECTION>F</PAGING_DIRECTION>
+      <PAGING_CONTINUATION_KEY/>
+    </PAGING>
+  </INPUT_VIEW>
+</DCLCUST0_REQUEST>'
+
+		resp = client.call_web_service(req_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_xml?).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash.empty?).to eq(false)
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash.empty?).to eq(false)
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+	it 'performs a GET request from http://eelslap.com/ with query' do
+		client_opts = {}
+		client_opts[:uri] = 'http://eelslap.com/?req=aaaa'
+		client_opts[:use_ssl] = false
+
+		client = NetHTTP.client(client_opts)
+
+		request_opts = {}
+		request_opts[:req_headers] = {}
+		request_opts[:req_method] = 'get'
+		request_opts[:req_path] = '/?req=aaaa'
+		resp = client.call_web_service(request_opts)
+
+		expect(resp.code).to eq('200')
+		expect(resp.resp_code).to eq('200')
+		expect(resp.headers.empty?).to eq(false)
+		expect(resp.resp_headers.empty?).to eq(false)
+		expect(resp.headers_hash.empty?).to eq(false)
+		expect(resp.headers_hash.class).to eq(Hash)
+		expect(resp.resp_headers_hash.empty?).to eq(false)
+		expect(resp.resp_headers_hash.class).to eq(Hash)
+		expect(resp.valid_html?).to eq(true)
+		expect(NetHTTP::Core.valid_html?(resp.body, nil)).to eq(true)
+		expect(resp.body.empty?).to eq(false)
+		expect(resp.resp_body.empty?).to eq(false)
+		expect(resp.body_hash).to eq({})
+		expect(resp.body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash).to eq({})
+		expect(resp.resp_body_hash.class).to eq(Hash)
+		expect(resp.resp_body_hash.class).to eq(Hash)
+	end
+end