lizarb 1.0.5 → 1.0.6

data/lib/liza/unit_test.rb

@@ -6,119 +6,110 @@ class Liza::UnitTest < Liza::Test
   #
 
   def self.test_methods_defined(&block)
-    helper = TestMethodsDefinedHelper.new
-    helper.instance_eval(&block)
-
     test :subject_class, :methods_defined do
-      a = subject_class.methods_defined
-      b = helper.methods
-      assert_equality a, b, kaller: helper.methods_caller
-    end
-
-    test :subject_class, :instance_methods_defined do
-      a = subject_class.instance_methods_defined
-      b = helper.instance_methods
-      assert_equality a, b, kaller: helper.instance_methods_caller
-    end
-  end
-
-  class TestMethodsDefinedHelper
-    attr_reader :methods, :methods_caller
-    attr_reader :instance_methods, :instance_methods_caller
-
-    def initialize
-      @methods, @instance_methods = [], []
-      @methods_caller, @instance_methods_caller = caller, caller
-    end
-
-    def on_self(*args)
-      @methods = args
-      @methods_caller = caller
-    end
-
-    def on_instance(*args)
-      @instance_methods = args
-      @instance_methods_caller = caller
+      todo "replace me with test_sections"
     end
   end
 
   #
-
-  test :subject_class, :methods_defined do
-    a = \
-      subject_class.methods_defined -
-      subject_class.methods_for_settings -
-      subject_class.methods_for_logging -
-      subject_class.methods_for_rendering
-    b = [
-      :descendants_select,
-      :division,
-      :instance_methods_defined, :instance_methods_for_logging, :instance_methods_for_rendering, :instance_methods_for_settings,
-      :methods_defined, :methods_for_logging, :methods_for_rendering, :methods_for_settings,
-      :namespace,
-      :part,
-      :procedure, :proceed,
-      :reload!,
-      :subclasses_select, :system, :system?,
-      :test_class
-    ]
-    assert_equality a, b
-  end
-
-  test :subject_class, :instance_methods_defined do
-    a = \
-      subject_class.instance_methods_defined -
-      subject_class.instance_methods_for_settings -
-      subject_class.instance_methods_for_logging -
-      subject_class.instance_methods_for_rendering
-    b = [:procedure, :proceed, :reload!, :system]
-    assert_equality a, b
-  end
-
-  test :subject_class, :methods_for_settings do
-    a = subject_class.methods_for_settings
-    b = [:add, :fetch, :get, :set, :settings]
-    assert_equality a, b
+  
+  def self.test_sections(hash={})
+    test :sections do
+      assert_equality! subject_class.sections.keys, hash.keys
+
+      # each section should match the hash
+      group do
+        hash.each do |section_name, section|
+          assert_equality section, subject_class.sections[section_name]
+        end
+      end
+
+      hash_class_methods = hash.values.map { _1[:class_methods] }.flatten
+      hash_instance_methods = hash.values.map { _1[:instance_methods] }.flatten
+
+      actual_class_methods = subject_class.sections.values.map { _1[:class_methods] }.flatten
+      actual_instance_methods = subject_class.sections.values.map { _1[:instance_methods] }.flatten
+
+      # each section should have unique methods
+      group do
+        assert_equality actual_class_methods, hash_class_methods
+        assert_equality actual_instance_methods, hash_instance_methods
+      end
+
+      # methods in all sections should be unique
+      group do
+        assert_equality actual_class_methods.count, actual_class_methods.uniq.count
+        assert_equality actual_instance_methods.count, actual_instance_methods.uniq.count
+        assert_equality actual_class_methods.sort, actual_class_methods.sort.uniq
+        assert_equality actual_instance_methods.sort, actual_instance_methods.sort.uniq
+      end
+    end
   end
+  
+  test_sections(
+    :default=>{
+      :constants=>[:Error],
+      :class_methods=>[:singleton_method_added, :section, :sections, :method_added, :const_added, :methods_defined, :class_methods_defined, :instance_methods_defined, :constants_defined, :part, :const_missing, :reload!, :cl, :time_diff],
+      :instance_methods=>[:reload!, :cl, :time_diff]
+    },
+    setting: {
+      :constants=>[],
+      :class_methods=>[:settings, :get, :set, :add, :fetch],
+      :instance_methods=>[:settings, :get, :set, :add, :fetch]
+    },
+    associating: {
+      :constants=>[],
+      :class_methods=>[:namespace, :subclasses_select, :descendants_select, :subunits, :system?, :test_class, :division, :system],
+      :instance_methods=>[:system]
+    },
+    erroring: {
+      :constants=>[],
+      :class_methods=>[:errors, :define_error, :raise_error],
+      :instance_methods=>[:raise_error]
+    },
+    logging: {
+      :constants=>[],
+      :class_methods=>[:log_levels, :log, :stick, :sticks, :log_level, :log_hash, :log_array, :log?, :log_level?],
+      :instance_methods=>[:log_levels, :log, :stick, :sticks, :log_level, :log_hash, :log_array, :log?, :log_level?]
+    },
+    :sleep=>{
+      :constants=>[],
+      :class_methods=>[:sleep],
+      :instance_methods=>[:sleep]
+    },
+    rendering: {
+      :constants=>[:RendererNotFoundError, :RenderStackIsEmptyError, :RenderStackIsFullError],
+      :class_methods=>[:erbs_defined, :erbs_available, :renderable_names, :renderable_formats_for, :erbs_for, :_erbs_for],
+      :instance_methods=>[:render!, :render, :render_stack, :log_render_in, :log_render_out, :log_render_convert, :log_render_format]
+    }
+  )
 
-  test :subject_class, :instance_methods_for_settings do
-    a = subject_class.instance_methods_for_settings
-    b = [:add, :fetch, :get, :set, :settings]
-    assert_equality a, b
-  end
+  section :rendering
 
-  test :subject_class, :methods_for_rendering do
-    a = subject_class.methods_for_rendering
-    b = [:erbs_available, :erbs_defined, :erbs_for, :renderable_formats_for, :renderable_names]
-    assert_equality a, b
+  def self.test_erbs_defined(*keys)
+    test :erbs_defined do
+      actual = subject_class.erbs_defined.map &:key
+      assert_equality actual, keys
+    end
   end
 
-  test :subject_class, :instance_methods_for_rendering do
-    a = subject_class.instance_methods_for_rendering
-    b = [:render, :render!, :render_stack]
-    assert_equality a, b
+  def self.test_erbs_available(*keys)
+    test :erbs_available do
+      actual = subject_class.erbs_available.map &:key
+      assert_equality actual, keys
+    end
   end
 
-  test :subject_class, :methods_for_logging do
-    a = subject_class.methods_for_logging
-    b = [:log, :log?, :log_array, :log_hash, :log_level, :log_level?, :log_levels, :stick, :sticks]
-    assert_equality a, b
-  end
+  test_erbs_defined "render.txt.erb"
+  test_erbs_available
 
-  test :subject_class, :instance_methods_for_logging do
-    a = subject_class.instance_methods_for_logging
-    b = [:log, :log?, :log_array, :log_hash, :log_level, :log_level?, :log_levels, :log_render_convert, :log_render_in, :log_render_out, :stick, :sticks]
-    assert_equality a, b
-  end
+  section :setting
 
   test :settings do
-    assert_equality subject_class.get(:log_level), 0
-    assert_equality subject_class.log_level, 0
+    assert_equality subject_class.get(:log_level), 4
+    assert_equality subject_class.log_level, 4
 
-    assert_equality subject_class.settings, {
-      log_level: 0,
-      division: Liza::Controller,
-    }
+    assert_equality subject_class.settings.keys, [:errors, :log_level, :division]
   end
 
   test :settings_inheritance do

data/lib/liza.rb

@@ -18,7 +18,7 @@ module Liza
     const name
   end
 
-  # Checks Object, each system, then Liza for Liza::Unit classes
+  # Checks Object, each system, then Liza, only returns if they are Liza::Unit descendants
   def const name
     name = name.to_s.camelize.to_sym
 
@@ -28,20 +28,13 @@ module Liza
     k = const_check_systems name
     return k if k
 
-    k = const_get name
+    k = const_get_liza name
     return k if k
 
     nil
-  rescue NameError
-    log "Liza const #{name} not found!" if $VERBOSE
-    if Lizarb.ruby_supports_raise_cause?
-      raise ConstNotFound, name, cause: nil
-    else
-      raise ConstNotFound, name, []
-    end
   end
 
-  # Checks each system, then Liza for Liza::Unit classes
+  # Checks each system, then Liza, only returns if they are Liza::Unit descendants
   def const_missing name
     k = const_check_systems name
     return k if k
@@ -69,6 +62,17 @@ module Liza
     nil
   end
 
+  def const_get_liza name
+    const_get name
+  rescue NameError => _e
+    log "Liza const #{name} not found!" if $VERBOSE
+    if Lizarb.ruby_supports_raise_cause?
+      raise ConstNotFound, name, cause: nil
+    else
+      raise ConstNotFound, name, []
+    end
+  end
+
   def is_unit? kk
     kk && kk < Liza::Unit
   end

data/lib/lizarb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lizarb
-  VERSION = "1.0.5"
+  VERSION = "1.0.6"
 end