swgr2rb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8fff27c262279ed16947b368dcf3eb09f6460a55d2edc069cffa79512139a525
+  data.tar.gz: 72da74531bffacfd10b0046d97b9a1c256f2d0c418cb06c93f1e6ab4a9d7a52e
+SHA512:
+  metadata.gz: a5dabc64221fd3d03011bd2892770fc37880d89ff855329b2d63b081728e878633e5d59809ece1004981d146dd8695393e57d40a3ea214a4676b55b2917decbf
+  data.tar.gz: 8616aa2474134f98c6905435b2450d91e97b19f9ddaa6409d610df3e503554efe8a7f21bd0a14f912c173fb648279fa04e511a6e9d93dee0a84a2acbb49fb098

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Polytech Software
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Swgr2rb
+
+Swgr2rb (Swagger to Ruby) is a tool that generates Ruby classes for JSON schema validation
+based on Swagger-generated documentation.
+The tool was developed by [Polytech Software](https://polytech.software/).
+
+## Installation
+
+Swgr2rb can be installed with RubyGems:
+
+```shell script
+$ gem install swgr2rb
+```
+
+## Usage
+
+Swgr2rb can be used in two ways: to generate a new testing framework, or to update an existing one.
+
+In both cases, `swgr2rb` has one required argument and a number of options.
+The required argument must be either a URL of Swagger (e.g. `localhost:8080/swagger`)
+or a path to the JSON file returned by Swagger (e.g. `docs/swagger.json`).
+To read more about the options, view help:
+
+```shell script
+$ swgr2rb --help
+```
+
+### Generating a new testing framework
+
+Swgr2rb can generate a scaffold of a testing framework:
+
+```shell script
+$ swgr2rb <swagger_url|json_file_path> --from-scratch
+```
+
+A directory named `harness` will be created, and the scaffold will be generated inside.
+
+The endpoint object models generated from Swagger will be located in the
+`endpoint_object_models/object_model/%component_name%`
+folder (component's name can be specified with the `-c/--component` option).
+
+More about the generated testing framework's structure can be read in [its README file](./assets/README.md).
+
+### Updating an existing testing framework
+
+Swgr2rb can be used to update the endpoint object models of an existing testing framework:
+
+```shell script
+$ swgr2rb <swagger_url|json_file_path> -c <component_name>
+```
+
+The tool will update the endpoint object model schema modules (located in
+`%target_dir%/%component_name%/object_model_schemas`) according to Swagger,
+and create new object model classes and schemas if there are new (previously untested)
+endpoints in the documentation.
+
+The behavior can be modified with the following command line options
+(check `swgr2rb --help` to read more):
+
+| Option | Description | Default value |
+| ---    | ---         | ---           |
+| `-t/--target-dir TARGET_DIR` | The target directory for endpoint object models.        | `endpoint_object_models/object_model` |
+| `-c/--component COMPONENT`   | The name of the component.                                                       | `component1` |
+| `--[no-]update-only`         | Do not create new files (endpoint models and schemas), only update the existing ones. | `false` |
+| `--[no-]rewrite-schemas`     | Rewrite schema modules if they already exist.                                         | `true`  |
+
+## License
+
+Swgr2rb is released under the [MIT license](./LICENSE).

data/assets/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'activesupport'
+gem 'cucumber', '~> 3.1', '>= 3.1.2'
+gem 'httparty'
+gem 'humanize', '~> 2.1', '>= 2.1.1'

data/assets/README.md

@@ -0,0 +1,94 @@
+# Harness service
+## Overview
+The harness service includes tests and endpoint object models. The service's prime use is to perform testing.
+
+## Project directories overview
+```
+.
+├── configs
+├── endpoint_object_models
+│   ├── config_loaders
+│   ├── json_validator
+│   ├── object_models
+|   |   └── %component_name%
+|   |       └── object_model_schemas
+│   └── prototypes
+├── features
+│   ├── component
+|   |   └── %component_name%
+│   ├── step_definitions
+│   └── support
+└── request_sender
+    └── conductor_sender
+```
+
+The `configs` folder contains service's configuration files.
+
+The `endpoint_object_models` folder contains all things related to the endpoint models such as the `JSON validator`
+component, the `Config loader` component, and prototypes like `JSON schema data types` and `Request object`.
+The endpoint models themselves are located in `object_models/%component_name%`.
+The modules that contain expected JSON schemas for schema validation testing are located in
+`object_models/%component_name%/object_model_schemas`.
+
+The `features` folder contains the Cucumber tests.
+All tests are located in `component/%component_name%`.
+
+The `request_sender` folder includes the `conductor_sender`, which is used for sending requests to the application.
+
+## Service configuration
+
+The service is configurable. The configuration file is in the `configs` directory.
+The configuration file includes info about the location of the application.
+In other words, it includes info on how to have access to the application.
+
+```yaml
+connection:
+  protocol: 'https://'
+  host: '<HOST>'
+  port: '<PORT>'
+```
+
+## Setting up a local environment and run tests locally
+
+The Harness service was written on Ruby and that is why it is required to install RVM (Ruby Version Master)
+and ruby 2.6.5 as well.
+
+To install RVM complete the following steps:
+
+* Add the GPG key to your system by performing the following command:
+
+```bash
+gpg2 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
+``` 
+
+* Download and install RVM by performing the following command:
+
+```bash
+curl -sSL https://get.rvm.io | bash -s stable
+``` 
+
+* To install ruby perform the following command:
+
+```bash
+rvm install ruby-2.6.5
+rvm --default use ruby-2.6.5
+```
+
+The Harness service uses different libs, that's why to perform tests locally it is required to install them as well. 
+To do this perform the following command in the project folder:
+
+```bash
+bundle install
+``` 
+
+To execute tests perform one of the following commands:
+
+```bash
+cucumber
+```
+
+To execute a specific test perform the following command:
+
+```bash
+cucumber --tags '<testcase_tag>' --tags '<component_tag>'
+```

data/assets/configs/conductor_sender_configs.yaml

@@ -0,0 +1,4 @@
+connection:
+  protocol: 'https://'
+  host: 'localhost'
+  port: '8080'

data/assets/endpoint_object_models/config_loaders/base_config.rb

@@ -0,0 +1,28 @@
+class BaseConfig
+  attr_accessor :config_file
+  def initialize(config_file)
+    @config_file = config_file
+    create_attribute_accessors
+    self
+  end
+
+  private
+
+  def create_attribute_accessors
+    config_file.each do |k, v|
+      create_attribute_reader(k, v)
+    end
+  end
+
+  def create_attribute_reader(key, value)
+    case value
+    when Hash
+      instance_variable_set("@#{key}", BaseConfig.new(value))
+    else
+      instance_variable_set("@#{key}", value)
+    end
+    self.class.send(:define_method, key) do
+      instance_variable_get("@#{key}")
+    end
+  end
+end

data/assets/endpoint_object_models/config_loaders/conductor_config_loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base_config'
+
+class ConductorConfigLoader
+  class << self
+    def load
+      current_dir = __FILE__.scan(%r{(.*/harness/)(.*)}m).flatten.first
+      file = YAML.load_file(File.join(current_dir,
+                                      '/configs',
+                                      'conductor_sender_configs.yaml'))
+      ConductorConfig.new(file)
+    end
+  end
+end
+
+class ConductorConfig < BaseConfig
+end

data/assets/endpoint_object_models/json_validator/json_data_validator.rb

@@ -0,0 +1,44 @@
+class JsonDataValidator
+  class << self
+    def validate(expected_data, actual_data)
+      begin
+        validate_recursively(expected_data, actual_data)
+      rescue RuntimeError => e
+        raise "#{e.message}\n\n"\
+              "Full expected response:\n#{expected_data}\n\n"\
+              "Full actual response:\n#{actual_data}"
+      end
+    end
+
+    private
+
+    def validate_recursively(expected_data, actual_data, key_name = nil)
+      case expected_data
+      when Array
+        validate_response_size(expected_data, actual_data, key_name)
+        expected_data.zip(actual_data).each do |expected, actual|
+          validate_recursively(expected, actual)
+        end
+      when Hash
+        expected_data.each do |exp_key, exp_value|
+          validate_recursively(exp_value, actual_data[exp_key], exp_key)
+        end
+      else
+        unless expected_data.to_s == actual_data.to_s ||
+            (expected_data.is_a?(Regexp) && expected_data.match?(actual_data.to_s))
+          raise "Unexpected value in response body#{key_name ? " for key '#{key_name}'" : ''}\n"\
+                "Expected: #{expected_data}\n"\
+                "Actual: #{actual_data}"
+        end
+      end
+    end
+
+    def validate_response_size(expected_data, actual_data, key_name = nil)
+      unless expected_data.size == actual_data.size
+        raise "Unexpected number of objects in response body#{key_name ? " for key '#{key_name}'" : ''}\n"\
+              "Expected: #{expected_data.size}\n"\
+              "Actual: #{actual_data.size}"
+      end
+    end
+  end
+end

data/assets/endpoint_object_models/json_validator/json_schema_validator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../../endpoint_object_models/prototypes/json_schema_data_types'
+
+class JsonSchemaValidator
+  class << self
+    def validate(expected_schema, actual_schema)
+      unless actual_schema.is_a? Hash
+        compare_types(expected_schema, actual_schema, '')
+        return
+      end
+      validate_keys(expected_schema.keys, actual_schema.keys)
+      expected_schema.each do |key, type|
+        case type
+        when Hash
+          validate(expected_schema[key], actual_schema[key])
+        when Array
+          actual_schema[key].each do |e|
+            validate(expected_schema[key][0], e)
+          end
+        else
+          compare_types(type, actual_schema[key], key)
+        end
+      end
+    end
+
+    private
+
+    def compare_types(expected_type, actual_value, key)
+      unless actual_value.is_a?(expected_type) || actual_value.is_a?(NilClass)
+        raise "Schema do not match to the expected schema\n"\
+              "key: #{key}\n"\
+              "expected type: #{expected_type}\n"\
+              "actual type: #{actual_value.class}"
+      end
+    end
+
+    def validate_keys(expected_keys, actual_keys)
+      expected_keys.sort!
+      actual_keys.sort!
+      unless expected_keys == actual_keys
+        raise "Schema do not match to the expected schema \n\n"\
+              "expected schema includes the following keys: \n"\
+              "#{expected_keys.join("\n")}\n\n"\
+              "actual schema includes the following keys: \n"\
+              "#{actual_keys.join("\n")}\n\n"\
+              "missing keys : #{(expected_keys - actual_keys).join(', ')}\n"\
+              "extra keys   : #{(actual_keys - expected_keys).join(', ')}\n"
+      end
+    end
+  end
+end

data/assets/endpoint_object_models/json_validator/json_validator.rb

@@ -0,0 +1,34 @@
+class JsonValidator
+  class << self
+    def validate(expected_schema, actual_data, expected_data = nil)
+      preprocess_actual_data(actual_data).each do |data|
+        JsonSchemaValidator.validate(expected_schema, data)
+      end
+      if expected_data
+        expected = preprocess_expected_data(expected_schema, expected_data)
+        JsonDataValidator.validate(expected, actual_data)
+      end
+    end
+
+    private
+
+    def preprocess_actual_data(actual_data)
+      actual_data.is_a?(Array) ? actual_data : [actual_data]
+    end
+
+    def preprocess_expected_data(expected_schema, expected_data)
+      case expected_data
+      when Array
+        expected_data.map { |data_hash| filter_expected_data_hash(expected_schema, data_hash) }
+      when Hash
+        filter_expected_data_hash(expected_schema, expected_data)
+      else
+        expected_data
+      end
+    end
+
+    def filter_expected_data_hash(expected_schema, expected_data)
+      expected_data.select { |key, _value| expected_schema.key?(key) }
+    end
+  end
+end

data/assets/endpoint_object_models/loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+puts "Loading Endpoint' object models 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 Endpoint' object models component"

data/assets/endpoint_object_models/object_models/base_endpoint_object_model.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class BaseEndpointObjectModel
+  attr_accessor :request_options, :request, :response, :end_point_path,
+                :supportable_request_types, :subdomain, :credentials
+
+  def send_request(_type, _params)
+    raise 'This is abstract class'
+  end
+
+  def validate_response_schema
+    raise 'This is abstract class'
+  end
+
+  def validate_error_response(_error_code)
+    raise 'This is abstract class'
+  end
+
+  def results
+    raise 'This is abstract class'
+  end
+end

data/assets/endpoint_object_models/object_models/base_endpoint_object_model_constants.rb

@@ -0,0 +1,2 @@
+module BaseEndpointObjectModelConstants
+end

data/assets/endpoint_object_models/object_models/base_endpoint_object_model_methods.rb

@@ -0,0 +1,82 @@
+require_relative 'base_endpoint_object_model_constants'
+
+module BaseEndpointObjectModelMethods
+  include BaseEndpointObjectModelConstants
+
+  def send_request(type, params, sub_results = nil)
+    if request_type_support?(type)
+      @request_options = {
+          type: type,
+          params: params,
+          sub_results: sub_results
+      }
+      @request = Request.new(end_point_path, type,
+                             generate_headers, generate_body)
+      @response = ConductorSender.send_request(request)
+    else
+      raise "Harness setup error!\n "\
+            "#{type} do not supports by the #{end_point_path}\n"\
+            'list of the supportable types: '\
+            "#{supportable_request_types.join(', ')}"
+    end
+  end
+
+  def validate_error_response(error_code)
+    unless error_code == response.code
+      raise "The #{response.code} is wrong for #{self.class} endpoint\n"\
+            "Expected : #{error_code}\n"\
+            "Actual   : #{response.code}"
+    end
+    send("#{response.code.to_i.humanize.gsub(' ', '_')}_error_code_schema")
+  end
+
+  def results
+    response.body
+  end
+
+  private
+
+  def validate_response_code
+    unless response.code == expected_code
+      raise "Invalid response code\n"\
+            "Expected: #{expected_code}\n"\
+            "Actual: #{response.code}"
+    end
+  end
+
+  def compare_error_body(expected, actual)
+    expected_keys = expected.keys.sort
+    actual_keys = actual.keys.sort
+
+    unless expected_keys == actual_keys
+      raise "The body for error is wrong \n"\
+            "Expected:\n"\
+            "#{expected_keys}\n"\
+            "Actual:\n"\
+            "#{actual_keys}"
+    end
+
+    expected.each do |k, v|
+      case v
+      when Hash
+        compare_error_body(expected[k], actual[k])
+      else
+        unless expected[k] == actual[k]
+          raise "The value of body is wrong\n"\
+                "Expected:\n"\
+                "#{k}: #{expected[k]}\n"\
+                "Actual:\n"\
+                "#{k}: #{actual[k]}"
+        end
+      end
+    end
+  end
+
+  def generate_headers
+    { 'Content-Type': 'application/json' }
+  end
+
+  def request_type_support?(type)
+    supportable_request_types.include?(type)
+  end
+end