rast 0.1.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eb63e35c4439e5fc90b4e25ce9981739f624a114d6f8848eb07576eac93e9222
+  data.tar.gz: 12f0b43bd2385dada9e6272e8895054911c3bee8fbe2ff267914ceae996f5a82
+SHA512:
+  metadata.gz: 5c39d99e9dde201939565dc47372a0cff3be2e83a77ca2162275982ac15b7e73fc8fa83270761ed7b615093e078ed0d6a4324f30883de1258bb38a14082f8fad
+  data.tar.gz: 103f18839c943b5c30af075fe567386d553be83a7f9f4598e5a77c3917df19362a60fbcaca65bf30873dcbc52b64470cad6318584a037d560732af0eb24921c0

data/.gitignore

@@ -0,0 +1,2 @@
+coverage/
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,3 @@
+---
+AllCops:
+  TargetRubyVersion: 2.6

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+group :test do
+  gem 'guard-rspec', require: false
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'rspec'
+  gem 'simplecov'
+  gem 'simplecov-html'
+end

data/Gemfile.lock

@@ -0,0 +1,72 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    docile (1.3.2)
+    ffi (1.12.2)
+    formatador (0.2.5)
+    guard (2.16.2)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.2.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.4)
+    method_source (0.9.2)
+    nenv (0.3.0)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-nav (0.3.0)
+      pry (>= 0.9.10, < 0.13.0)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.1)
+      rspec-support (~> 3.9.1)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.2)
+    shellany (0.0.1)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.2)
+    thor (1.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard-rspec
+  pry
+  pry-nav
+  rspec
+  simplecov
+  simplecov-html
+
+BUNDLED WITH
+   2.1.4

data/Guardfile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# guard :rubocop do
+#   watch(%r{.+\.rb$})
+#   watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+# end
+
+guard :rspec, cmd: 'bundle exec rspec -fd' do
+  require 'guard/rspec/dsl'
+
+  Guard::RSpec::Dsl.new(self)
+
+  watch(%r{^spec/.+_spec\.rb$})
+  # watch(%r{^spec\/.*?\/(.+_spec\.)yml$}) { |m| "#{m}.rb" }
+  watch(%r{^lib/(.+)\.rb$}) { |_m| 'spec/examples/prime_number_spec.rb' }
+  # watch(%r{^lib/(.+)\.rb$}) { |_m| 'spec/examples/logic_checker_spec.rb' }
+  # watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { 'spec' }
+end

data/README.md

@@ -0,0 +1,25 @@
+# Overview
+RSpec All Scenario Testing
+
+## Definition of terms
+
+spec - as defined in the yaml file, the individual elements under `specs`
+
+scenario - a specific combination of tokens from vars, it can uniquely identify a fixture.
+
+fixture - instance of a spec, containing a scenario, reference back to the spec, and the expected result for the given scenario.
+
+vars - raw list of variables to be combined into multiple fixtures.
+
+rule - set of outcome paired with rule clause.
+exemption/exclusions - rule defining variable combinations to be excluded from the test.
+
+outcome - the left portion of a rule e.g. `true: true&true`
+
+clause - the right portion of a rule
+
+
+##
+
+When running the tests, the execution starts at the spec file, then invoking the
+DSL. The DSL will then invoke the parameter generator to generate the scenarios.

data/examples/logic_checker.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# LogicChecker ported from Java
+#
+# @author Royce Remulla
+#
+class LogicChecker
+  # Perform logical AND operation on two arguments.
+  #
+  # @param argument1 first argument of Boolean type.
+  # @param argument2 second argument of Boolean type.
+  def and(argument1, argument2)
+    argument1 && argument2
+  end
+
+  # Perform logical OR operation on two arguments.
+  #
+  # @param argument1 first argument of Boolean type.
+  # @param argument2 second argument of Boolean type.
+  def or(argument1, argument2)
+    argument1 || argument2
+  end
+end

data/examples/prime_number.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Example that returns true if the number passed is a prime number
+class PrimeNumber
+  def prime?(number)
+    is_prime = true
+    raise "Invalid number: #{number}" if number <= 0
+
+    if number == 1
+      is_prime = false
+    elsif number > 2
+      (2...number).each do |i|
+        is_prime = number % i != 0
+        break unless is_prime
+      end
+    end
+    is_prime
+  end
+end

data/examples/recruiter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Rules
+class Recruiter
+  def score; end
+
+  def position; end
+
+  def assess
+    case position
+    when 'Manager'
+      assess_manager(score)
+    when 'Senior Engineer'
+      assess_sr_engineer(score)
+    when 'Engineer'
+      assess_engineer(score)
+    end
+  end
+
+  private
+
+  # Shortlist score of 9, accept 10, and reject the rest
+  def assess_manager(score)
+    return 'Shortlist' if score == 9
+
+    return 'Accept' if score == 10
+
+    'Reject'
+  end
+
+  # Shortlist score of 8, accept 9 or 10, and reject the rest
+  def assess_sr_engineer(score)
+    return 'Shortlist' if score == 8
+
+    return 'Accept' if score > 8
+
+    'Reject'
+  end
+
+  # Score of 9 and above are overqualified, shortlist 7, accept 8, and reject the rest.
+  def assess_engineer(score)
+    return 'Over Qualified' if score > 8
+
+    return 'Accept' if score == 8
+
+    return 'Shortlist' if score == 7
+
+    'Reject'
+  end
+end

data/examples/worker.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Example
+class Worker
+  def day_of_week; end
+
+  def holiday?; end
+
+  def goto_work?
+    !holiday? && day_of_week != :Sunday
+  end
+end

data/lib/rast/assert.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Used to provide assertion check similar to java
+
+def assert(message)
+  raise message unless yield
+end

data/lib/rast/converters/bool_converter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Converts string into boolean
+class BoolConverter
+  def convert(string)
+    return nil if string == 'nil'
+
+    string == 'true'
+  end
+end

data/lib/rast/converters/float_converter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Converts string into a floating type number
+class FloatConverter
+  def convert(string)
+    string.to_f
+  end
+end

data/lib/rast/converters/int_converter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Converts string into an integer
+class IntConverter
+  def convert(string)
+    string.to_i
+  end
+end

data/lib/rast/converters/str_converter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Converts string into number
+class StrConverter
+  def convert(string)
+    string
+  end
+end

data/lib/rast/parameter_generator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'pry'
+require 'yaml'
+require_relative 'rast_spec'
+require_relative 'rules/rule'
+require_relative 'rules/rule_evaluator'
+require_relative 'rules/rule_validator'
+
+require_relative 'converters/float_converter'
+
+# Generates the test parameters.
+class ParameterGenerator
+  def initialize(yaml_path: '')
+    @specs_config = YAML.load_file(yaml_path)['specs']
+
+    # p @specs_config
+  end
+
+  # addCase. Generate the combinations, then add the fixture to the final list
+  def generate_fixtures(spec_id: '')
+    spec_config = @specs_config[spec_id]
+
+    spec_config[:description] = spec_id
+    spec = instantiate_spec(spec_config)
+
+    list = []
+
+    variables = spec.variables
+    var_first = spec.variables.first
+    multipliers = []
+
+    (1...variables.size).each { |i| multipliers << variables.values[i].dup }
+    scenarios = var_first.last.product(*multipliers)
+    add_fixtures(scenarios: scenarios, spec: spec, list: list)
+    list
+  end
+
+  private
+
+  def valid_case?(scenario, spec)
+    return true if spec.exempt_rule.nil?
+
+    exempt_rule = fixture.exempt_rule
+    rule_evaluator = RuleEvaluator.new(converters: spec.converters)
+    rule_evaluator.parse(exempt_rule)
+    !ruleEvaluator.evaluate(scenario, spec.converters)
+  end
+
+  # add all fixtures to the list.
+  def add_fixtures(scenarios: [], spec: nil, list: [])
+    validator = RuleValidator.new
+
+    scenarios.each do |scenario|
+      next unless valid_case?(scenario, spec)
+
+      list << build_param(validator, scenario, spec)
+    end
+  end
+
+  def build_param(validator, scenario, spec)
+    param = { spec: spec, scenario: {} }
+    token_converter = {}
+
+    spec.variables.keys.each_with_index do |key, index|
+      spec.variables[key].each do |element|
+        unless spec.converters.nil?
+          token_converter[element.to_s] = spec.converters[index]
+        end
+      end
+    end
+
+    spec.variables.keys.zip(scenario) do |array|
+      var_name = array.first.to_sym
+      var_value = array.last
+      param[:scenario][var_name] = var_value
+    end
+
+    param[:converter_hash] = token_converter
+    param[:expected_outcome] = validator.validate(
+      scenario: scenario,
+      fixture: param
+    )
+
+    param
+  end
+
+  def instantiate_spec(spec_config)
+    spec = RastSpec.new(
+      description: spec_config[:description],
+      variables: spec_config['variables'],
+      rule: Rule.new(rules: spec_config['rules'])
+    )
+
+    pair_config = spec_config['pair']
+    spec.init_pair(pair_config: pair_config) unless pair_config.nil?
+
+    converters = if spec_config['converters'].nil?
+                   str_converter = StrConverter.new
+                   spec_config['variables'].map { |_var| str_converter }
+                 else
+                   spec_config['converters'].map do |converter|
+                     Object.const_get(converter).new
+                   end
+                 end
+
+    spec.init_converters(converters: converters)
+  end
+end

data/lib/rast/rast_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# CaseFixture.java, containing an actual and specific combination of variables.
+class RastSpec
+  attr_reader :variables, :pair, :pair_reversed, :rule, :description,
+              :exempt_rule, :converters
+
+  attr_accessor :exclude
+
+  def initialize(description: '', variables: [][], rule: nil)
+    @description = description
+    @variables = variables
+    @pair = {}
+    @pair_reversed = {}
+    @rule = rule
+    @exempt_rule = nil
+  end
+
+  def init_pair(pair_config: {})
+    @pair[pair_config.keys.first.to_s] = pair_config.values.first.to_s
+    @pair_reversed = [@pair.to_a.first.reverse].to_h
+    self
+  end
+
+  def init_converters(converters: [])
+    @converters = converters
+    self
+  end
+
+  def init_exempt_rule(exempt_rule)
+    @exempt_rule = exempt_rule
+    self
+  end
+
+  def to_s
+    "Class: #{self.class}
+Description: #{@description}
+Variables: #{@variables}
+Rules: #{@rules}
+Pair: #{@pair}
+Converters: #{@converters}
+    "
+  end
+end

data/lib/rast/rules/logic_helper.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# Provides logic evaluation functionalities.
+module LogicHelper
+  # /**
+  #  * Custom logical AND/OR evaluator.
+  #  *
+  #  * @author Royce
+  #  */
+
+  TRUE = '|true'
+  FALSE = '|false'
+
+  # /**
+  #  * @param scenario list of scenario tokens.
+  #  * @param left_subscript left index.
+  #  * @param right_subscript right index.
+  #  * @param left left token.
+  #  * @param right right token.
+  #  */
+  def perform_logical_and(scenario: [], left_subscript: -1, right_subscript: -1,
+                          left: nil, right: nil)
+    if FALSE == left || FALSE == right
+      FALSE
+    elsif TRUE == left && TRUE == right
+      TRUE
+    elsif TRUE == left
+      if right_subscript.negative?
+        scenario.include?(right).to_s
+      else
+        (scenario[right_subscript] == right).to_s
+      end
+    elsif TRUE == right
+      if left_subscript.negative?
+        scenario.include?(left).to_s
+      else
+        (scenario[left_subscript] == left).to_s
+      end
+    else
+      left_eval = pevaluate(
+        scenario: scenario,
+        subscript: left_subscript,
+        object: left
+      )
+
+      right_eval = pevaluate(
+        scenario: scenario,
+        subscript: right_subscript,
+        object: right
+      )
+
+      (left_eval && right_eval).to_s
+    end
+  end
+
+  # /**
+  #  * @param scenario list of scenario tokens.
+  #  * @param left_subscript left index.
+  #  * @param right_subscript right index.
+  #  * @param left left token.
+  #  * @param right right token.
+  #  */
+  def perform_logical_or(scenario: [], left_subscript: -1, right_subscript: -1,
+                         left: nil, right: nil)
+    if TRUE == left || TRUE == right
+      TRUE
+    elsif FALSE == left && FALSE == right
+      FALSE
+    elsif FALSE == left
+      if right_subscript.negative?
+        scenario.include?(right).to_s
+      else
+        (scenario[right_subscript] == right).to_s
+      end
+    elsif FALSE == right
+      if left_subscript.negative?
+        scenario.include?(left).to_s
+      else
+        (scenario[left_subscript]).to_s == left
+      end
+    else
+      left_eval = pevaluate(
+        scenario: scenario,
+        subscript: left_subscript,
+        object: left
+      )
+
+      right_eval = pevaluate(
+        scenario: scenario,
+        subscript: right_subscript,
+        object: right
+      )
+
+      (left_eval || right_eval).to_s
+    end
+  end
+
+  # /**
+  #  * Helper method to evaluate left or right token.
+  #  *
+  #  * @param scenario list of scenario tokens.
+  #  * @param subscript scenario token subscript.
+  #  * @param object left or right token.
+  #  */
+  def pevaluate(scenario: [], subscript: -1, object: nil)
+    if subscript.negative?
+      scenario.include?(object)
+    else
+      scenario[subscript] == object
+    end
+  end
+
+  # /**
+  #  * Check if the token is opening bracket.
+  #  *
+  #  * @param token Input <code>String</code> token
+  #  * @return <code>boolean</code> output
+  #  */
+  def open_bracket?(token: '')
+    token == '('
+  end
+
+  # /**
+  #  * Check if the token is closing bracket.
+  #  *
+  #  * @param token Input <code>String</code> token
+  #  * @return <code>boolean</code> output
+  #  */
+  def close_bracket?(token: '')
+    token == ')'
+  end
+end

data/lib/rast/rules/operator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Operator Enum in Java. To be used only internally in RuleEvaluator class.
+class Operator
+  # Not('!', Byte.MAX_VALUE), And('&', (byte) 2), Or('|', (byte) 1)
+
+  attr_reader :name, :symbol, :precedence
+
+  def initialize(name: '', symbol: '', precedence: -1)
+    @name = name
+    @symbol = symbol
+    @precedence = precedence
+  end
+
+  def to_s
+    @operator.to_s
+  end
+end