lizarb 1.0.1 → 1.0.3

data/lib/liza/test/test_test.rb

@@ -1,108 +1,200 @@
-module Liza
-  class TestTest < Test
 
-    test :settings do
-      assert subject_class.log_level == :normal
-      assert subject_class.log_color == :white
+class Liza::TestTest < Liza::Test
+
+  test :settings do
+    assert subject_class.log_level == :normal
+    assert subject_class.log_color == :white
+  end
+
+  group :basics do
+    test :truths do
+      assert true
+      assert true
+      assert true
     end
 
-    group :basics do
-      test :truths do
-        assert true
-        assert true
-        assert true
+    test :falsehoods do
+      refute false
+      refute false
+      refute false
+    end
+
+    test :assertions do
+      assert assertions == 0
+      refute assertions != 1
+      assert assertions == 2
+    end
+  end
+
+  group :assertions do
+    test :assert do
+      assert 0
+      assert 1
+      assert :a
+      assert "a"
+      assert ""
+      assert []
+      assert [1]
+      assert({})
+      assert({a: 1})
+      assert true
+      refute false
+      refute nil
+    end
+
+    test :assert_equality do
+      assert_equality 0, 0
+      assert_equality 1, 1
+      assert_equality :a, :a
+      assert_equality "a", "a"
+      assert_equality "", ""
+      assert_equality [], []
+      assert_equality [1], [1]
+      assert_equality({}, {})
+      assert_equality({a: 1}, {a: 1})
+      assert_equality true, true
+      refute_equality false, true
+      refute_equality nil, true
+    end
+    
+    test :assert_raises do
+      assert_raises StandardError do
+        raise RuntimeError
       end
 
-      test :falsehoods do
-        refute false
-        refute false
-        refute false
+      assert_raises RuntimeError do
+        raise RuntimeError
       end
 
-      test :assertions do
-        assert assertions == 0
-        refute assertions != 1
-        assert assertions == 2
+      refute_raises RuntimeError do
+        raise StandardError
       end
     end
+  end
+  
+  group :instance_variables do
+    test :instance_variables do
+      assert_equality instance_variables, [:@test_words, :@before_stack, :@after_stack, :@test_block]
+    end
 
-    test :instance_groups do
-      assert assertions == 0
+    test :test_block do
+      assert_equality @test_block.source_location[1], __LINE__ - 1
+    end
+  end
 
-      group do
-        assert true
-        assert true
-        assert true
-      end
+  group :tree do
+    test :test_tree do
+      assert_equality self.class.test_tree.class, Liza::TestTreePart::Extension
+      assert_equality self.class.test_tree, self.class.test_tree.parent
+      
+      assert_equality 2, self.class.test_tree.tests.count
+      assert_equality 5, self.class.test_tree.children.count
 
-      assert assertions == 2
+      assert_equality self.class.test_tree.tests.map(&:first).flatten, [:settings, :instance_groups]
+    end
+  end
+
+  test :instance_groups do
+    assert assertions == 0
 
+    group do
+      assert true
+      assert true
+      assert true
+    end
+
+    assert assertions == 2
+
+    group do
+      assert true
       group do
         assert true
-        group do
-          assert true
-        end
-        assert true
       end
+      assert true
+    end
+
+    assert assertions == 4
+  end
 
-      assert assertions == 4
+  group :class_groups do
+    before do
+      @string = "START"
+      assert_equality @string, "START"
     end
 
-    group do
+    test :class_groups, :outer_a do
+      @string.concat "-123"
+      assert_equality @string, "START-123"
+      #
+      @expectation_outer = "START-123-FINISH"
+    end
+
+    test :class_groups, :outer_b do
+      @string.concat "-321"
+      assert_equality @string, "START-321"
+      #
+      @expectation_outer = "START-321-FINISH"
+    end
+
+    group :class_groups_inner do
       before do
-        @a = true
-        assert @a
+        @string.concat "-BEGIN"
+        assert_equality @string, "START-BEGIN"
       end
 
-      group do
-        before do
-          refute @b
-          @b = true
-        end
-
-        test :Test, :inner do
-          assert @a
-          assert @b
-        end
+      test :class_groups, :inner_a do
+        @string.concat "-aaa"
+        assert_equality @string, "START-BEGIN-aaa"
+        #
+        @expectation_inner = "START-BEGIN-aaa-END"
+        @expectation_outer = "START-BEGIN-aaa-END-FINISH"
       end
 
-      test :Test, :outer do
-        assert @a
-        refute @b
+      test :class_groups, :inner_b do
+        @string.concat "-bbb"
+        assert_equality @string, "START-BEGIN-bbb"
+        #
+        @expectation_inner = "START-BEGIN-bbb-END"
+        @expectation_outer = "START-BEGIN-bbb-END-FINISH"
       end
 
       after do
-        assert @a
-        refute @b
+        @string.concat "-END"
+        assert_equality @string, @expectation_inner
       end
     end
 
-    # group :throwables do
-    #   test :throw_within_test do
-    #     assert! true
-    #     assert! false
-    #     raise "it should not have reached this line"
-    #   end
-
-    #   group :throw_within_before do
-    #     before do
-    #       assert! false
-    #     end
-
-    #     test :that_will_not_run do
-    #       raise "it should not have reached this line"
-    #     end
-    #   end
-
-    #   group :throw_within_after do
-    #     test :that_will_not_run do
-    #       assert! false
-    #     end
-
-    #     after do
-    #       raise "it should not have reached this line"
-    #     end
-    #   end
-    # end
+    after do
+      @string << "-FINISH"
+      assert_equality @string, @expectation_outer
+    end
   end
+
+  # group :throwables do
+  #   test :throw_within_test do
+  #     assert! true
+  #     assert! false
+  #     raise "it should not have reached this line"
+  #   end
+
+  #   group :throw_within_before do
+  #     before do
+  #       assert! false
+  #     end
+
+  #     test :that_will_not_run do
+  #       raise "it should not have reached this line"
+  #     end
+  #   end
+
+  #   group :throw_within_after do
+  #     test :that_will_not_run do
+  #       assert! false
+  #     end
+
+  #     after do
+  #       raise "it should not have reached this line"
+  #     end
+  #   end
+  # end
 end

data/lib/liza/test_parts/test_assertions_advanced_part.rb

@@ -0,0 +1,125 @@
+class Liza::TestAssertionsAdvancedPart < Liza::Part
+  insertion do
+    
+    def assert_equality a, b, msg = nil, kaller: nil
+      ret = a == b
+
+      if ret
+        self.class._assertion_passed
+        @last_result = :passed
+      else
+        self.class._assertion_failed msg
+        @last_result = :failed
+      end
+
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
+
+      if log_test_assertion_message?
+        msg ||= "#{__method__} #{a}, #{b} (== equality)"
+        log_test_assertion_message ret, msg
+      end
+
+      ret
+    end
+
+    def refute_equality a, b, msg = nil, kaller: nil
+      ret = a == b
+
+      if ret
+        self.class._assertion_failed msg
+        @last_result = :failed
+      else
+        self.class._assertion_passed
+        @last_result = :passed
+      end
+
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
+
+      if log_test_assertion_message?
+        msg ||= "#{__method__} #{a}, #{b} (== equality)"
+        log_test_assertion_message !ret, msg
+      end
+
+      ret
+    end
+
+    def assert_equality! a, b, msg = nil
+      critical assert_equality a, b, msg, kaller: caller
+    end
+
+    def refute_equality! a, b, msg = nil
+      critical refute_equality a, b, msg, kaller: caller
+    end
+
+    def assert_raises exception_klass, msg = nil, kaller: nil, &block
+      raise ArgumentError, "No block given" unless block_given?
+
+      ret = false
+      begin
+        yield
+      rescue => e
+        ret = exception_klass === e
+        error = e
+      end
+
+      if ret
+        self.class._assertion_passed
+        @last_result = :passed
+      else
+        self.class._assertion_failed msg
+        @last_result = :failed
+      end
+
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
+
+      if log_test_assertion_message?
+        msg ||= "#{__method__} (#{exception_klass}) #{error.inspect}"
+        log_test_assertion_message ret, msg
+      end
+
+      ret
+    end
+
+    def refute_raises exception_klass, msg = nil, kaller: nil, &block
+      raise ArgumentError, "No block given" unless block_given?
+
+      ret = false
+      begin
+        yield
+      rescue => e
+        ret = !exception_klass === e
+        error = e
+      end
+
+      if ret
+        self.class._assertion_failed msg
+        @last_result = :failed
+      else
+        self.class._assertion_passed
+        @last_result = :passed
+      end
+
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
+
+      if log_test_assertion_message?
+        msg ||= "#{__method__} (#{exception_klass}) #{error.inspect}"
+        log_test_assertion_message !ret, msg
+      end
+
+      ret
+    end
+
+    def assert_raises! e, msg = nil
+      critical assert_raises e, msg, kaller: caller
+    end
+
+    def refute_raises! e, msg = nil
+      critical refute_raises e, msg, kaller: caller
+    end
+
+  end
+end

data/lib/liza/test_parts/test_assertions_part.rb

@@ -1,110 +1,109 @@
-module Liza
-  class TestAssertionsPart < Part
-    insertion do
-      # CLASS
-
-      def self.totals
-        @totals ||= {
-                      todos: [],
-                      passes: [],
-                      fails: [],
-                      errors: [],
-                    }
-      end
+class Liza::TestAssertionsPart < Liza::Part
+  insertion do
+    # CLASS
+
+    def self.totals
+      @totals ||= {
+                    errors: [],
+                    todos: [],
+                    fails: [],
+                    passes: [],
+                  }
+    end
 
-      def self._assertion_todo msg
-        self.totals[:todos] << msg
-      end
+    def self._assertion_todo msg
+      self.totals[:todos] << msg
+    end
 
-      def self._assertion_passed
-        self.totals[:passes] << 1
-      end
+    def self._assertion_passed
+      self.totals[:passes] << 1
+    end
 
-      def self._assertion_failed msg
-        self.totals[:fails] << msg
-      end
+    def self._assertion_failed msg
+      self.totals[:fails] << msg
+    end
 
-      def self._assertion_errored e
-        self.totals[:errors] << e
-      end
+    def self._assertion_errored e
+      self.totals[:errors] << e
+    end
 
-      # INSTANCE
+    # INSTANCE
 
-      attr_writer :assertions
+    attr_writer :assertions
 
-      def assertions
-        @assertions ||= 0
-      end
+    def assertions
+      @assertions ||= 0
+    end
 
-      def _inc_assertions
-        self.assertions += 1
-      end
+    def _inc_assertions
+      self.assertions += 1
+    end
 
-      # ASSERTIONS
+    # ASSERTIONS
 
-      def todo msg
-        self.class._assertion_todo msg
-        @last_result = :todo
+    def todo msg
+      self.class._assertion_todo msg
+      @last_result = :todo
 
-        _assertion_log __method__, caller if _groups.empty?
-      end
+      log_test_assertion __method__, caller if _groups.empty?
+    end
 
-      def _groups
-        @_groups ||= []
-      end
+    def _groups
+      @_groups ||= []
+    end
+
+    def group kaller: nil, **_words, &block
+      block_given? || raise(ArgumentError, "No block given")
 
-      def group kaller: nil, **_words, &block
-        block_given? || raise(ArgumentError, "No block given")
+      _groups << block
+      instance_exec &block
+      _groups.pop
 
-        _groups << block
-        instance_exec &block
-        _groups.pop
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
+    end
 
-        kaller ||= caller
-        _assertion_log __method__, kaller if _groups.empty?
+    def assert b, msg = "it should have been true", kaller: nil
+      if b
+        self.class._assertion_passed
+        @last_result = :passed
+      else
+        self.class._assertion_failed msg
+        @last_result = :failed
       end
 
-      def assert b, msg = "it should have been true", kaller: nil
-        if b
-          self.class._assertion_passed
-          @last_result = :passed
-        else
-          self.class._assertion_failed msg
-          @last_result = :failed
-        end
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
 
-        kaller ||= caller
-        _assertion_log __method__, kaller if _groups.empty?
+      b
+    end
 
-        b
+    def refute b, msg = "it should have been false", kaller: nil
+      if b
+        self.class._assertion_failed msg
+        @last_result = :failed
+      else
+        self.class._assertion_passed
+        @last_result = :passed
       end
 
-      def refute b, msg = "it should have been false", kaller: nil
-        if b
-          self.class._assertion_failed msg
-          @last_result = :failed
-        else
-          self.class._assertion_passed
-          @last_result = :passed
-        end
+      kaller ||= caller
+      log_test_assertion __method__, kaller if _groups.empty?
 
-        kaller ||= caller
-        _assertion_log __method__, kaller if _groups.empty?
-
-        b
-      end
+      b
+    end
 
-      def assert! b, msg = "it should have been true"
-        critical assert b, msg, kaller: caller
-      end
+    def assert! b, msg = "it should have been true"
+      critical assert b, msg, kaller: caller
+    end
 
-      def refute! b, msg = "it should have been false"
-        critical refute b, msg, kaller: caller
-      end
+    def refute! b, msg = "it should have been false"
+      critical refute b, msg, kaller: caller
+    end
 
-      def critical passed
-        throw :critical, :critical if not passed
-      end
+    def critical passed
+      throw :critical, :critical if not passed
     end
+
   end
 end