tet 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1096a4a6ae70158e1f6f70394a2b9d5f246a18c
-  data.tar.gz: 2b5bad1375b9dbdac13a038ae07360c1a81e27f2
+  metadata.gz: 97ce2949a018ea80d5012fc9dd00268098dd0ece
+  data.tar.gz: fefa2a09bfc0adf45730b15be19785812e75d535
 SHA512:
-  metadata.gz: 9fd9ff0cc0747b0c8e4594e11855b550cb5d62661bdc648da8ef5f293f3594634bbae582f770fcff86c03041c8c26fe900d5996bcd5985fad49817db36b032c9
-  data.tar.gz: 0102c03c6892f95f948d345497ff8b0fc785e317d0116ad48be4df82177290438e75809a021a2a6699990c36c05c4e78f9d0cda98e98c6ce8a334f32a78bbe7e
+  metadata.gz: c60b11a370e690471156621bce8884a3daaaa13bab34e0bb80cb0a9c8e52fb11b24d9f2231f42ff80d0aa65804e25000069095324bbfb3f0f2d125d5dfc0dc6c
+  data.tar.gz: '0719db9dedda2b62d2a413dd3b3342a28c87cff1855fb41b300e165aef30d2998156e67c3b153f1b7ef765f1cf1831e920b570efa613fb056e41d323aba95ab5'

data/lib/tests.rb

@@ -1,77 +1,51 @@
-# Copyright (C) 2016 Colin Fulton
+# Copyright (C) 2017 Colin Fulton
 # All rights reserved.
 #
 # This software may be modified and distributed under the
 # terms of the three-clause BSD license. See LICENSE.txt
 # (located in root directory of this project) for details.
 
-require_relative "./tet"
-require_relative "./test_helpers"
+require_relative './tet'
 
-group "#assert" do
-  assert("truthy blocks pass") { true }
+class IntendedError      < StandardError; end
+class IntendedErrorChild < IntendedError; end
 
-  result = assert { true }
-  assert("passing returns true") { result.equal?(true) }
+puts ".!?!!?!!!!!!.!.??????? (expected result)"
 
-  result = should_fail { assert { false } }
-  assert("failing returns false") { result.equal?(false) }
+assert('true blocks pass')  { true  }
+assert('false blocks fail') { false }
 
-  should_fail do
-    assert("falsy blocks fail") { nil }
-    assert("empty assertions fail") { }
+assert('errors are caught') { raise IntendedError }
 
-    assert("can not nest #assert") { assert("nested") { true            }; nil }
-    assert("can not nest #group")  { group("nested")  { assert { true } }; nil }
-    assert("can not nest #err")    { err("nested")    { not_a_method    }; nil }
-  end
+group '#group' do
+  assert('first failure')  { false }
+  assert('second failure') { false }
 
-  should_err do
-    assert("errors are caught and count as failures") { not_a_method }
-  end
+  group('errors are caught') { raise IntendedError }
 end
 
-group "#group" do
-  expected = "example output"
-  result   = group("EXAMPLE") do
-               assert("EXAMPLE") { true }
-               expected
-             end
-  assert("returns output of block") { result == expected }
-
-  return_value = should_err { group { raise "Example Error" } }
-  assert("returns nil when the block throws an error") { return_value.nil? }
-
-  group 'fails when empty' do
-    should_fail { group('group without content') { } }
-  end
-
-  group "can have classes for names" do
-    group String do
-      should_fail { assert { false } }
-    end
-  end
+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 }
 end
 
-group "#err" do
-  err("passes when there is an error") { not_a_method }
-
-  err("specify an exception class",       expect: NameError) { not_a_method }
-  err("specify a parent exception class", expect: Exception) { not_a_method }
+group '#err' do
+  err('errors pass')     { raise IntendedError }
+  err('non-errors fail') { true }
 
-  result = err { not_a_method }
-  assert("passing returns true") { result.equal?(true) }
-
-  result = should_fail { err { 1 + 1 } }
-  assert("failing returns false") { result.equal?(false) }
-
-  should_fail do
-    err("no errors fails") { 1 + 1 }
-    err("empty assertions fail") { }
-    err("wrong class fails", expect: ArgumentError) { not_a_method }
+  err('correct errors pass',   expect: IntendedError)      { raise IntendedError }
+  err('incorrect errors err', expect: IntendedErrorChild) { raise IntendedError }
+end
 
-    err("can not nest #err")    { err("nested")    { not_a_method    }; 1 + 1 }
-    err("can not nest #assert") { assert("nested") { true            }; 1 + 1 }
-    err("can not nest #group")  { group("nested")  { assert { true } }; 1 + 1 }
-  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 } }
 end

data/lib/tet.rb

@@ -1,222 +1,285 @@
-# Copyright (C) 2016 Colin Fulton
+# Copyright (C) 2017 Colin Fulton
 # All rights reserved.
 #
 # This software may be modified and distributed under the
 # terms of the three-clause BSD license. See LICENSE.txt
 # (located in root directory of this project) for details.
 
-# Label all tests within a block.
-def group name = nil
-  before = Tet.test_count
+# Label a block of tests
+def group label, &block
+  Tet.run(
+    label: label,
+    test:  block
+  )
+end
 
-  Tet.in_group(name) do
-    yield.tap do
-      if Tet.test_count == before
-        Tet.log_fail("EMPTY GROUP")
-      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) {
+               (expect >= caught.class) ? Tet.passed : Tet.erred(caught, expect)
+             }
+  )
+end
+
+
+
+# A namespace for all of the helper methods and classes.
+module Tet
+  # Print all the reports after all the tests have run
+  at_exit do
+    unless Stats.empty?
+      puts
+      puts_report 'Failures',   Messages.failure_report
+      puts_report 'Exceptions', Messages.error_report
+      puts_report 'Statistics', Stats.report
     end
   end
-end
 
-# Declare that a block will return a truthy value.
-# If it doesn't or if it has an error, the test will be logged as failing.
-def assert name = nil
-    Tet.in_group(name) do
-      result = false
 
-      Tet.stop_nesting("NESTED IN ASSERT: #{name}") do
-        begin
-          result = yield
 
-          if result
-            Tet.log_pass
-          else
-            Tet.log_fail
-          end
-        rescue StandardError => error_object
-          Tet.log_error(error_object)
-        end
+  # An exception class to distinguish errors from incorrectly written tests
+  class TestError < StandardError; end
+
+  # Object oriented way to do string formatting
+  module StringFormatting
+    refine String do
+      def indent
+        gsub(/^/, '    ')
       end
 
-      !!result
+      def to_label
+        self
+      end
     end
-end
-
-# Declare that a block will have an error.
-# If it doesn't the test will be logged as failing.
-def err name = nil, expect: StandardError
-  Tet.in_group(name) do
-    result = false
 
-    Tet.stop_nesting("NESTED IN ERR: #{name}") do
-      begin
-        yield
-        Tet.log_fail
-      rescue StandardError => error_object
-        if expect >= error_object.class
-          result = true
-          Tet.log_pass
-        else
-          Tet.log_wrong_error(expected: expect, got: error_object)
-        end
+    refine Module do
+      def to_label
+        name
       end
     end
 
-    result
+    refine Object do
+      def to_label
+        inspect
+      end
+    end
   end
-end
 
-# A namespace for all of the helper methods.
-module Tet
-  PassChar  = "."
-  FailChar  = "F"
-  ErrorChar = "!"
-  Indent    = "    "
-
-  @messages      = []
-  @current_group = []
-  @test_count    = 0
-  @fail_count    = 0
-  @err_count     = 0
-  @nested_ban    = false
+  using StringFormatting
+
 
+
+  # Helpers for building test methods
   class << self
-    attr_reader :messages, :test_count, :fail_count, :err_count
+    # Call when an assertion has passed
+    def passed
+      Stats.passed
+    end
 
-    # Store the group name for the duration of calling the given block.
-    def in_group name
-      result = nil
+    # Call when an assertion has failed
+    def failed
+      Stats.failed
+      Messages.failed
+    end
 
-      @current_group << name.to_s if name
+    # Call when an assertion has erred
+    def erred caught, expected = nil
+      Stats.erred
+      Messages.erred(caught, expected)
+    end
 
-      begin
-        if @nested_ban
-          log_fail @nested_ban
-        else
-          result = yield
+    # Run a block as a test
+    def run label:,
+            truthy:  -> { },
+            falsy:   -> { },
+            error:   ->(caught) { erred(caught) },
+            no_nest: false,
+            test:
+
+      Messages.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
-      rescue StandardError => error_object
-        log_error error_object, "ERROR IN GROUP"
       end
 
-      @current_group.pop if name
+      nil
+    end
+
+    private
 
-      result
+    # Print out a report to stdout
+    def puts_report header, content
+      unless content.empty?
+        puts
+        puts "#{header}:"
+        puts content.indent
+      end
     end
 
-    def stop_nesting message
-      @nested_ban = message
+    # 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
-      @nested_ban = false
+    ensure
+      @nesting_banned = false
     end
+  end
 
-    # Log a passing test.
-    def log_pass
-      print_now PassChar
 
-      @test_count += 1
-    end
 
-    # Log a failing test.
-    def log_fail *messages, letter: FailChar
-      print_now letter
+  # Tracks and reports statistics about the tests that have run
+  module Stats
+    Counts = { passed: 0,  failed: 0,  erred: 0  }
+    Marks  = { passed: ?., failed: ?!, erred: ?? }
 
-      @test_count += 1
-      @fail_count += 1
+    class << self
+      # Call when an assertion has passed
+      def passed
+        log :passed
+      end
 
+      # Call when an assertion has failed
+      def failed
+        log :failed
+      end
 
-      group           = @current_group.dup
-      current_section = @messages
-      messages        = messages.map { |item| item.is_a?(Array) ? item : "✖ #{item}" }
+      # Call when an assertion has erred
+      def erred
+        log :erred
+      end
 
-      # Walk down the tree of messages until either you find the current group's
-      # array of messages OR the last section in common with the current group.
-      until group.empty? || group.first != current_section[-2]
-        group.shift
-        current_section = current_section.last
+      # Returns true if no statistics have been logged
+      def empty?
+        Counts.values.inject(&:+).zero?
       end
 
-      # If the messages were missing parts of this group fill out the remaining
-      # group names.
-      until group.empty?
-        current_section << group.shift << []
-        current_section = current_section.last
+      # Returns a string with statistics about the tests that have been run
+      def report
+        errors = Counts[:erred]
+        fails  = Counts[:failed]
+        passes = Counts[:passed]
+
+        output = []
+        output << "Errors: #{errors}" unless errors.zero?
+        output << "Failed: #{fails}"
+        output << "Passed: #{passes}"
+
+        output.join(?\n)
       end
 
-      # Append the new messages onto the current section.
-      current_section.concat(messages)
-    end
+      private
 
-    # Log an error.
-    def log_error error_object, *messages
-      @err_count += 1
-      log_fail *messages, *format_error(error_object), letter: ErrorChar
-    end
+      # Log an event and print a mark to show progress is being made on tests
+      def log type
+        Counts[type] += 1
 
-    # Log test which raised the wrong error.
-    def log_wrong_error expected:, got:
-      log_fail "EXPECTED: #{expected}", *format_error(got)
+        print Marks[type]
+        $stdout.flush
+      end
     end
+  end
+
+
+  # Tracks and reports messages for each test
+  module Messages
+    Labels  = []
+    Results = []
+    Errors  = []
+
+    class << self
+      # Add a label to all subsequent messages
+      def with_label label
+        Labels.push(label)
+        yield
+      ensure
+        Labels.pop
+      end
+
+      # Call when an assertion has failed
+      def failed
+        add_result!
+      end
 
-    # Print stats and messages for all the failing tests.
-    def render_result
-      puts "\n" unless @test_count.zero?
+      # Call when an assertion has passed
+      def erred caught, expected = nil
+        number = Stats::Counts[:erred]
+        label  = "EXCEPTION_#{number}"
+        label << " (expected: #{expected})" if expected
 
-      print "#{plural @test_count, 'result'}, "
+        with_label(label) { add_result! }
 
-      if (@fail_count + @err_count).zero?
-        print "all good!"
-      else
-        print "#{plural @fail_count, 'fail'}"
-        print " (including #{plural @err_count, 'error'})" unless @err_count.zero?
+        Errors.push(error_message(caught, number))
       end
 
-      print "\n"
+      # Returns a string with details about all failed tests
+      def failure_report
+        Results.join(?\n)
+      end
 
-      unless @messages.empty?
-        puts "\nFailed tests:"
-        puts indent(@messages)
+      # Returns a string with details about all errors
+      def error_report
+        Errors.join("\n\n")
       end
-    end
 
-    private
+      private
 
-    # Format an error message so #indent will render it properly
-    def format_error error_object
-      [
-        "ERROR: #{error_object.class}",
-        [
-          "#{error_object.message}",
-          error_object.backtrace
-        ]
-      ]
-    end
+      # Add a message for a new result using the current labels
+      def add_result!
+        Results.push(
+          Labels.map { |raw| raw.to_label }
+                .reject(&:empty?)
+                .join('  ::  ')
+        )
+      end
 
-    # Format an array of strings by joining them with \n and indenting nested
-    # arrays deeper than their parents.
-    def indent input, amount = 0
-      case input
-      when String
-        input.gsub(/^/, Indent * amount)
-      when Array
-        input
-          .reject(&:empty?)
-          .map { |part| indent(part, amount + 1) }
-          .join("\n")
+      def format_label label
+        case label
+        when Module
+          label.name
+        when String
+          label.to_s
+        else
+          label.inspect
+        end
       end
-    end
 
-    # Pluralize the given word.
-    def plural amount, word
-      "#{amount} #{word}#{amount != 1 ? "s" : ""}"
-    end
+      # Format an error into a message string
+      def error_message error, number
+        error_message  = error.to_s
+        error_class    = error.class.to_s
+        error_message << " (#{error.class})" if error_message != error_class
+
+        summary  = "#{number}. #{error_message}"
+        details  = error.backtrace
+                        .reject { |line| line.start_with?(__FILE__) }
+                        .map    { |line| line.indent }
 
-    # Prevent delays in printing results.
-    def print_now string
-      print string
-      $stdout.flush
+        details.unshift(summary).join(?\n)
+      end
     end
   end
-
-  at_exit { Tet.render_result }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tet
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Colin Fulton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-10 00:00:00.000000000 Z
+date: 2017-03-08 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
@@ -40,7 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Barely a test framework