client-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 354bd06d34542ca2e3010787df486062955a1bed02e442085dad030bb93fa8fd
+  data.tar.gz: 7992b72abafc9da352d16ae1a8e47f84daaa21b41b79b6954b3bea5ec1f3fc97
+SHA512:
+  metadata.gz: 5efb106c06984cc6544c846dc66eacca7af085576b285ca71f00802498f9fd75057fa4ffc299e1238f7ee7adb5d75162014f81db5fa6283c325740cdf26324b4
+  data.tar.gz: 9d9132ed137314a0b828fa56073efdca4a437abeda66731faecea9ada65dbabe23d822bc34b9a3a7cfa0f92d6533c0e1ef396ae63e8606277803337ea2bf129e

data/lib/client-api.rb

@@ -0,0 +1,17 @@
+require "client-api/version"
+require "client-api/settings"
+require "client-api/base"
+require "client-api/request"
+require "client-api/validator"
+require "client-api/loggers"
+
+RSpec.configure do |config|
+  config.add_setting :base_url
+  config.add_setting :headers
+  config.add_setting :basic_auth
+  config.add_setting :json_output
+  config.add_setting :time_out
+  config.include ClientApi
+end
+
+include Loggers

data/lib/client-api/base.rb

@@ -0,0 +1,72 @@
+require_relative 'request'
+
+module ClientApi
+
+  class Api < ClientApi::Request
+
+    include ClientApi
+
+    def get(url, headers = nil)
+      @output = get_request(url, :headers => headers)
+      post_logger if $logger
+    end
+
+    def post(url, body, headers = nil)
+      @output = post_request(url, :body => body, :headers => headers)
+      post_logger if $logger
+    end
+
+    def delete(url, headers = nil)
+      @output = delete_request(url, :headers => headers)
+      post_logger if $logger
+    end
+
+    def put(url, body, headers = nil)
+      @output = put_request(url, :body => body, :headers => headers)
+      post_logger if $logger
+    end
+
+    def patch(url, body, headers = nil)
+      @output = patch_request(url, :body => body, :headers => headers)
+      post_logger if $logger
+    end
+
+    def status
+      @output.code.to_i
+    end
+
+    def body
+      if [200, 201, 204].include? status
+        unless json_output['Dirname'] == nil
+          FileUtils.mkdir_p "#{json_output['Dirname']}"
+          File.open("./output/#{json_output['Filename']}.json", "wb") {|file| file.puts JSON.pretty_generate(JSON.parse(@output.body))}
+        end
+        JSON.parse(@output.body)
+      else
+        JSON.parse(@output.message)
+      end
+    end
+
+    def message
+      @output.message
+    end
+
+    def post_logger
+      (@output.body.nil? || @output.body == "{}") ? res_body = 'empty response body' : res_body = body
+
+      $logger.debug("Response code == #{@output.code.to_i}")
+      $logger.debug("Response body == #{res_body}")
+      $logger.debug("=====================================================================================")
+    end
+
+    alias :code :status
+    alias :resp :body
+  end
+
+  def payload(path)
+    JSON.parse(File.read(path))
+  end
+
+  alias :schema_from_json :payload
+
+end

data/lib/client-api/loggers.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+module Loggers
+
+  def logger=(logs)
+    output_logs_dir = logs['Dirname']
+    output_logs_filename = logs['Filename']
+
+    now = (Time.now.to_f * 1000).to_i
+    $logger = Logger.new(STDOUT)
+    $logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+    Dir.mkdir("./#{output_logs_dir}") unless File.exist?("./#{output_logs_dir}")
+
+    if logs['StoreFilesCount'] && (logs['StoreFilesCount'] != nil || logs['StoreFilesCount'] != {} || logs['StoreFilesCount'] != empty)
+      file_count = Dir["./#{output_logs_dir}/*.log"].length
+      Dir["./#{output_logs_dir}/*.log"].sort_by {|f| File.ctime(f)}.reverse.last(file_count - "#{logs['StoreFilesCount']}".to_i).map {|junk_file| File.delete(junk_file)} if file_count > logs['StoreFilesCount']
+    end
+
+    $logger = Logger.new(File.new("#{output_logs_dir}/#{output_logs_filename}_#{now}.log", 'w'))
+    $logger.level = Logger::DEBUG
+  end
+end

data/lib/client-api/request.rb

@@ -0,0 +1,74 @@
+module ClientApi
+
+  class Request
+
+    include ClientApi
+
+    def get_request(url, options = {})
+      connect(url)
+      pre_logger(:log_url => uri(url), :log_header => header(options), :log_method => 'GET') if $logger
+      @http.get(uri(url).request_uri, initheader = header(options))
+    end
+
+    def post_request(url, options = {})
+      body = options[:body] || {}
+      connect(url)
+      pre_logger(:log_url => uri(url), :log_header => header(options), :log_body => body, :log_method => 'POST') if $logger
+      @http.post(uri(url).path, body.to_json, initheader = header(options))
+    end
+
+    def delete_request(url, options = {})
+      connect(url)
+      pre_logger(:log_url => uri(url), :log_header => header(options), :log_method => 'DELETE') if $logger
+      @http.delete(uri(url).path, initheader = header(options))
+    end
+
+    def put_request(url, options = {})
+      body = options[:body] || {}
+      connect(url)
+      pre_logger(:log_url => uri(url), :log_header => header(options), :log_body => body, :log_method => 'PUT') if $logger
+      @http.put(uri(url).path, body.to_json, initheader = header(options))
+    end
+
+    def patch_request(url, options = {})
+      body = options[:body] || {}
+      connect(url)
+      pre_logger(:log_url => uri(url), :log_header => header(options), :log_body => body, :log_method => 'PATCH') if $logger
+      @http.patch(uri(url).path, body.to_json, initheader = header(options))
+    end
+
+    def uri(args)
+      %w[http://, https://].any? {|protocol| args.include? protocol} ? URI.parse(args) : URI.parse(base_url + args)
+    end
+
+    def connect(args)
+      http = Net::HTTP.new(uri(args).host, uri(args).port)
+
+      if uri(args).scheme == "https"
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http.read_timeout = time_out.to_i
+        @http = http
+      end
+    end
+
+    def basic_encode(options = {})
+      'Basic ' + ["#{options[:username]}:#{options[:password]}"].pack('m0')
+    end
+
+    def header(options = {})
+      mod_headers = options[:headers] || {}
+      headers['Authorization'] = basic_encode(:username => basic_auth['Username'], :password => basic_auth['Password'])
+      headers.merge(mod_headers)
+    end
+
+    def pre_logger(options = {})
+      options[:log_body] = 'not available' if options[:log_body].nil?
+      $logger.debug("Requested method == #{options[:log_method]}")
+      $logger.debug("Requested url == #{options[:log_url]}")
+      $logger.debug("Requested headers == #{options[:log_header]}")
+      $logger.debug("Requested body == #{options[:log_body]}")
+    end
+  end
+
+end

data/lib/client-api/settings.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+module ClientApi
+
+  def self.configure
+    RSpec.configure do |config|
+      yield config
+    end
+  end
+
+  def self.configuration
+    RSpec.configuration
+  end
+
+  def base_url
+    ClientApi.configuration.base_url || ''
+  end
+
+  def headers
+    ClientApi.configuration.headers || ''
+  end
+
+  def basic_auth
+    ClientApi.configuration.basic_auth || ''
+  end
+
+  def json_output
+    ClientApi.configuration.json_output || ''
+  end
+
+  def time_out
+    ClientApi.configuration.time_out || ''
+  end
+
+end

data/lib/client-api/validator.rb

@@ -0,0 +1,180 @@
+require "json-schema"
+
+module ClientApi
+
+  def validate(res, *options)
+    options.map do |data|
+      raise_error('key (or) operator is not given!') if data[:key].nil? && data[:operator].nil?
+      raise_error('value (or) type is not given!') if data[:value].nil? && data[:type].nil?
+
+      @resp = res
+      key = data[:key].split("->")
+
+      key.map do |method|
+        method = method.to_i if is_num?(method)
+        @resp = @resp.send(:[], method)
+      end
+
+      value ||= data[:value]
+      operator = data[:operator]
+      type = data[:type] if data[:type] || data[:type] != {} || !data[:type].empty?
+
+      case operator
+      when '=', '==', 'eql?', 'equal', 'equal?'
+        # value validation
+        expect(value).to eq(@resp) if value != nil
+
+        # datatype validation
+        if (type == "boolean" || type == "bool") && value.nil?
+          expect(%w[TrueClass, FalseClass].any? {|bool| @resp.class.to_s.include? bool}).to be true
+        else
+          expect(datatype(type, value)).to eq(@resp.class)
+        end
+
+      when '!', '!=', '!eql?', 'not equal', '!equal?'
+        # value validation
+        expect(value).not_to eq(@resp) if value != nil
+
+        # datatype validation
+        if (type == "boolean" || type == "bool") && value.nil?
+          expect(%w[TrueClass, FalseClass].any? {|bool| @resp.class.to_s.include? bool}).not_to be true
+        else
+          expect(datatype(type, value)).not_to eq(@resp.class)
+        end
+      else
+        raise_error('operator not matching')
+      end
+    end
+  end
+
+  def validate_schema(param1, param2)
+    expected_schema = JSON::Validator.validate(param1, param2)
+    expect(expected_schema).to be true
+  end
+
+  def datatype(type, value)
+    if (type.downcase == 'string') || (type.downcase.== 'str')
+      String
+    elsif (type.downcase.== 'integer') || (type.downcase.== 'int')
+      Integer
+    elsif (type.downcase == 'symbol') || (type.downcase == 'sym')
+      Symbol
+    elsif (type.downcase == 'array') || (type.downcase == 'arr')
+      Array
+    elsif (type.downcase == 'object') || (type.downcase == 'obj')
+      Object
+    elsif (type.downcase == 'boolean') || (type.downcase == 'bool')
+      value === true ? TrueClass : FalseClass
+    elsif type.downcase == 'float'
+      Float
+    elsif type.downcase == 'hash'
+      Hash
+    elsif type.downcase == 'complex'
+      Complex
+    elsif type.downcase == 'rational'
+      Rational
+    elsif type.downcase == 'fixnum'
+      Fixnum
+    elsif type.downcase == 'falseclass'
+      FalseClass
+    elsif type.downcase == 'trueclass'
+      TrueClass
+    elsif type.downcase == 'bignum'
+      Bignum
+    else
+    end
+  end
+
+  def is_num?(str)
+    if Float(str)
+      true
+    end
+  rescue ArgumentError, TypeError
+    false
+  end
+
+  def validate_json(actual, expected)
+    param1 = JSON.parse(actual.to_json)
+    param2 = JSON.parse(expected.to_json)
+
+    @actual_key, @actual_value = [], []
+    deep_traverse(param2) do |path, value|
+      if !value.is_a?(Hash)
+        key_path = path.map! {|k| k}
+        @actual_key << key_path.join("->").to_s
+        @actual_value << value
+      end
+    end
+
+    Hash[@actual_key.zip(@actual_value)].map do |data|
+      @resp = param1
+      key = data[0].split("->")
+
+      key.map do |method|
+        method = method.to_i if is_num?(method)
+        @resp = @resp.send(:[], method)
+      end
+
+      value = data[1]
+      @assert, @final_assert, @overall = [], [], []
+
+      if !value.is_a?(Array)
+        expect(value).to eq(@resp)
+      else
+        @resp.each_with_index do |resp, i|
+          value.to_a.each_with_index do |val1, j|
+            val1.to_a.each_with_index do |val2, k|
+              if resp.to_a.include? val2
+                @assert << true
+              else
+                @assert << false
+              end
+            end
+            @final_assert << @assert
+            @assert = []
+
+            if @resp.count == @final_assert.count
+              @final_assert.each_with_index do |result, i|
+                if result.count(true) == val1.count
+                  @overall << true
+                  break
+                elsif @final_assert.count == i+1
+                  expect(value).to eq(@resp)
+                end
+              end
+              @final_assert = []
+            end
+
+          end
+        end
+
+        if @overall.count(true) == value.count
+          return
+        else
+          expect(value).to eq(@resp)
+        end
+
+      end
+    end
+  end
+
+  def deep_traverse(hash, &block)
+    stack = hash.map {|k, v| [[k], v]}
+
+    while not stack.empty?
+      key, value = stack.pop
+      yield(key, value)
+      if value.is_a? Hash
+        value.each do |k, v|
+          if v.is_a?(String) then
+            if v.empty? then
+              v = nil
+            end
+          end
+          stack.push [key.dup << k, v]
+        end
+      end
+    end
+  end
+
+end

data/lib/client-api/version.rb

@@ -0,0 +1,3 @@
+module ClientApi
+  VERSION = "0.1.0".freeze
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: client-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- prashanth-sams
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: client-api helps you write api tests quickly using rspec with different
+  levels of validations
+email:
+- sams.prashanth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/client-api.rb
+- lib/client-api/base.rb
+- lib/client-api/loggers.rb
+- lib/client-api/request.rb
+- lib/client-api/settings.rb
+- lib/client-api/validator.rb
+- lib/client-api/version.rb
+homepage: https://github.com/prashanth-sams/client-api
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/prashanth-sams/client-api
+  source_code_uri: https://github.com/prashanth-sams/client-api
+  documentation_uri: https://www.rubydoc.info/github/prashanth-sams/client-api/master
+  bug_tracker_uri: https://github.com/prashanth-sams/client-api/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: HTTP Rest API client for RSpec Api Test framework
+test_files: []