rb-net_http-client 1.0.1 → 1.0.2

data/lib/response/response.rb

@@ -3,58 +3,71 @@
 require 'json'
 require 'nokogiri'
 require 'ostruct'
-require_relative 'schema'
 require_relative '../core/core'
 require_relative '../core/utilities'
 
 module NetHTTP
   class Response
-    attr_reader :logger,
+    attr_reader :code,
+                :body,
+                :body_obj,
+                :body_os,
+                :headers,
+                :headers_hash,
+                :headers_os,
+                :logger,
                 :response
 
     def initialize(opts = {})
       send('logger=', opts[:logger])
-      puts opts[:response].class
-      Core.schema_validation(opts, NetHTTP::Response::Schema, logger) unless opts[:enforce_schema_validation] == false
       @response = opts[:response]
+      send('response=', opts[:response])
+      send('code=')
+      send('headers=')
+      send('headers_hash=')
+      send('headers_os=')
+      send('body=')
+      send('body_obj=')
+      send('body_os=')
       log_response
     end
 
     alias resp response
 
-    def body
-      response.body
+    def body=
+      @body = response.body
     end
 
     alias resp_body body
     alias response_body body
 
-    def body_hash
+    def body_obj=
+      @body_obj = {}
       begin
-        return NetHTTP::Core::Utilities.json_2_hash(body, 'symbol', logger) if valid_json?
-      rescue JSON::ParserError => err
-        logger.debug(err)
+        @body_obj = NetHTTP::Core::Utilities.json_2_hash(body, 'symbol', logger) if valid_json?
+      rescue JSON::ParserError => error
+        logger.debug(error)
       end
       begin
-        return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_xml?
-      rescue Nokogiri::XML::SyntaxError => err
-        logger.debug(err)
+        @body_obj = NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_xml?
+      rescue Nokogiri::XML::SyntaxError => error
+        logger.debug(error)
       end
       begin
         # TODO: revisit this if necessary
-        return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_html?
-      rescue Nokogiri::XML::SyntaxError => err
-        logger.debug(err)
+        @body_obj = NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_html?
+      rescue Nokogiri::XML::SyntaxError => error
+        logger.debug(error)
       end
-
-      {}
     end
 
-    alias resp_body_hash body_hash
-    alias response_body_hash body_hash
+    # TODO: remove this eventually
+    alias body_hash body_obj
+    alias resp_body_obj body_obj
+    alias response_body_obj body_obj
 
-    def body_os
-      JSON.parse(body_hash.to_json, object_class: OpenStruct)
+    def body_os=
+      @body_os = JSON.parse(body_obj.to_json, object_class: OpenStruct)
     end
 
     alias resp_body_os body_os
@@ -63,24 +76,25 @@ module NetHTTP
     alias resp_body_open_struct body_os
     alias response_body_open_struct body_os
 
-    def code
-      response.code
+    def code=
+      @code = response.code
     end
 
     alias resp_code code
     alias response_code code
 
-    def headers
-      response_headers = {}
+    def headers=
+      @headers = {}
       response.to_hash.each do |key, value|
-        response_headers[key] = value.flatten[0].to_s
+        @headers[key] = value.flatten[0].to_s
       end
     end
 
     alias resp_headers headers
     alias response_headers headers
 
-    def headers_hash
+    def headers_hash=
+      @headers_hash = {}
       NetHTTP::Core::Utilities.convert_hash_keys(
         object: headers,
         format: 'snake',
@@ -91,8 +105,8 @@ module NetHTTP
     alias resp_headers_hash headers_hash
     alias response_headers_hash headers_hash
 
-    def headers_os
-      JSON.parse(headers_hash.to_json, object_class: OpenStruct)
+    def headers_os=
+      @headers_os = JSON.parse(headers_hash.to_json, object_class: OpenStruct)
     end
 
     alias resp_headers_os headers_os
@@ -101,6 +115,10 @@ module NetHTTP
     alias resp_headers_struct headers_os
     alias response_headers_open_struct headers_os
 
+    def response=(response)
+      @response = response
+    end
+
     def valid_json?
       NetHTTP::Core::Utilities.valid_json?(body, logger)
     end

data/lib/version.rb

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

data/spec/unit/client/client_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+describe 'NetHTTP.client' do
+  it 'returns a valid NetHTTP client instance' do
+    ENV['http_proxy'] = nil
+    ENV['https_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+    ENV['HTTPS_PROXY'] = nil
+
+    net_http_client = NetHTTP.client(
+      uri: 'https://jsonplaceholder.typicode.com/posts'
+    )
+
+    expect(net_http_client.class).to eq(NetHTTP::Client)
+    expect(net_http_client.logger.class).to eq(Logger)
+    expect(net_http_client.logger.level).to eq(Logger::INFO)
+    expect(net_http_client.uri.to_s).to eq('https://jsonplaceholder.typicode.com/posts')
+    expect(net_http_client.proxy_uri.to_s).to eq('')
+    expect(net_http_client.use_ssl).to eq(true)
+    expect(net_http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+    expect(net_http_client.open_timeout).to eq(60)
+    expect(net_http_client.read_timeout).to eq(60)
+  end
+
+  it 'returns a valid NetHTTP client instance' do
+    ENV['http_proxy'] = nil
+    ENV['https_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+    ENV['HTTPS_PROXY'] = nil
+
+    net_http_client = NetHTTP::Client.new(
+      uri: 'https://jsonplaceholder.typicode.com/posts'
+    )
+
+    expect(net_http_client.class).to eq(NetHTTP::Client)
+    expect(net_http_client.logger.class).to eq(Logger)
+    expect(net_http_client.logger.level).to eq(Logger::INFO)
+    expect(net_http_client.uri.to_s).to eq('https://jsonplaceholder.typicode.com/posts')
+    expect(net_http_client.proxy_uri.to_s).to eq('')
+    expect(net_http_client.use_ssl).to eq(true)
+    expect(net_http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+    expect(net_http_client.open_timeout).to eq(60)
+    expect(net_http_client.read_timeout).to eq(60)
+  end
+end

data/spec/unit/client/ext_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+describe 'NetHTTP::Client ext' do
+  it 'returns a valid NetHTTP client instance with proxy_uri -> URI' do
+    net_http_client = NetHTTP.client(
+      uri: 'https://jsonplaceholder.typicode.com/posts',
+      proxy_uri: 'http://proxy.com:8888'
+    )
+
+    expect(net_http_client.class).to eq(NetHTTP::Client)
+    expect(net_http_client.proxy_uri.to_s).to eq('http://proxy.com:8888')
+  end
+
+  it 'returns a valid NetHTTP client instance with proxy_uri -> ""' do
+    expect {
+      NetHTTP.client(
+        uri: 'https://jsonplaceholder.typicode.com/posts',
+        proxy_uri: ''
+      )
+    }.to raise_error(RuntimeError, /NetHTTP::Core::SchemaValidationError/)
+  end
+
+  it 'returns a valid NetHTTP client instance with proxy_uri -> nil' do
+    expect {
+      NetHTTP.client(
+        uri: 'https://jsonplaceholder.typicode.com/posts',
+        proxy_uri: nil
+      )
+    }.to raise_error(RuntimeError, /NetHTTP::Core::SchemaValidationError/)
+  end
+
+  it 'returns a valid NetHTTP client instance with proxy_uri -> INVALID' do
+    expect {
+      NetHTTP.client(
+        uri: 'https://jsonplaceholder.typicode.com/posts',
+        proxy_uri: 12345
+      )
+    }.to raise_error(RuntimeError, /NetHTTP::Core::SchemaValidationError/)
+  end
+
+  it 'returns a valid NetHTTP client instance' do
+    ENV['http_proxy'] = nil
+    ENV['https_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+    ENV['HTTPS_PROXY'] = nil
+
+    net_http_client = NetHTTP.client(
+      scheme: 'https',
+      host: 'jsonplaceholder.typicode.com',
+      port: 443,
+      path: '/posts'
+    )
+
+    expect(net_http_client.class).to eq(NetHTTP::Client)
+    expect(net_http_client.logger.class).to eq(Logger)
+    expect(net_http_client.logger.level).to eq(Logger::INFO)
+    expect(net_http_client.uri.to_s).to eq('https://jsonplaceholder.typicode.com/posts')
+    expect(net_http_client.proxy_uri.to_s).to eq('')
+    expect(net_http_client.use_ssl).to eq(true)
+    expect(net_http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+    expect(net_http_client.open_timeout).to eq(60)
+    expect(net_http_client.read_timeout).to eq(60)
+  end
+
+  it 'returns a valid NetHTTP client instance' do
+    ENV['http_proxy'] = nil
+    ENV['https_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+    ENV['HTTPS_PROXY'] = nil
+
+    net_http_client = NetHTTP.client(
+      scheme: 'https',
+      host: 'jsonplaceholder.typicode.com',
+      port: 443,
+      path: '/posts'
+    )
+
+    expect(net_http_client.class).to eq(NetHTTP::Client)
+    expect(net_http_client.logger.class).to eq(Logger)
+    expect(net_http_client.logger.level).to eq(Logger::INFO)
+    expect(net_http_client.uri.to_s).to eq('https://jsonplaceholder.typicode.com/posts')
+    expect(net_http_client.proxy_uri.to_s).to eq('')
+    expect(net_http_client.use_ssl).to eq(true)
+    expect(net_http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+    expect(net_http_client.open_timeout).to eq(60)
+    expect(net_http_client.read_timeout).to eq(60)
+  end
+end

data/spec/unit/core/core_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+describe 'NetHTTP::Core' do
+  it 'successful schema_validation' do
+    logger = NetHTTP::Core.get_logger
+
+    results = NetHTTP::Core.schema_validation(
+      {
+        uri: 'https://www.google.com'
+      },
+      NetHTTP::Client::Schema,
+      logger
+    )
+
+    expect(results).to eq(nil)
+  end
+
+  it 'failed schema_validation' do
+    logger = NetHTTP::Core.get_logger
+
+    expect {
+      NetHTTP::Core.schema_validation(
+        {
+          uri: nil
+        },
+        NetHTTP::Client::Schema,
+        logger
+      )
+    }.to raise_error(RuntimeError)
+  end
+
+  it 'failed schema_validation -> invalid schema' do
+    logger = NetHTTP::Core.get_logger
+
+    expect {
+      NetHTTP::Core.schema_validation(
+        {
+          uri: 'https://www.google.com'
+        },
+        'Invalid::Schema',
+        logger
+      )
+    }.to raise_error(NoMethodError, "undefined method `call' for \"Invalid::Schema\":String")
+  end
+end

data/spec/unit/core/utilities_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+describe 'NetHTTP::Core::Utilities' do
+  it 'constructs valid URI' do
+    uri = {
+      scheme: 'https',
+      host: 'www.google.com',
+      port: 443,
+      path: '/search',
+      query: 'q=ruby+uri'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq('https://www.google.com/search?q=ruby+uri')
+    expect(uri.class).to eq(String)
+
+    parsed_uri = URI(uri)
+    expect(parsed_uri.scheme).to eq('https')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(443)
+    expect(parsed_uri.path).to eq('/search')
+    expect(parsed_uri.query).to eq('q=ruby+uri')
+  end
+
+  it 'constructs valid URI when uri[:scheme] is missing' do
+    uri = {
+      host: 'www.google.com',
+      port: 443,
+      path: '/search',
+      query: 'q=ruby+uri'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq('https://www.google.com/search?q=ruby+uri')
+    expect(uri.class).to eq(String)
+
+    parsed_uri = URI(uri)
+    expect(parsed_uri.scheme).to eq('https')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(443)
+    expect(parsed_uri.path).to eq('/search')
+    expect(parsed_uri.query).to eq('q=ruby+uri')
+  end
+
+  it 'constructs valid URI when uri[:port] is missing' do
+    uri = {
+      scheme: 'https',
+      host: 'www.google.com',
+      path: '/search',
+      query: 'q=ruby+uri'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq('https://www.google.com/search?q=ruby+uri')
+    expect(uri.class).to eq(String)
+
+    parsed_uri = URI(uri)
+    expect(parsed_uri.scheme).to eq('https')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(443)
+    expect(parsed_uri.path).to eq('/search')
+    expect(parsed_uri.query).to eq('q=ruby+uri')
+  end
+
+  it 'constructs valid URI when uri[:scheme] is missing' do
+    uri = {
+      host: 'www.google.com',
+      port: 80,
+      path: '/search',
+      query: 'q=ruby+uri'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq('http://www.google.com/search?q=ruby+uri')
+    expect(uri.class).to eq(String)
+
+    parsed_uri = URI(uri)
+    expect(parsed_uri.scheme).to eq('http')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(80)
+    expect(parsed_uri.path).to eq('/search')
+    expect(parsed_uri.query).to eq('q=ruby+uri')
+  end
+
+  it 'constructs valid URI when uri[:port] is missing' do
+    uri = {
+      scheme: 'http',
+      host: 'www.google.com',
+      path: '/search',
+      query: 'q=ruby+uri'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq('http://www.google.com/search?q=ruby+uri')
+    expect(uri.class).to eq(String)
+
+    parsed_uri = URI(uri)
+    expect(parsed_uri.scheme).to eq('http')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(80)
+    expect(parsed_uri.path).to eq('/search')
+    expect(parsed_uri.query).to eq('q=ruby+uri')
+  end
+
+  it 'constructs valid URI when uri[:port], uri[:path], uri[:query] are missing' do
+    uri = {
+      scheme: 'https',
+      host: 'www.google.com'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq('https://www.google.com')
+    expect(uri.class).to eq(String)
+
+    parsed_uri = URI(uri)
+    expect(parsed_uri.scheme).to eq('https')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(443)
+    expect(parsed_uri.path).to eq('')
+    expect(parsed_uri.query).to eq(nil)
+  end
+
+  it 'construct uri returns nil if uri is empty' do
+    uri = {
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq(nil)
+  end
+
+  it 'construct uri returns nil if uri[:host] is missing' do
+    uri = {
+      host: nil
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq(nil)
+  end
+
+  it 'construct uri returns nil if uri[:scheme] && uri[:port] are missing' do
+    uri = {
+      host: 'www.google.com',
+      path: '/search'
+    }
+
+    uri = NetHTTP::Core::Utilities.construct_uri(uri)
+    expect(uri).to eq(nil)
+  end
+
+  it 'parses valid uri when no scheme is provided, only port => 443' do
+    uri = 'www.google.com:443'
+
+    parsed_uri = NetHTTP::Core::Utilities.parse_uri(uri)
+    expect(parsed_uri.scheme).to eq('https')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(443)
+    expect(parsed_uri.path).to eq('')
+    expect(parsed_uri.query).to eq(nil)
+  end
+
+  it 'parses valid uri when no scheme is provided, only port => 80' do
+    uri = 'www.google.com:80'
+
+    parsed_uri = NetHTTP::Core::Utilities.parse_uri(uri)
+    expect(parsed_uri.scheme).to eq('http')
+    expect(parsed_uri.host).to eq('www.google.com')
+    expect(parsed_uri.port).to eq(80)
+    expect(parsed_uri.path).to eq('')
+    expect(parsed_uri.query).to eq(nil)
+  end
+
+  it 'checks if valid xml document is valid XML' do
+    xml_doc = '''
+<note>
+<to>Tove</to>
+<from>Jani</from>
+<heading>Reminder</heading>
+<body>Do not forget me this weekend!</body>
+</note>
+    '''
+
+    valid_xml = NetHTTP::Core::Utilities.valid_xml?(xml_doc)
+    expect(valid_xml).to eq(true)
+  end
+
+  it 'checks if valid html document is valid HTML' do
+    html_doc = '''
+<!DOCTYPE html>
+<html>
+<body>
+<h1>My First Heading</h1>
+<p>My first paragraph.</p>
+</body>
+</html>
+    '''
+
+    valid_html = NetHTTP::Core::Utilities.valid_html?(html_doc)
+    expect(valid_html).to eq(true)
+  end
+
+  it 'checks if invalid xml document is valid XML' do
+    xml_doc = '''
+<note>
+<to>Tove</to>
+<from>Jani</from>
+<heading>Reminder</heading>
+<body>Do not forget me this weekend!</body>
+    '''
+
+    valid_xml = NetHTTP::Core::Utilities.valid_xml?(xml_doc)
+    expect(valid_xml).to eq(false)
+  end
+
+  it 'checks if invalid html document is valid HTML' do
+    html_doc = '''
+<!DOCTYPE html>
+<html>
+<body>
+<h1>My First Heading
+<p>My first paragraph.
+</body>
+</html>
+    '''
+
+    valid_html = NetHTTP::Core::Utilities.valid_html?(html_doc)
+    expect(valid_html).to eq(false)
+  end
+end