tet 1.5.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71c11439cad3f5c481d5242bc65ade2c8780804f
-  data.tar.gz: 6a410a5f775aa07096ed3b56e06cf85baddbdb33
+  metadata.gz: b9c5b7e8d1240ae647425b19d13b5307bedf74a5
+  data.tar.gz: 930d474cc6a5f09b57bc590a5d8ef97a00c7622d
 SHA512:
-  metadata.gz: 4bcdfe86d7625c0a0a259a75f61b76165f0bb5dcb20400edaa950207553eaa451af2a219f5b7075c56caabdd46abf0fc573d006e2a3682b70fad43d41027bc2f
-  data.tar.gz: b24180e3e816c9e165d857547072f73e5f4d2a0cbe6d9f5a010e4017a9bf1a95392374228110d45b05241442e3793ebe12bbb9a7a3e8625dd9020c076f17e624
+  metadata.gz: 8d6f765630b953aa0d691d4aa09d02297e4460eb48bd71d4841b1ca7393a39bb88429541bae25494798b69fc26cd10b0aab7c578fa527edc092dc5db67ce8746
+  data.tar.gz: d5ccdc37e41471a2ad0cf5d2cf6c4e029db2bae7f1db7d8b8346091b797fe90143a601d74adce29e56465cc241fda87393d47a03f0ef465450d7c5636dd5f785

data/lib/tests.rb

@@ -7,45 +7,69 @@
 
 require_relative './tet'
 
-class IntendedError      < StandardError; end
-class IntendedErrorChild < IntendedError; end
+SHOW_EXPECTED = false
 
-puts ".!?!!?!!!!!!.!.??????? (expected result)"
+def prefix string
+  if SHOW_EXPECTED
+    TetCore.break_after_print
+    print string
+  end
+end
 
-assert('true blocks pass')  { true  }
-assert('false blocks fail') { false }
+def pass; prefix 'PASS  = '; end
+def fail; prefix 'FAIL  = '; end
+def err;  prefix 'ERROR = '; end
 
-assert('errors are caught') { raise IntendedError }
+def test_between
+  assert('Intentional failure') { false }
+  yield
+  assert('') { true }
+  yield
+  assert('Intentional failure') { false }
+end
 
-group '#group' do
-  assert('first failure')  { false }
-  assert('second failure') { false }
+class IntendedError < StandardError; end
 
-  group('errors are caught') { raise IntendedError }
-end
+group('#assert') do
+  pass; assert('True assertions pass') { true }
+  fail; assert('False assertions fail') { false }
+  err; assert('Errors are caught') { raise IntendedError.new('error message') }
 
-group 'anything can be a label' do
-  assert(:a_symbol)    { false }
-  assert(Class)        { false }
-  assert(Enumerable)   { false }
-  assert(true)         { false }
-  assert({x: 1, y: 2}) { false }
-  assert(nil)          { false }
+  puts 'Multiple passes in a row show on one line:'
+  assert('') { true }
+  assert('') { true }
+  assert('') { true }
 end
 
-group '#err' do
-  err('errors pass')     { raise IntendedError }
-  err('non-errors fail') { true }
+group('#group') do
+  group('Can nest') do
+    fail; assert('Intentional failure') { false }
+  end
 
-  err('correct errors pass',  expect: IntendedError)      { raise IntendedError }
-  err('incorrect errors err', expect: IntendedErrorChild) { raise IntendedError }
+  group('Can have classes as names') do
+    group(String) do
+      fail; assert('Intentional failure') { false }
+    end
+  end
 end
 
-group 'should not nest' do
-  assert('#assert in #assert') { assert    { true                } }
-  assert('#group in #assert')  { group('') { 'empty #group'      } }
-  assert('#err in #assert')    { err       { raise IntendedError } }
-  err('#assert in #err')       { assert    { true                } }
-  err('#group in #err')        { group('') { 'empty #group'      } }
-  err('#err in #err')          { err       { raise IntendedError } }
+group('#error') do
+  fail; error('True errors fail', expect: StandardError) { true }
+  fail; error('False errors fail', expect: StandardError) { false }
+
+  err; error('Unexpected errors err', expect: NoMethodError) do
+    raise IntendedError.new('should expect different error')
+  end
+
+  pass; error('Expected errors pass', expect: IntendedError) do
+    raise IntendedError.new('SHOULD NOT BE SEEN')
+  end
 end
+
+puts
+puts "Testing #puts between different results:"
+test_between { puts 'Test of #puts' }
+
+puts
+puts "Testing #p between different results:"
+test_between { p 'Test of #p' }

data/lib/tet.rb

@@ -5,299 +5,144 @@
 # terms of the three-clause BSD license. See LICENSE.txt
 # (located in root directory of this project) for details.
 
-# Label a block of tests.
-def group label, &block
-  Tet.run(
-    label: label,
-    test:  block
-  )
-end
-
-# Assert that a block will return a truthy value.
-def assert label = '', &block
-  Tet.run(
-    label:   label,
-    test:    block,
-    no_nest: true,
-    truthy:  -> { Tet.passed },
-    falsy:   -> { Tet.failed }
-  )
-end
-
-# Assert that a block will err.
-def err label = '', expect: StandardError, &block
-  Tet.run(
-    label:   label,
-    test:    block,
-    no_nest: true,
-    truthy:  -> { Tet.failed },
-    falsy:   -> { Tet.failed },
-    error:   ->(caught) do
-               (expect >= caught.class) ? Tet.passed : Tet.erred(caught, expect)
-             end
-  )
-end
-
-
-
-# A namespace for all of the helper methods and classes.
-module Tet
-  # Print all the reports after all the tests have run.
+module TetCore
+  INDENT_DEPTH = 4
+  SEPERATOR    = '  |  '
+  FAIL_HEADER  = 'FAIL:  '
+  ERROR_HEADER = 'ERROR: '
+
+  @prev_printed = false
+  @messages     = []
+  @counts       = Struct.new(:tests, :fails, :errors)
+                        .new(0,      0,      0)
+
+  # Output totals at the end of the test run.
   at_exit do
-    puts
-    puts_report 'Failures',   failure_report
-    puts_report 'Exceptions', error_report
-    puts_report 'Statistics', statistics_report
+    puts "\nTests: #{@counts.tests}   Fails: #{@counts.fails}   Errors: #{@counts.errors}"
   end
 
-
-
-  # An exception class to distinguish errors from incorrectly written tests.
-  class TestError < StandardError; end
-
-
-
-  # Object oriented ways to do string formatting.
-  module StringFormatting
-    refine String do
-      def indent
-        gsub(/^/, '    ')
-      end
-
-      def to_label_string
-        self
-      end
-    end
-
-    refine Module do
-      def to_label_string
-        name
-      end
+  class << self
+    # Record an assertion.
+    def assert
+      @counts.tests += 1
     end
 
-    refine Object do
-      def to_label_string
-        inspect
-      end
+    # Record a passing assertion.
+    def pass
+      checked_print ?.
     end
-  end
-
-  using StringFormatting
 
-
-
-  # Helpers for building test methods.
-  class << self
-    # Call when an assertion has passed.
-    def passed
-      print_now ?.
-      Data.add_note(:pass)
+    # Record a failing assertion.
+    def fail
+      @counts.fails += 1
+      puts_failure_data(header: FAIL_HEADER)
     end
 
-    # Call when an assertion has failed.
-    def failed
-      print_now ?!
-      Data.add_note(:fail)
+    # Run a block under a certain name, catching and printing errors.
+    def group name
+      @messages << name
+      yield
+    rescue StandardError => caught
+      @counts.errors += 1
+      puts_failure_data(
+        header:          ERROR_HEADER,
+        additional_info: error_to_info_array(caught)
+      )
+    ensure
+      @messages.pop
     end
 
-    # Call when an assertion has erred.
-    def erred caught, expected = nil
-      print_now ??
-      Data.add_note(:error, caught: caught, expected: expected)
+    # Add a line break if the last output was a #print instead of a #puts.
+    def break_after_print
+      checked_puts if @prev_printed
     end
 
-    # Run a block as a test.
-    def run label:,
-            truthy:  -> { },
-            falsy:   -> { },
-            error:   ->(caught) { erred(caught) },
-            no_nest: false,
-            test:
-
-      Data.with_label(label) do
-        nesting_guard(no_nest) do
-          begin
-            test.call ? truthy.call : falsy.call
-          rescue TestError => caught
-            erred(caught)
-          rescue StandardError => caught
-            error.call(caught)
-          end
-        end
-      end
-
-      nil
-    end
+    # Alias original #puts and #p methods.
+    alias_method :real_puts, :puts
+    alias_method :real_p, :p
+    public :real_puts
+    public :real_p
 
-  private
+    private
 
-    # Print out a string immediately. Calling #print alone may have a delay.
-    def print_now string
-      print string
-      $stdout.flush
-    end
+    # Output data related to a failure.
+    def puts_failure_data header:, additional_info: []
+      break_after_print
+      checked_puts header + @messages.join(SEPERATOR)
 
-    # Print out a report to stdout.
-    def puts_report header, content
-      unless content.empty?
-        puts
-        puts "#{header}:"
-        puts content.indent
+      additional_info.each.with_index do |text, index|
+        checked_puts indent(text, index + 1)
       end
     end
 
-    # Render a string with details about all of the test run.
-    def statistics_report
-      pass_count  = Data.count_type(:pass)
-      fail_count  = Data.count_type(:fail)
-      error_count = Data.count_type(:error)
-
-      output = []
-      output << "Errors: #{error_count}" unless error_count.zero?
-      output << "Failed: #{fail_count}"  unless fail_count.zero?
-      output << "Passed: #{pass_count}"  unless pass_count.zero?
-
-      output.join(?\n)
+    # Perform a #puts and then set a flag for future line breaks.
+    def checked_puts object = ''
+      real_puts object
+      @prev_printed = false
     end
 
-    # Render a string with details about all of the failures encountered.
-    def failure_report
-      errors = Data.select_type(:error)
-
-      Data.select_type(:fail, :error)
-          .map do |node|
-            node.label
-                .tap do |label|
-                  if node.type == :error
-                    error_note  = "EXCEPTION_#{1 + errors.index(node)}"
-                    expected    = node.data[:expected]
-                    error_note << " (expected: #{expected}" if expected
-
-                    label << error_note
-                  end
-                end
-                .map(&:to_label_string)
-                .join('  ::  ')
-          end
-          .join(?\n)
+    # Perform a #print and then set a flag for future line breaks.
+    def checked_print object = ''
+      print object
+      @prev_printed = true
     end
 
-    # Render a string with details about all of the errors encountered.
-    def error_report
-      Data.select_type(:error)
-          .map.with_index do |node, index|
-            error    = node.data[:caught]
-            message  = error.to_s
-            message << " (#{error.class})" if message != error.class.to_s
-            summary  = "#{index + 1}. #{message}"
-
-            error.backtrace
-                 .reject { |line| line.start_with?(__FILE__) }
-                 .map    { |line| line.indent }
-                 .unshift(summary)
-                 .join(?\n)
-          end
-          .join("\n\n")
+    # Indent each line of a given string by a given amount.
+    def indent string, amount
+      indent_string = ' ' * amount * INDENT_DEPTH
+      string.gsub(/^/, indent_string)
     end
 
-    # Check and set a flag to prevent test blocks from nesting
-    def nesting_guard guard_state
-      raise TestError, 'assertions can not be nested' if @nesting_banned
-      @nesting_banned = guard_state
-      yield
-    ensure
-      @nesting_banned = false
+    # Convert an error object into an array of strings describing the error.
+    def error_to_info_array error
+      [
+        "#{error.class}: #{error.message}",
+        error.backtrace
+             .reject { |path| path.match?(/^#{__FILE__}:/) }
+             .join(?\n)
+      ]
     end
   end
+end
 
+# Group together assertions and groups under a given name.
+def group name
+  TetCore.group(name) { yield }
+end
 
-  # Because tests are represented as series of nested groups containing
-  # assertions, the test data is stored in a tree.
-  module Tree
-    module Basics
-      include Enumerable
-
-      # Create and append a new node to this node, returning the new node.
-      def append_node type, data
-        Node.new(type: type, data: data, parent: self)
-            .tap { |node| @children << node }
-      end
-
-      # Recursively iterate over each node in the test data tree in the order
-      # that they were added.
-      def each &block
-        @children.each do |node|
-          block.call(node)
-          node.each(&block)
-        end
-      end
-    end
-
-    # The root of the tree with methods to terminate Node methods which search
-    # up the tree, as well as methods for enumerating over the test data, adding
-    # labels and adding nodes.
-    class Root
-      include Basics
-
-      def initialize
-        @children     = []
-        @current_node = self
-      end
-
-      # Terminate Node#label.
-      def label
-        []
-      end
-
-      # Run a block where any notes added will be inside a new label node.
-      def with_label label
-        previous      = @current_node
-        @current_node = add_note(:label, label)
-        yield
-      ensure
-        @current_node = previous
-        self
-      end
-
-      # Add a node to note some data within the node that is currently active.
-      def add_note type, data = nil
-        @current_node.append_node(type, data)
-      end
-
-      # Get an array of all nodes of some type in the order they were added.
-      def select_type *types
-        select { |node| types.include?(node.type) }
-      end
-
-      # Count the number of nodes of a given type.
-      def count_type type
-        select_type(type).size
-      end
-    end
-
-    # A node to store data about that some point in the test tree
-    class Node
-      include Basics
-      attr_reader :data, :type
+# Assert that a given block will return true.
+def assert name
+  TetCore.group(name) do
+    TetCore.assert
 
-      def initialize parent:, type:, data: nil
-        @type     = type
-        @data     = data
-        @parent   = parent
-        @children = []
-      end
+    yield ? TetCore.pass : TetCore.fail
+  end
+end
 
-      # Generate the array of labels that identify this point in the tree.
-      def label
-        if @type == :label
-          @parent.label + [@data]
-        else
-          @parent.label
-        end
-      end
+# Assert that a given block will raise an expected error.
+def error name, expect:
+  TetCore.group(name) do
+    begin
+      TetCore.assert
+      yield
+    rescue expect
+      TetCore.pass
+    else
+      TetCore.fail
     end
   end
+end
+
+# A redefined version of #puts which ensures a line break before the printed
+# object (for easier debugging).
+def puts object = ''
+  TetCore.break_after_print
+  TetCore.real_puts(object)
+end
 
-  # The instance of the Tree data structure that stores all of the test results.
-  Data = Tree::Root.new
+# A redefined version of #p which ensures a line break before the printed
+# object (for easier debugging).
+def p object
+  TetCore.break_after_print
+  TetCore.real_p(object)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tet
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Colin Fulton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-12-03 00:00:00.000000000 Z
 dependencies: []
 description: A very minimal test framework designed for simple projects. A couple
   of features, relatively nice looking output, and nothing else. Does the world need
@@ -32,7 +32,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.3
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="