tet 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44bf1dbabac3f4b26c14a10ffc4d8bbc33437313
-  data.tar.gz: d72933e6c68011c2440dc74637c6a0e4e5921dd1
+  metadata.gz: 6df1946431552379933de20912968be739eab224
+  data.tar.gz: c62f656b7d3f666c6d78dc6069ee335b698c7a9b
 SHA512:
-  metadata.gz: f43d8dc735eb8ee73a12d1de92f743d7a947bf42236c59679f3a2cc9891c36547b55cac0c94fd3449cb24f0c3d23f400d12d3e4827b05c1fcd87165ba55b03fb
-  data.tar.gz: 56f318bcfcf9e7455d1a6db92b05b4d139017047c6bcde05a4dd4bcaa6caa057545c3e4c2eedce0c137870b6f86c9abd8b86ab340743de60ab32349731572299
+  metadata.gz: 395c666f9638b07ff91517ddd9e70acecf91d5c9a49b8ba49932debfd097f1300fa3cc675a4476962b1fb0585245e322fba10cc61eabd583a25fbffceb362b2e
+  data.tar.gz: f0472526eb13689f3e89e5f44415d8689e124c7f4fc3e56856c8511e3551bfbacabe6f891dd4a22ee250f93a69afadcedaa7d1dfeccc94a963b143545588db89

data/lib/tests.rb

@@ -6,83 +6,41 @@
 # (located in root directory of this project) for details.
 
 require_relative "./tet"
-
-$missed_fails   = 0
-$missed_errs    = 0
-$expected_fails = 0
-$expected_errs  = 0
-
-at_exit do
-  puts <<~END
-    \n
-    #{$missed_fails} missed fails
-    #{$missed_errs} missed errs
-    #{total_fails - $expected_fails + $missed_fails} unintended fails
-    #{total_errs - $expected_errs + $missed_errs} unintended errs
-  END
-end
-
-def total_fails
-  Tet.fail_count - Tet.err_count
-end
-
-def total_errs
-  Tet.err_count
-end
-
-# Wraps the block in a group to label it as an example instead of a real test.
-def should_fail
-  $expected_fails += 1
-  prev_fail_count  = total_fails
-  result           = false
-
-  group("INTENDED FAILURE") { result = yield }
-
-  $missed_fails += 1 if prev_fail_count == total_fails
-
-  result
-end
-
-# Wraps the block in a group to label it as an example instead of a real test.
-def should_err
-  $expected_errs += 1
-  prev_err_count  = total_errs
-  result          = false
-
-  group("INTENDED ERROR") { result = yield }
-
-  $missed_errs += 1 if prev_err_count == total_errs
-
-  result
-end
+require_relative "./test_helpers"
 
 group "#assert" do
   assert("truthy blocks pass") { true }
 
-  should_fail { assert("falsy blocks fail") { nil } }
-  should_err { assert("errors are caught and count as failures") { not_a_method } }
-  should_fail { assert("empty assertions fail") {} }
+  result = assert { true }
+  assert("passing returns true") { result.equal?(true) }
+
+  result = should_fail { assert { false } }
+  assert("failing returns false") { result.equal?(false) }
 
-  assert("passing returns true") {  assert { true }.equal?(true) }
+  should_fail do
+    assert("falsy blocks fail") { nil }
+    assert("empty assertions fail") { }
+
+    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
 
-  should_fail { assert("failing returns false") { nil }.equal?(false) }
+  should_err do
+    assert("errors are caught and count as failures") { not_a_method }
+  end
 end
 
 group "#group" do
-  assert "returns output of block" do
-    result = group("EXAMPLE") do
+  expected = "example output"
+  result   = group("EXAMPLE") do
                assert("EXAMPLE") { true }
-               "example output"
+               expected
              end
-
-      result == "example output"
-  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" do
-    return_value.nil?
-  end
+  assert("returns nil when the block throws an error") { return_value.nil? }
 
   group 'fails when empty' do
     should_fail { group('group without content') { } }
@@ -96,43 +54,24 @@ group "#group" do
 end
 
 group "#err" do
-  group "passes when there is an error" do
-    err { not_a_method }
-
-    assert "and returns true" do
-      err { not_a_method }.equal?(true)
-    end
-  end
-
-  should_fail { err("empty assertions fail") {} }
+  err("passes when there is an error") { not_a_method }
 
-  group "allows you to specify an exception class" do
-    err(expect: NameError) { 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 "or a parent exception class" do
-      err(expect: Exception) { not_a_method }
-    end
+  result = err { not_a_method }
+  assert("passing returns true") { result.equal?(true) }
 
-    assert "and returns true" do
-      err(expect: NameError) { not_a_method }.equal?(true)
-    end
-  end
+  result = should_fail { err { 1 + 1 } }
+  assert("failing returns false") { result.equal?(false) }
 
-  group "fails when there is no error" do
-    should_fail { err { 1+1 } }
+  should_fail do
+    err("no errors fails") { 1 + 1 }
+    err("empty assertions fail") { }
+    err("wrong class fails", expect: ArgumentError) { not_a_method }
 
-    assert "and returns false" do
-      should_fail { err { 1+1 } }.equal?(false)
-    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 "fails given wrong error class" do
-    should_fail { err(expect: ArgumentError) { not_a_method } }
-
-    assert "and returns false" do
-      should_fail { err(expect: ArgumentError) { not_a_method } }.equal?(false)
-    end
-  end
-
-  should_fail { err("Can have a name") { 1+1 } }
 end

data/lib/tet.rb

@@ -10,30 +10,36 @@ def group name = nil
   before = Tet.test_count
 
   Tet.in_group(name) do
-    yield.tap { Tet.fail "EMPTY GROUP" if Tet.test_count == before }
+    yield.tap do
+      if Tet.test_count == before
+        Tet.log_fail("EMPTY GROUP")
+      end
+    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
-
-    begin
-      result = yield
-
-      if result
-        Tet.pass
-      else
-        Tet.fail
+    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
       end
-    rescue StandardError => error_object
-      Tet.error(error_object)
-    end
 
-    !!result
-  end
+      !!result
+    end
 end
 
 # Declare that a block will have an error.
@@ -42,15 +48,17 @@ def err name = nil, expect: StandardError
   Tet.in_group(name) do
     result = false
 
-    begin
-      yield
-      Tet.fail
-    rescue StandardError => error_object
-      if expect >= error_object.class
-        result = true
-        Tet.pass
-      else
-        Tet.wrong_error(expected: expect, got: error_object)
+    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
       end
     end
 
@@ -70,6 +78,7 @@ module Tet
   @test_count    = 0
   @fail_count    = 0
   @err_count     = 0
+  @nested_ban    = false
 
   class << self
     attr_reader :messages, :test_count, :fail_count, :err_count
@@ -81,9 +90,13 @@ module Tet
       @current_group << name.to_s if name
 
       begin
-        result = yield
+        if @nested_ban
+          log_fail @nested_ban
+        else
+          result = yield
+        end
       rescue StandardError => error_object
-        error error_object, "ERROR IN GROUP"
+        log_error error_object, "ERROR IN GROUP"
       end
 
       @current_group.pop if name
@@ -91,45 +104,56 @@ module Tet
       result
     end
 
+    def stop_nesting message
+      @nested_ban = message
+      yield
+      @nested_ban = false
+    end
+
     # Log a passing test.
-    def pass
+    def log_pass
       print_now PassChar
 
       @test_count += 1
     end
 
     # Log a failing test.
-    def fail *messeges, letter: FailChar
+    def log_fail *messages, letter: FailChar
       print_now letter
 
       @test_count += 1
       @fail_count += 1
 
-      group   = @current_group.dup
-      section = @messages
+      group           = @current_group.dup
+      current_section = @messages
 
-      until group.empty? || group.first != section[-2]
+      # 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
-        section = section.last
+        current_section = current_section.last
       end
 
+      # If the messages were missing parts of this group fill out the remaining
+      # group names.
       until group.empty?
-        section << group.shift << []
-        section = section.last
+        current_section << group.shift << []
+        current_section = current_section.last
       end
 
-      section.concat(messeges)
+      # Append the new messages onto the current section.
+      current_section.concat(messages)
     end
 
     # Log an error.
-    def error error_object, *messages
+    def log_error error_object, *messages
       @err_count += 1
-      fail *messages, *format_error(error_object), letter: ErrorChar
+      log_fail *messages, *format_error(error_object), letter: ErrorChar
     end
 
     # Log test which raised the wrong error.
-    def wrong_error expected:, got:
-      fail "EXPECTED: #{expected}", *format_error(got)
+    def log_wrong_error expected:, got:
+      log_fail "EXPECTED: #{expected}", *format_error(got)
     end
 
     # Print stats and messages for all the failing tests.
@@ -173,16 +197,19 @@ module Tet
       when String
         input.gsub(/^/, Indent * amount)
       when Array
-        input.reject(&:empty?)
-             .map { |part| indent(part, amount + 1) }
-             .join("\n")
+        input
+          .reject(&:empty?)
+          .map { |part| indent(part, amount + 1) }
+          .join("\n")
       end
     end
 
-    def plural amount, name
-      "#{amount} #{name}#{amount != 1 ? "s" : ""}"
+    # Pluralize the given word.
+    def plural amount, word
+      "#{amount} #{word}#{amount != 1 ? "s" : ""}"
     end
 
+    # Prevent delays in printing results.
     def print_now string
       print string
       $stdout.flush

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tet
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.0
 platform: ruby
 authors:
 - Colin Fulton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-03 00:00:00.000000000 Z
+date: 2017-02-10 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