swgr2rb 1.0.0

data/assets/endpoint_object_models/prototypes/json_schema_data_types.rb

@@ -0,0 +1,3 @@
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end

data/assets/endpoint_object_models/prototypes/request.rb

@@ -0,0 +1,31 @@
+class Request
+  attr_reader :type, :headers, :body, :subdomain, :endpoint_name
+
+  def initialize(endpoint_name, type, headers, body)
+    @endpoint_name = endpoint_name
+    @type = type
+    @headers = headers
+    @body = body
+    process_request_type
+  end
+
+  def url
+    generate_url
+  end
+
+  private
+
+  def process_request_type
+    if type.split(' ').length > 1
+      @type = type.split(' ').join('_')
+    end
+  end
+
+  def generate_url
+    configs = ConductorConfigLoader.load
+
+    "#{configs.connection.protocol}"\
+    "#{configs.connection.host}:#{configs.connection.port}"\
+    "#{endpoint_name}"
+  end
+end

data/assets/features/step_definitions/base_steps.rb

@@ -0,0 +1,56 @@
+Given(/^I send "([^"]*)" request to "([^"]*)"(?: with using results of ([^"]*) request to "([^"]*)" endpoint)?$/) do |request_type, endpoint_name, sub_request_type, sub_endpoint_name|
+  request_type = request_type.sub(' ', '_')
+  endpoint_instances["#{request_type}_#{endpoint_name}"] = eval("#{endpoint_name.split(' ').map(&:capitalize).join}.new")
+  if sub_request_type && sub_endpoint_name
+    sub_results = endpoint_instances["#{sub_request_type}_#{sub_endpoint_name}"].results
+  else
+    sub_results = {}
+  end
+  endpoint_instances["#{request_type}_#{endpoint_name}"].send_request(request_type, nil, sub_results)
+end
+
+Given(/^I send "([^"]*)" request to "([^"]*)" with the following properties(?: with using results of ([^"]*) request to "([^"]*)" endpoint)?:$/) do |request_type, endpoint_name, sub_request_type, sub_endpoint_name, table|
+  request_type = request_type.sub(' ', '_')
+  endpoint_instances["#{request_type}_#{endpoint_name}"] = eval("#{endpoint_name.split(' ').map(&:capitalize).join}.new")
+  if sub_request_type && sub_endpoint_name
+    sub_results = endpoint_instances["#{sub_request_type}_#{sub_endpoint_name}"].results
+  else
+    sub_results = {}
+  end
+  endpoint_instances["#{request_type}_#{endpoint_name}"].send_request(request_type,
+                                                                      table.hashes.first, sub_results)
+end
+
+Given(/^I send "([^"]*)" request to "([^"]*)"(?: with the following properties)? with using results of the following requests:$/) do |request_type, endpoint_name, table|
+  request_type = request_type.sub(' ', '_')
+  endpoint_instances["#{request_type}_#{endpoint_name}"] = eval("#{endpoint_name.split(' ').map(&:capitalize).join}.new")
+  sub_results = {}
+  table.hashes.first[:sub_requests].split(/;\s*/).map do |sub_request_str|
+    match_data = sub_request_str.match(/^(?<request_type>\w+) (?<endpoint_name>.+)$/)
+    sub_results[match_data[:endpoint_name]] = endpoint_instances["#{match_data[:request_type]}_#{match_data[:endpoint_name]}"].results
+  end
+  params = table.hashes.first.reject { |k, _v| k.to_sym == :sub_requests }
+  endpoint_instances["#{request_type}_#{endpoint_name}"].send_request(request_type, params, sub_results)
+end
+
+And(/^the response schema for "([^"]*)" request to "([^"]*)" endpoint should be valid$/) do |request_type, endpoint_name|
+  request_type = request_type.sub(' ', '_')
+  endpoint_instances["#{request_type}_#{endpoint_name}"].validate_response_schema
+end
+
+And(/^the error response for "([^"]*)" request to "([^"]*)" endpoint should be valid with ([^"]*) code$/) do |request_type, endpoint_name, error_code|
+  request_type = request_type.sub(' ', '_')
+  endpoint_instances["#{request_type}_#{endpoint_name}"].validate_error_response(error_code.to_i)
+end
+
+And(/^I wait (\d+) seconds/) do |seconds|
+  sleep(seconds)
+end
+
+And(/^I (do|do not do) this: (.*[^:])$/) do |do_or_not, step_str|
+  step step_str if do_or_not == 'do'
+end
+
+And(/^I (do|do not do) this: (.*:)$/) do |do_or_not, step_str, table|
+  step step_str, table if do_or_not == 'do'
+end

data/assets/features/support/env.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# This is the entry point for Cucumber
+
+require_relative 'world'
+
+World do
+  World.new
+end

data/assets/features/support/instance_variables.rb

@@ -0,0 +1,9 @@
+module InstanceVariables
+  attr_accessor :endpoint_instances
+
+  def initialize_instance_variables
+    @endpoint_instances = {}
+    @db_query_results = {}
+    @broker_results = {}
+  end
+end

data/assets/features/support/world.rb

@@ -0,0 +1,12 @@
+require_relative '../../endpoint_object_models/loader'
+require_relative '../../request_sender/loader'
+require_relative 'instance_variables'
+require 'base64'
+
+class World
+  include InstanceVariables
+
+  def initialize
+    initialize_instance_variables
+  end
+end

data/assets/request_sender/conductor_sender/conductor_sender.rb

@@ -0,0 +1,53 @@
+require 'httparty'
+require_relative 'response'
+
+class ConductorSender
+  class << self
+    def send_request(request)
+      response = send("send_#{request.type}_request",
+                      request)
+
+      Response.new(response)
+    end
+
+    private
+
+    def send_post_request(request)
+      HTTParty.post(request.url, body: request.body, headers: request.headers, verify: false)
+    end
+
+    def send_multipart_post_request(request)
+      cmd = "curl -k -i --verbose --request POST "\
+            " --form 'file=@#{request.body[:filePath]}'"\
+            " -H 'Content-Type: #{request.headers[:'Content-Type']}'"\
+            " -H 'Authorization: #{request.headers[:'Authorization']}'"\
+            " #{request.url}"
+
+      `#{cmd}`
+    end
+
+    def send_get_request(request)
+      HTTParty.get(request.url, query: request.body, headers: request.headers, verify: false)
+    end
+
+    def send_put_request(request)
+      HTTParty.put(request.url, body: request.body, headers: request.headers, verify: false)
+    end
+
+    def send_delete_request(request)
+      HTTParty.delete(request.url, query: request.body, headers: request.headers, verify: false)
+    end
+
+    def send_head_request(request)
+      HTTParty.head(request.url, query: request.body, headers: request.headers, verify: false)
+    end
+
+    def send_patch_request(request)
+      HTTParty.patch(request.url, query: request.body, headers: request.headers, verify: false)
+    end
+
+    def send_options_request(request)
+      HTTParty.options(request.url, query: request.body, headers: request.headers, verify: false)
+    end
+  end
+end

data/assets/request_sender/conductor_sender/response.rb

@@ -0,0 +1,105 @@
+class Response
+  attr_accessor :code, :headers, :body
+
+  def initialize(response)
+    @response = response
+    check_response
+  end
+
+  private
+
+  def check_response
+    case @response
+    when String
+      begin
+        hash_ = JSON.parse(@response)
+        if hash_
+          @code = 200
+          @headers = ''
+          @body = convert_hash(hash_)
+          return
+        end
+      rescue
+      end
+    end
+
+    if @response.nil? || (@response.respond_to?(:body) && %w[null true false].include?(@response.body))
+      handle_nil_response
+    else
+      handle_response
+    end
+  end
+
+  def convert_hash(base_hash)
+    return base_hash unless base_hash.is_a? Hash
+    temp_hash = base_hash.dup
+    base_hash.each do |k, v|
+      case v
+      when Hash
+        temp_hash[k.to_sym] = convert_hash(v)
+      when Array
+        temp_hash[k.to_sym] = v.map { |v_el| convert_hash(v_el) }
+      else
+        temp_hash = temp_hash.inject({}) { |memo, (k1, v1)| memo[k1.to_sym] = v1; memo }
+      end
+    end
+    temp_hash
+  end
+
+  def handle_nil_response
+    @code = @response.code
+    @headers = @response.headers
+
+    if @code == 204
+      raise 'Received non-null body in 204 No Content response' unless @response.body.nil?
+      @body = nil
+    else
+      case @response.body
+      when 'null', ''
+        @body = {}
+      when 'true'
+        @body = true
+      when 'false'
+        @body = false
+      else
+        raise 'Not implemented behavior for the empty response'
+      end
+    end
+  end
+
+  def handle_response
+    case @response
+    when String
+      @code = (@response.match /(HTTP Status|HTTP\/2) \d{3}/).to_s.split(' ')[-1].to_i
+      content_type = if @response.match?(/content-type: (.*);/)
+                       @response.match(/content-type: (.*);/)[1]
+                     else
+                       'text/html'
+                     end
+      @headers = {
+          "ContentType": content_type
+      }
+      @body = if @response.match?(/{.*}/)
+                convert_hash(JSON.parse(@response.match(/{.*}/)[0]))
+              else
+                @response
+              end
+      return
+    else
+      @code = @response.code
+      @headers = @response.headers
+    end
+    if @headers&.content_type == 'application/json'
+      @body = if @response.parsed_response.is_a? Array
+                @response.parsed_response.map { |i| convert_hash(i)}
+              elsif @response.parsed_response.is_a? Integer
+                @response.parsed_response
+              else
+                convert_hash(@response.parsed_response)
+              end
+    else
+      # parsed response is string
+      @body = @response.parsed_response
+    end
+  end
+end

data/assets/request_sender/loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+puts 'Loading Request sender component'
+
+def recursive_require(dir)
+  Dir["#{File.dirname(__FILE__)}/#{dir}/**/*.rb"].each do |f|
+    require(f)
+  end
+end
+
+dirs = Dir.entries(File.dirname(__FILE__)).select { |entry| File.directory? File.join(File.dirname(__FILE__), entry) and !(entry == '.' || entry == '..') }
+dirs.each do |dir|
+  recursive_require(dir)
+end
+
+puts 'Done loading Request sender component'

data/bin/swgr2rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$VERBOSE = nil
+require 'swgr2rb'
+begin
+  Swgr2rb::Main.new(ARGV).execute
+rescue Swgr2rb::Swgr2rbError => e
+  abort(e.message)
+end

data/lib/cli/cli_options_parser.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'swgr2rb'
+
+module Swgr2rb
+  # CliOptionsParser parses arguments received from
+  # command line and generates parameters for endpoint generation.
+  class CliOptionsParser
+    def initialize
+      @params = default_params
+    end
+
+    def parse(args)
+      option_parser = OptionParser.new do |parser|
+        define_options(parser)
+      end
+      parse_options(option_parser, args)
+      path = parse_swagger_path_from_args(args)
+      [path, @params]
+    end
+
+    private
+
+    def default_params
+      {
+        target_dir: ScaffoldGeneratorConstants::ENDPOINT_MODELS_DIR,
+        component: 'component1',
+        update_only: false,
+        rewrite_schemas: true,
+        from_scratch: false
+      }
+    end
+
+    def define_options(opts)
+      define_banner(opts)
+      define_target_dir_option(opts)
+      define_component_option(opts)
+      define_update_only_option(opts)
+      define_rewrite_schemas_option(opts)
+      define_from_scratch_option(opts)
+      define_help_option(opts)
+    end
+
+    def parse_options(options_parser, args)
+      options_parser.parse(args)
+    rescue OptionParser::ParseError => e
+      raise Swgr2rbError, e.message
+    end
+
+    def parse_swagger_path_from_args(args)
+      path = args[0]
+      if path.nil? || !(url?(path) || json_file_path?(path))
+        raise Swgr2rbError,
+              "Provided Swagger URL/file path '#{path}' is neither "\
+              'a URL nor a path of an existing JSON file'
+      end
+      path.to_s
+    end
+
+    def define_banner(opts)
+      opts.banner = "Usage:\tswgr2rb SWAGGER_URL|FILE_PATH [OPTIONS]"
+      opts.separator("\nTo generate a new testing framework from scratch:\n\t"\
+                     'swgr2rb SWAGGER_URL|FILE_PATH --from-scratch'\
+                     " [-c COMPONENT]\n\n"\
+                     "To update an existing testing framework:\n\t"\
+                     'swgr2rb SWAGGER_URL|FILE_PATH [-t TARGET_DIR]'\
+                     "[-c COMPONENT]\n\t"\
+                     '     [--[no-]update-only] [--[no-]rewrite-schemas]')
+      opts.separator('')
+      opts.separator('Options:')
+    end
+
+    def define_target_dir_option(opts)
+      opts.on('-t TARGET_DIR', '--target-dir TARGET_DIR', String,
+              'Target directory for endpoint object models',
+              "(the directory that contains components' folders).",
+              "Default: #{@params[:target_dir]}.") do |dir|
+        @params[:target_dir] = dir
+      end
+    end
+
+    def define_component_option(opts)
+      opts.on('-c COMPONENT', '--component COMPONENT', String,
+              'Component name for endpoint classes. For a new',
+              'project, a directory named like this will be created',
+              'inside the target directory, and all the generated',
+              'endpoint object models will be located inside.',
+              "Default: #{@params[:component]}.") do |component|
+        @params[:component] = component
+      end
+    end
+
+    def define_update_only_option(opts)
+      opts.on('--[no-]update-only', TrueClass,
+              'Do not create new files, only update existing. This',
+              'option is useful when there are new (previously',
+              'untested) endpoints in Swagger. '\
+              "Default: #{@params[:update_only]}.") do |update_only|
+        @params[:update_only] = update_only
+      end
+    end
+
+    def define_rewrite_schemas_option(opts)
+      opts.on('--[no-]rewrite-schemas', TrueClass,
+              'Rewrite schema modules (located in',
+              'TARGET_DIR/COMPONENT/object_model_schemas)',
+              'if they already exist. '\
+              "Default: #{@params[:rewrite_schemas]}.") do |rewrite_schemas|
+        @params[:rewrite_schemas] = rewrite_schemas
+      end
+    end
+
+    def define_from_scratch_option(opts)
+      opts.on('--from-scratch', TrueClass,
+              'Generate new testing framework. Will create',
+              "a directory named 'harness' and generate the scaffold",
+              'of the framework inside. '\
+              "Default: #{@params[:from_scratch]}.") do |from_scratch|
+        @params[:from_scratch] = from_scratch
+      end
+    end
+
+    def define_help_option(opts)
+      opts.on('-h', '--help', 'Prints this help') do
+        puts opts
+        exit
+      end
+    end
+
+    def url?(path)
+      URI.extract(path).present?
+    end
+
+    def json_file_path?(path)
+      path.end_with?('.json') && File.exist?(path)
+    end
+  end
+end