gloo-test 1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a73cec30908a847f9a57eff2a51260510ce2c6dae9c7ce3a5c899cb2b687385
+  data.tar.gz: 3e39c1eeac6b251ed68f81047759a7a505d5eccff6c62b3c156994a8c42b5a8c
+SHA512:
+  metadata.gz: a78397cbeb4554166ec1d210149969121f1ebe133f3d6b7c45811fba1da0c1f3f2c2627a0a12dfa2257b3a6e9b4a85294fd61f42c53b8731cf201e33a29b6e5a
+  data.tar.gz: b11b5be346c5de429676e3095c675b4ef651fc4ea4688890473fba113bcd1345777175ee95011ef4f930fe5d6054bbe8c751f3987df1e3ce5d347f28d9a83c29

data/README.md

@@ -0,0 +1,30 @@
+# gloo-test
+
+A core gloo library for unit testing gloo code.
+
+## Usage
+
+Loaded automatically when running gloo in test mode:
+
+```gloo
+> gloo --test ./path/to/tests/
+```
+
+It can also be loaded explicitly in a script, like any other core library:
+
+```gloo
+> load lib test
+```
+
+## Objects
+
+- `test` — a single gloo test
+
+## Verbs
+
+- `assert` — assert an expectation about the state or result of a prior command
+- `refute` — refute an expectation about the state or result of a prior command
+
+## Full Reference
+
+Every object/verb's full syntax is documented in-app once the library is loaded — e.g. `help> verb assert`.

data/lib/assert.rb

@@ -0,0 +1,88 @@
+#
+# Assert that [it] is true.
+#
+class Assert < Gloo::Core::Verb
+
+  KEYWORD = 'assert'.freeze
+  KEYWORD_SHORT = 'expect'.freeze
+  DEFAULT_MESSAGE = 'Assertion failed'.freeze
+  
+  #
+  # Get the Verb's keyword.
+  #
+  def self.keyword
+    return KEYWORD
+  end
+
+  #
+  # Get the Verb's keyword shortcut.
+  #
+  def self.keyword_shortcut
+    return KEYWORD_SHORT
+  end
+
+  #
+  # Run the verb.
+  #
+  def run
+    begin
+      @engine.context_object.assert_count += 1
+      if @engine.heap.it.is_true?
+        # Assertion passes
+        @engine.context_object.passed = true
+        return true
+      else
+        # Assertion fails
+        @engine.context_object.passed = false
+        @engine.context_object.add_message get_message
+        return false
+      end
+    rescue => ex
+      @engine.log_exception ex
+    end
+  end
+
+  #
+  # Get the assertion message.
+  #
+  def get_message
+    if @tokens.token_count > 1
+      expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
+      result = expr.evaluate
+      return result
+    end
+    return DEFAULT_MESSAGE
+  end
+
+  # ---------------------------------------------------------------------
+  #    Verb Documentation
+  # ---------------------------------------------------------------------
+
+  #
+  # Get the verb's documentation data.
+  #
+  def self.doc_data
+    {
+      :name => KEYWORD,
+      :shortcut => KEYWORD_SHORT,
+      :description => 'Assert an expectation about the state or ' \
+        'results. The verb looks at the value of it. If it is true, ' \
+        'then the assertion passes, otherwise it fails.',
+      :syntax => [ 'assert {optional expectation message}' ],
+      :parameters => [
+        "optional expectation message — A textual statement about " \
+          "what was expected. Optional. If none provided the default " \
+          "\"#{DEFAULT_MESSAGE}\" will be shown."
+      ],
+      :result => 'Validates an assumption and reports failures (or success).',
+      :examples => <<~EXAMPLES.strip
+        assert_noop [test] :
+          description [string] : Assert no operation
+          on_test [script] :
+            noop
+            assert 'noop should be true'
+      EXAMPLES
+    }
+  end
+
+end

data/lib/gloo-test.rb

@@ -0,0 +1,29 @@
+# 
+# Shim to allow `require 'gloo-test'`
+# 
+# This file is loaded when someone does `require 'gloo-test'`
+# 
+require 'assert'
+require 'refute'
+require 'result'
+require 'results'
+require 'test_file'
+require 'test_files'
+require 'test_runner'
+require 'test'
+
+# 
+# Registers the extension.
+# 
+class TestInit < Gloo::Plugin::Base
+
+    # 
+    # Register verbs and objects.
+    # 
+    def register( callback )
+      callback.register_obj( Test )
+      callback.register_verb( Assert )
+      callback.register_verb( Refute )
+    end
+
+end

data/lib/refute.rb

@@ -0,0 +1,89 @@
+#
+# Refute that [it] is true.
+# (Assert that [it] is false.)
+#
+class Refute < Gloo::Core::Verb
+
+  KEYWORD = 'refute'.freeze
+  KEYWORD_SHORT = 'expect_not'.freeze
+  DEFAULT_MESSAGE = 'Refutation failed'.freeze
+
+  #
+  # Get the Verb's keyword.
+  #
+  def self.keyword
+    return KEYWORD
+  end
+
+  #
+  # Get the Verb's keyword shortcut.
+  #
+  def self.keyword_shortcut
+    return KEYWORD_SHORT
+  end
+
+  #
+  # Run the verb.
+  #
+  def run
+    begin
+      @engine.context_object.refute_count += 1
+      if @engine.heap.it.is_false?
+        # Refutation passes
+        @engine.context_object.passed = true
+        return true
+      else
+        # Refutation fails
+        @engine.context_object.passed = false
+        @engine.context_object.add_message(get_message)
+        return false
+      end
+    rescue => ex
+      @engine.log_exception ex
+    end
+  end
+
+  #
+  # Get the refutation message.
+  #
+  def get_message
+    if @tokens.token_count > 1
+      expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
+      result = expr.evaluate
+      return result
+    end
+    return DEFAULT_MESSAGE
+  end
+
+  # ---------------------------------------------------------------------
+  #    Verb Documentation
+  # ---------------------------------------------------------------------
+
+  #
+  # Get the verb's documentation data.
+  #
+  def self.doc_data
+    {
+      :name => KEYWORD,
+      :shortcut => KEYWORD_SHORT,
+      :description => 'Refute an expectation about the state or ' \
+        'results. The verb looks at the value of it. If it is false, ' \
+        'then the assertion passes, otherwise it fails.',
+      :syntax => [ 'refute {optional expectation message}' ],
+      :parameters => [
+        "optional expectation message — A textual statement about " \
+          "what was NOT expected. Optional. If none provided the " \
+          "default \"#{DEFAULT_MESSAGE}\" will be shown."
+      ],
+      :result => 'Validates a negative assumption and reports failures (or success).',
+      :examples => <<~EXAMPLES.strip
+        refute [test] :
+          description [string] : Refute an operation
+          on_test [script] :
+            eval false
+            refute 'false should be false'
+      EXAMPLES
+    }
+  end
+
+end

data/lib/result.rb

@@ -0,0 +1,44 @@
+#
+# A gloo unit test result object.
+# The result of a single test.
+#
+class Result
+
+  attr_accessor :passed, :assert_count, :refute_count
+
+  def initialize( engine, test )
+    @engine = engine
+    @test = test
+    @test_desc = test.test_desc
+    @pn = test.pn
+
+    @assert_count = 0
+    @refute_count = 0
+
+    @passed = true
+    @failure_msg = ''
+  end
+
+  #
+  # Show the test result symbol.
+  #
+  def show_result_symbol
+    print @passed ? '.' : 'x'
+  end
+
+  #
+  # Add a failure message to the result.
+  #
+  def add_message(message)
+    @failure_msg += "   " + message + "\n"
+  end
+
+  # 
+  # Show the failure message.
+  #
+  def show_failure
+    puts "#{@pn} -> #{@test_desc}"
+    puts @failure_msg
+    puts
+  end
+end

data/lib/results.rb

@@ -0,0 +1,114 @@
+#
+# A gloo unit test results collection.
+# The results of a the set of tests run.
+#
+class Results 
+
+  attr_accessor :file_count, :test_count, 
+    :pass_count, :fail_count, :assert_count
+  
+  #
+  # Set up the results collection.
+  #
+  def initialize( engine )
+    @engine = engine
+
+    @all_results = []
+    @failures = []
+
+    @file_count = 0
+    @pass_count = 0
+    @fail_count = 0
+    @assert_count = 0
+    
+    @engine.log.debug "Results initialized"
+  end
+
+  # ---------------------------------------------------------------------
+  #    Timer
+  # ---------------------------------------------------------------------
+
+  # 
+  # Set a timer to track test duration.
+  # 
+  def start_timer
+    @start_time = Time.now
+  end
+
+  # 
+  # End the timer.
+  # 
+  def end_timer
+    @end_time = Time.now
+  end
+
+  # 
+  # Get the duration of the test.
+  # 
+  def duration
+    return @end_time - @start_time
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Results
+  # ---------------------------------------------------------------------
+
+  # 
+  # Add a result to the collection.
+  #
+  def add_result( result )
+    @all_results << result
+    @failures << result unless result.passed
+
+    @pass_count += 1 if result.passed
+    @fail_count += 1 unless result.passed
+    @assert_count += result.assert_count
+    @assert_count += result.refute_count
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Show Results
+  # ---------------------------------------------------------------------
+
+  #
+  # Show the results.
+  #
+  def show_results
+    delta = duration.round( 2 )
+    puts
+    puts get_result_summary
+    puts "Tests finished in #{delta} seconds".white
+    puts
+  end
+
+  #
+  # Show the failures.
+  #
+  def show_failures
+    if @fail_count > 0
+      puts
+      puts "*** Failures (#{@fail_count}) ***".red
+      puts
+      @failures.each do |failure|
+        failure.show_failure
+      end
+    end
+  end
+  
+  # 
+  # Get a textual summary of the results.
+  #
+  def get_result_summary
+    str = "Tests: #{@all_results.length} • Passed: #{@pass_count} • ".white
+    if @fail_count > 0
+      str += " Failed: #{@fail_count} ".red
+    else
+      str += " Failed: #{@fail_count} ".white
+    end
+    str += "\n  Assertions: #{@assert_count} • Files: #{@file_count}".yellow
+    return str
+  end
+
+end

data/lib/test.rb

@@ -0,0 +1,126 @@
+#
+# A gloo unit test object
+#
+class Test < Gloo::Core::Obj
+
+  KEYWORD = 'test'.freeze
+  TEST_DESC = 'description'.freeze
+  ON_TEST_EVENT = 'on_test'.freeze
+
+
+  #
+  # The name of the object type.
+  #
+  def self.typename
+    return KEYWORD
+  end
+
+  #
+  # The short name of the object type.
+  # Same as the typename.
+  #
+  def self.short_typename
+    return KEYWORD
+  end
+
+  # 
+  # Get the test description.
+  #
+  def test_desc
+    o = find_child TEST_DESC
+    return o ? o.value : 'Unknown'
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Children
+  # ---------------------------------------------------------------------
+
+  # Does this object have children to add when an object
+  # is created in interactive mode?
+  # This does not apply during obj load, etc.
+  def add_children_on_create?
+    return true
+  end
+
+  # Add children to this object.
+  # This is used by containers to add children needed
+  # for default configurations.
+  def add_default_children
+    fac = @engine.factory
+    fac.create_string TEST_DESC, '', self
+    fac.create_script ON_TEST_EVENT, '', self
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Messages
+  # ---------------------------------------------------------------------
+
+  #
+  # Get a list of message names that this object receives.
+  #
+  def self.messages
+    return super # + [ 'run' ]
+  end
+
+  # 
+  # Run the test.
+  #
+  def run_test
+    result = Result.new( @engine, self )
+    @engine.context_object = result
+    run_on_test
+    @engine.context_object = nil
+
+    result.show_result_symbol
+
+    return result
+  end
+
+  #
+  # Run the on_test script.
+  #
+  def run_on_test
+    o = find_child ON_TEST_EVENT
+    return unless o
+
+    Gloo::Exec::Dispatch.message( @engine, 'run', o )
+  end
+
+  # ---------------------------------------------------------------------
+  #    Object Documentation
+  # ---------------------------------------------------------------------
+
+  #
+  # Get the object's documentation data.
+  #
+  def self.doc_data
+    {
+      :name => KEYWORD,
+      :shortcut => KEYWORD,
+      :description => 'A single gloo test.',
+      :children => [
+        'description (string) — A textual description of the test and desired outcome, used in output if there is an error.',
+        'on_test (script) — The script to run when the test is executed. Note that the normal way to run tests is with gloo --test.'
+      ],
+      :examples => <<~EXAMPLES.strip
+        #
+        # Basic tests
+        #
+        tests [can] :
+          basic [can] :
+
+            on_load [script] :
+              log 'Include functionality for all test in on_load' (debug)
+
+            assert_noop [test] :
+              description [string] : Assert no operation
+              on_test [script] :
+                noop
+                assert 'noop should be true'
+      EXAMPLES
+    }
+  end
+
+end

data/lib/test_file.rb

@@ -0,0 +1,59 @@
+#
+# A single Test File, might have multiple tests.
+#
+class TestFile
+
+  #
+  # Set up the test file.
+  #
+  def initialize( engine, path_name )
+    @engine = engine
+    @path_name = path_name
+
+    @tests = []
+  end
+
+  #
+  # Execute all tests in this file and add results
+  # to the overall test results.
+  #
+  def run_tests( results )
+    # Load the test file
+    @engine.persist_man.load( @path_name )
+    # @engine.parser.run '.'
+
+    # Find all Test objects in the loaded file(s)
+    # The loaded file might have loaded other files
+    @tests = Gloo::Core::ObjFinder.by_type( @engine, 'test' )
+
+    # randomize the tests
+    @tests.shuffle!
+
+    # For each Test object, run its on_test script
+    @tests.each do |o|
+      result = o.run_test
+      results.add_result result
+    end
+
+    # Collect results from each test
+
+    # Aggregate result from test into overall results
+
+    # file.show_info
+  end
+
+  #
+  # Get the number of tests run.
+  #
+  def tests_run_count
+    return @tests.length
+  end
+
+  def show_info
+    puts "Test file: #{@path_name}"
+  end
+
+end
+
+
+

data/lib/test_files.rb

@@ -0,0 +1,102 @@
+#
+# The collection of Test Files.
+#
+class TestFiles
+  include Enumerable
+
+  TEST_FILE_PATTERN = '**/*.test.gloo'
+
+  #
+  # Set up the test file.
+  #
+  def initialize( engine, input_files = nil )
+    @engine = engine
+    @input_files = input_files
+    @files = []
+  end
+
+  #
+  # Detect test files.
+  #
+  def detect_files
+    @engine.log.debug "Detecting test files…"
+
+    if @input_files.length > 0
+      use_input_files
+    else
+      # Use the current directory
+      look_for_files_in Dir.pwd
+    end
+
+    @engine.log.debug "Found #{count} test files"
+  end
+
+  # 
+  # Use the files and or directories specified by the user.
+  #
+  def use_input_files
+    @engine.log.debug "Input files specified: #{@input_files}"
+    @input_files.each do |f| 
+      @engine.log.debug "Test file specified: #{f}"
+      if Dir.exist?( f )
+        # Expand path for file
+        f = File.expand_path( f )
+        look_for_files_in f
+      elsif File.exist?( f )
+        add( f )
+      else
+        # TODO: Show error
+        puts "Test file does not exist: #{f}"
+      end
+    end
+  end
+
+  #
+  # Look for test files in a directory.
+  # The directory might be provided as a parameter to the test runner,
+  # or if no parameter is provided, it is the current directory.
+  #
+  def look_for_files_in dir
+    @engine.log.debug "Looking for test files in: #{dir}"
+    root = File.join( dir, TEST_FILE_PATTERN )
+    files = Dir.glob( root )
+    @engine.log.debug "Found files: #{@files}"
+    files.each do |f| 
+      @engine.log.debug "Found: #{f}"
+      add f
+    end
+  end
+  
+  #
+  # Add a test file to the collection.
+  #
+  def add( file )
+    @files << TestFile.new( @engine, file )
+  end
+
+  # 
+  # Randomize the order of the test files.
+  #
+  def randomize
+    @engine.log.debug "Randomizing test files…"
+    @files.shuffle!
+  end
+
+  # 
+  # Get the number of test files.
+  #
+  def count
+    return @files.length
+  end
+
+  #
+  # Iterator method for Enumerable interface.
+  #
+  def each(&block)
+    @files.each(&block)
+  end
+
+end
+
+
+

data/lib/test_runner.rb

@@ -0,0 +1,74 @@
+#
+# Test Runner.
+#
+class TestRunner
+
+
+  #
+  # Set up the test runner.
+  #
+  def initialize( engine, input_files = nil )
+    @engine = engine
+
+    @files = TestFiles.new( @engine, input_files )
+    @results = Results.new( @engine )
+
+    @engine.log.debug "TestRunner initialized"
+  end
+
+  #
+  # Execute all tests and display results.
+  #
+  def run
+    setup
+
+    @results.start_timer    
+    run_for_files
+    @results.end_timer
+
+    @results.show_failures
+    @results.show_results
+    @engine.log.debug "TestRunner is finished"
+  end
+
+  # 
+  # Set up the test runner.
+  #
+  def setup
+    @engine.log.debug "TestRunner is running…"
+    puts
+    puts "Gloo Test Runner".white
+    puts
+
+    # Get a list of test files and randomize
+    @files.detect_files
+    @results.file_count = @files.count
+    @files.randomize
+  end
+
+  #
+  # Run tests for each file.
+  #
+  def run_for_files
+    @files.each do |file|
+      run_one_file( file )
+    end
+    puts
+  end
+
+  #
+  # Run tests for a single file.
+  # Once done, reset the engine's state.
+  #
+  def run_one_file( file )
+    # Run all tests in the file
+    # Add the results to the overall results
+    file.run_tests( @results )
+
+    # Reset the engine's state
+    @engine.reset_state
+  end
+end
+
+
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: gloo-test
+version: !ruby/object:Gem::Version
+  version: '1.1'
+platform: ruby
+authors:
+- Eric Crane
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Adds Gloo Unit Test support to Gloo.
+email:
+- eric.crane@mac.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/assert.rb
+- lib/gloo-test.rb
+- lib/refute.rb
+- lib/result.rb
+- lib/results.rb
+- lib/test.rb
+- lib/test_file.rb
+- lib/test_files.rb
+- lib/test_runner.rb
+homepage: https://github.com/ecrane/gloo
+licenses:
+- MIT
+metadata:
+  gloo.type: core-library
+  documentation_uri: https://github.com/ecrane/gloo
+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: 4.0.17
+specification_version: 4
+summary: Gloo core library. Gloo Unit Test support.
+test_files: []