benry-cmdapp 0.1.0

data/test/action_test.rb

@@ -0,0 +1,1038 @@
+# -*- coding: utf-8 -*-
+
+
+require 'oktest'
+
+require 'benry/cmdapp'
+require_relative './shared'
+
+
+Oktest.scope do
+
+
+  topic Benry::CmdApp::ActionMetadata do
+    #include CommonTestingHelper         # not work. why?
+    include ActionMetadataTestingHelper
+
+    class MetadataTestAction < Benry::CmdApp::ActionScope
+
+      @action.("print greeting message")
+      @option.(:lang, "-l, --lang=<en|fr|it>", "language")
+      def halo1(user="world", lang: "en")
+        case lang
+        when "en" ;  puts "Hello, #{user}!"
+        when "fr" ;  puts "Bonjour, #{user}!"
+        when "it" ;  puts "Ciao, #{user}!"
+        else      ;  raise "#{lang}: unknown language."
+        end
+      end
+
+      @action.("print greeting message")
+      @option.(:lang, "-l, --lang=<en|fr|it>", "language")
+      def halo2(user="world", *users, lang: "en")
+        puts "user=#{user.inspect}, users=#{users.inspect}"
+      end
+
+      @action.("no arguments")
+      @option.(:lang, "-l, --lang=<en|fr|it>", "language")
+      def halo3(lang: "en")
+        puts "lang=#{lang}"
+      end
+
+      def args1(aa, bb, xx: nil); end                   # required arg
+      def args2(aa, bb=nil, cc=nil, xx: nil); end       # optional arg
+      def args3(aa, bb=nil, cc=nil, *dd, xx: nil); end  # variable arg
+      def args4(xx_or_yy_or_zz); end                    # xx|yy|zz
+      def args5(_xx_yy_zz); end                         # _xx-yy-zz
+
+    end
+
+
+    before do
+      schema = Benry::Cmdopt::Schema.new
+      schema.add(:lang, "-l, --lang=<en|fr|it>", "language")
+      @metadata = Benry::CmdApp::ActionMetadata.new("halo1", MetadataTestAction, :halo1, "greeting", schema)
+    end
+
+
+    topic '#hidden?()' do
+
+      class HiddenTestAction < Benry::CmdApp::ActionScope
+        @action.("public")
+        def pphidden1(); puts __method__(); end
+        #
+        @action.("private")
+        def pphidden2(); puts __method__(); end
+        private :pphidden2
+        #
+        private
+        @action.("private")
+        def pphidden3(); puts __method__(); end
+      end
+
+      spec "[!kp10p] returns true when action method is private." do
+        ameta = Benry::CmdApp::INDEX.get_action("pphidden3")
+        ok {ameta.hidden?} == true
+        ameta = Benry::CmdApp::INDEX.get_action("pphidden2")
+        ok {ameta.hidden?} == true
+      end
+
+      spec "[!nw322] returns false when action method is not private." do
+        ameta = Benry::CmdApp::INDEX.get_action("pphidden1")
+        ok {ameta.hidden?} == false
+      end
+
+    end
+
+
+    topic '#importance?()' do
+
+      spec "[!52znh] returns true if `@important == true`." do
+        ameta = @metadata
+        ameta.instance_variable_set('@important', true)
+        ok {ameta.important?} == true
+      end
+
+      spec "[!rlfac] returns false if `@important == false`." do
+        ameta = @metadata
+        ameta.instance_variable_set('@important', false)
+        ok {ameta.important?} == false
+      end
+
+      spec "[!j3trl] returns false if `@important == nil`. and action is hidden." do
+        ameta = @metadata
+        def ameta.hidden?; true; end
+        ok {ameta.important?} == false
+      end
+
+      spec "[!hhef8] returns nil if `@important == nil`." do
+        ameta = @metadata
+        ameta.instance_variable_set('@important', nil)
+        ok {ameta.important?} == nil
+      end
+
+    end
+
+
+    topic '#parse_options()' do
+
+      spec "[!ab3j8] parses argv and returns options." do
+        args = ["-l", "fr", "Alice"]
+        opts = @metadata.parse_options(args)
+        ok {opts} == {:lang => "fr"}
+        ok {args} == ["Alice"]
+        args = ["--lang=it", "Bob"]
+        opts = @metadata.parse_options(args)
+        ok {opts} == {:lang => "it"}
+        ok {args} == ["Bob"]
+      end
+
+      spec "[!56da8] raises InvalidOptionError if option value is invalid." do
+        args = ["-x", "fr", "Alice"]
+        pr = proc { @metadata.parse_options(args) }
+        ok {pr}.raise?(Benry::CmdApp::InvalidOptionError, "-x: Unknown option.")
+      end
+
+    end
+
+
+    topic '#run_action()' do
+
+      spec "[!veass] runs action with args and kwargs." do
+        args = ["Alice"]; kwargs = {lang: "fr"}
+        #
+        sout, serr = capture_sio { @metadata.run_action() }
+        ok {sout} == "Hello, world!\n"
+        ok {serr} == ""
+        #
+        sout, serr = capture_sio { @metadata.run_action(*args) }
+        ok {sout} == "Hello, Alice!\n"
+        ok {serr} == ""
+        #
+        sout, serr = capture_sio { @metadata.run_action(**kwargs) }
+        ok {sout} == "Bonjour, world!\n"
+        ok {serr} == ""
+        #
+        sout, serr = capture_sio { @metadata.run_action(*args, **kwargs) }
+        ok {sout} == "Bonjour, Alice!\n"
+        ok {serr} == ""
+      end
+
+      def _trace_mode(flag, &block)
+        bkup = $TRACE_MODE
+        $TRACE_MODE = true
+        begin
+          return yield
+        ensure
+          $TRACE_MODE = bkup
+        end
+      end
+
+      spec "[!tubhv] if $TRACE_MODE is on, prints tracing info." do
+        args = ["Alice"]; kwargs = {lang: "it"}
+        sout, serr = _trace_mode(true) do
+          capture_sio {
+            @metadata.run_action(*args, **kwargs)
+          }
+        end
+        ok {serr} == ""
+        ok {sout} == <<"END"
+## enter: halo1
+Ciao, Alice!
+## exit:  halo1
+END
+      end
+
+      spec "[!zgp14] tracing info is colored when stdout is a tty." do
+        args = ["Alice"]; kwargs = {lang: "it"}
+        sout, serr = _trace_mode(true) do
+          capture_sio(tty: true) {
+            @metadata.run_action(*args, **kwargs)
+          }
+        end
+        ok {serr} == ""
+        ok {sout} == <<"END"
+\e[33m## enter: halo1\e[0m
+Ciao, Alice!
+\e[33m## exit:  halo1\e[0m
+END
+      end
+
+    end
+
+
+    topic '#method_arity()' do
+
+      spec "[!7v4tp] returns min and max number of positional arguments." do
+        ok {@metadata.method_arity()} == [0, 1]
+      end
+
+      spec "[!w3rer] max is nil if variable argument exists." do
+        schema = Benry::Cmdopt::Schema.new
+        metadata = Benry::CmdApp::ActionMetadata.new("halo2", MetadataTestAction, :halo2, "greeting", schema)
+        ok {metadata.method_arity()} == [0, nil]
+      end
+
+    end
+
+
+    topic '#validate_method_params()' do
+
+      spec "[!plkhs] returns error message if keyword parameter for option not exist." do
+        schema = Benry::Cmdopt::Schema.new
+        schema.add(:foo, "--foo", "foo")
+        metadata = Benry::CmdApp::ActionMetadata.new("halo1", MetadataTestAction, :halo1, "greeting", schema)
+        msg = metadata.validate_method_params()
+        ok {msg} == "Should have keyword parameter 'foo' for '@option.(:foo)', but not."
+      end
+
+      spec "[!1koi8] returns nil if all keyword parameters for option exist." do
+        schema = Benry::Cmdopt::Schema.new
+        schema.add(:lang, "-l, --lang=<lang>", "lang")
+        metadata = Benry::CmdApp::ActionMetadata.new("halo1", MetadataTestAction, :halo1, "greeting", schema)
+        msg = metadata.validate_method_params()
+        ok {msg} == nil
+      end
+
+    end
+
+
+    topic '#help_message()' do
+
+      spec "[!i7siu] returns help message of action." do
+        schema = new_schema()
+        msg = without_tty { new_metadata(schema).help_message("testapp") }
+        ok {uncolorize(msg)} == <<END
+testapp halo1 -- greeting
+
+Usage:
+  $ testapp halo1 [<options>] [<user>]
+
+Options:
+  -l, --lang=<en|fr|it> : language
+END
+      end
+
+    end
+
+
+  end
+
+
+  topic Benry::CmdApp::ActionWithArgs do
+    include ActionMetadataTestingHelper
+
+
+    topic '#initialize()' do
+
+      spec "[!6jklb] keeps ActionMetadata, args, and kwargs." do
+        ameta = new_metadata(new_schema())
+        wrapper = Benry::CmdApp::ActionWithArgs.new(ameta, ["Alice"], {lang: "fr"})
+        ok {wrapper.action_metadata} == ameta
+        ok {wrapper.args}   == ["Alice"]
+        ok {wrapper.kwargs} == {lang: "fr"}
+      end
+
+    end
+
+
+    topic '#method_missing()' do
+
+      spec "[!14li3] behaves as ActionMetadata." do
+        ameta = new_metadata(new_schema())
+        wrapper = Benry::CmdApp::ActionWithArgs.new(ameta, ["Alice"], {lang: "fr"})
+        ok {wrapper.name} == ameta.name
+        ok {wrapper.klass} == ameta.klass
+        ok {wrapper.schema} == ameta.schema
+        ok {wrapper.method_arity()} == ameta.method_arity()
+      end
+
+    end
+
+
+    topic '#run_action()' do
+
+      class ActionWithArgsTest < Benry::CmdApp::ActionScope
+        @action.("hello")
+        @option.(:lang, "-l <lang>", "language")
+        @option.(:repeat, "-r <N>", "repeat <N> times")
+        def hellowithargs(user1="alice", user2="bob", lang: nil, repeat: nil)
+          puts "user1=#{user1}, user2=#{user2}, lang=#{lang.inspect}, repeat=#{repeat.inspect}"
+        end
+      end
+
+      spec "[!fl26i] invokes action with args and kwargs." do
+        ameta = Benry::CmdApp::INDEX.get_action("hellowithargs")
+        #
+        wrapper = Benry::CmdApp::ActionWithArgs.new(ameta, ["bill"], {repeat: 3})
+        sout, serr = capture_sio() { wrapper.run_action() }
+        ok {serr} == ""
+        ok {sout} == "user1=bill, user2=bob, lang=nil, repeat=3\n"
+        #
+        wrapper = Benry::CmdApp::ActionWithArgs.new(ameta, ["bill"], nil)
+        sout, serr = capture_sio() { wrapper.run_action() }
+        ok {serr} == ""
+        ok {sout} == "user1=bill, user2=bob, lang=nil, repeat=nil\n"
+        #
+        wrapper = Benry::CmdApp::ActionWithArgs.new(ameta, nil, {repeat: 3})
+        sout, serr = capture_sio() { wrapper.run_action() }
+        ok {serr} == ""
+        ok {sout} == "user1=alice, user2=bob, lang=nil, repeat=3\n"
+      end
+
+    end
+
+
+  end
+
+
+  topic Benry::CmdApp::ActionScope do
+
+
+    class InvokeTestAction < Benry::CmdApp::ActionScope
+      prefix "test3:foo"
+      #
+      @action.("invoke once")
+      @option.(:lang, "-l, --lang=<en|fr>", "language")
+      def invoke1(user="world", lang: "en")
+        puts(lang == "fr" ? "Bonjour, #{user}!" : "Hello, #{user}!")
+      end
+      #
+      @action.("invoke twice")
+      @option.(:lang, "-l, --lang=<en|fr>", "language")
+      def invoke2(user="world", lang: "en")
+        puts(lang == "fr" ? "Bonjour, #{user}!" : "Hello, #{user}!")
+      end
+      #
+      @action.("invoke more")
+      @option.(:lang, "-l, --lang=<en|fr>", "language")
+      def invoke3(user="world", lang: "en")
+        puts(lang == "fr" ? "Bonjour, #{user}!" : "Hello, #{user}!")
+      end
+    end
+
+    class LoopedActionTest < Benry::CmdApp::ActionScope
+      @action.("test")
+      def loop1()
+        run_action_once("loop2")
+      end
+      @action.("test")
+      def loop2()
+        run_action_once("loop3")
+      end
+      @action.("test")
+      def loop3()
+        run_action_once("loop1")
+      end
+    end
+
+    before do
+      @action = InvokeTestAction.new()
+      Benry::CmdApp::INDEX.instance_variable_get('@done').clear()
+    end
+
+
+    topic '#run_action_once()' do
+
+      spec "[!oh8dc] don't invoke action if already invoked." do
+        sout, serr = capture_sio() do
+          @action.run_action_once("test3:foo:invoke2", "Alice", lang: "fr")
+        end
+        ok {sout} == "Bonjour, Alice!\n"
+        sout, serr = capture_sio() do
+          @action.run_action_once("test3:foo:invoke2", "Alice", lang: "fr")
+        end
+        ok {sout} == ""
+        ok {serr} == ""
+      end
+
+    end
+
+
+    topic '#run_action!()' do
+
+      spec "[!2yrc2] invokes action even if already invoked." do
+        sout, serr = capture_sio() do
+          @action.run_action!("test3:foo:invoke3", "Alice", lang: "fr")
+        end
+        ok {sout} == "Bonjour, Alice!\n"
+        sout, serr = capture_sio() do
+          @action.run_action!("test3:foo:invoke3", "Alice", lang: "fr")
+        end
+        ok {sout} == "Bonjour, Alice!\n"
+        sout, serr = capture_sio() do
+          @action.run_action!("test3:foo:invoke3", "Alice", lang: "en")
+        end
+        ok {sout} == "Hello, Alice!\n"
+      end
+
+    end
+
+
+    topic '#__run_action()' do
+
+      def __run_action(action_name, once, args, kwargs)
+        @action.__send__(:__run_action, action_name, once, args, kwargs)
+      end
+
+      def __run_loop(action_name, once, args, kwargs)
+        action = LoopedActionTest.new()
+        action.__send__(:__run_action, action_name, once, args, kwargs)
+      end
+
+      spec "[!lbp9r] invokes action name with prefix if prefix defined." do
+        sout, serr = capture_sio() do
+          @action.run_action_once("invoke2", "Alice", lang: "fr")
+        end
+        ok {sout} == "Bonjour, Alice!\n"
+      end
+
+      spec "[!7vszf] raises error if action specified not found." do
+        pr = proc { __run_action("loop9", nil, ["Alice"], {}) }
+        ok {pr}.raise?(Benry::CmdApp::ActionNotFoundError, "loop9: Action not found.")
+      end
+
+      spec "[!u8mit] raises error if action flow is looped." do
+        pr = proc { __run_loop("loop1", nil, [], {}) }
+        ok {pr}.raise?(Benry::CmdApp::LoopedActionError, "loop1: Action loop detected.")
+      end
+
+      spec "[!vhdo9] don't invoke action twice if 'once' arg is true." do
+        sout, serr = capture_sio() do
+          __run_action("test3:foo:invoke2", true, ["Alice"], {lang: "fr"})
+        end
+        ok {sout} == "Bonjour, Alice!\n"
+        sout, serr = capture_sio() do
+          __run_action("test3:foo:invoke2", true, ["Alice"], {lang: "fr"})
+        end
+        ok {sout} == ""
+        ok {serr} == ""
+      end
+
+      spec "[!r8fbn] invokes action." do
+        sout, serr = capture_sio() do
+          __run_action("test3:foo:invoke1", false, ["Alice"], {lang: "fr"})
+        end
+        ok {sout} == "Bonjour, Alice!\n"
+      end
+
+    end
+
+
+    topic '.prefix()' do
+
+      spec "[!1gwyv] converts symbol into string." do
+        class PrefixTest1 < Benry::CmdApp::ActionScope
+          prefix :foo
+        end
+        prefix = PrefixTest1.instance_variable_get('@__prefix__')
+        ok {prefix} == "foo:"
+      end
+
+      spec "[!pz46w] error if prefix contains extra '_'." do
+        pr = proc do
+          class PrefixTest2 < Benry::CmdApp::ActionScope
+            prefix "foo_bar"
+          end
+        end
+        ok {pr}.raise?(Benry::CmdApp::ActionDefError,
+                       "foo_bar: Invalid prefix name (please use ':' or '-' instead of '_' as word separator).")
+      end
+
+      spec "[!9pu01] adds ':' at end of prefix name if prefix not end with ':'." do
+        class PrefixTest3 < Benry::CmdApp::ActionScope
+          prefix "foo:bar"
+        end
+        prefix = PrefixTest3.instance_variable_get('@__prefix__')
+        ok {prefix} == "foo:bar:"
+      end
+
+    end
+
+
+    topic '.inherited()' do
+
+      spec "[!f826w] registers all subclasses into 'ActionScope::SUBCLASSES'." do
+        class InheritedTest0a < Benry::CmdApp::ActionScope
+        end
+        class InheritedTest0b < Benry::CmdApp::ActionScope
+        end
+        ok {Benry::CmdApp::ActionScope::SUBCLASSES}.include?(InheritedTest0a)
+        ok {Benry::CmdApp::ActionScope::SUBCLASSES}.include?(InheritedTest0b)
+      end
+
+      spec "[!2imrb] sets class instance variables in subclass." do
+        class InheritedTest1 < Benry::CmdApp::ActionScope
+        end
+        ivars = InheritedTest1.instance_variables().sort()
+        ok {ivars} == [:@__action__, :@__aliasof__, :@__default__, :@__option__, :@__prefix__, :@action, :@copy_options, :@option]
+      end
+
+      spec "[!1qv12] @action is a Proc object and saves args." do
+        class InheritedTest2 < Benry::CmdApp::ActionScope
+          @action.("description", detail: "xxx", postamble: "yyy", important: true, tag: "zzz")
+        end
+        x = InheritedTest2.instance_variable_get('@__action__')
+        ok {x} == ["description", {detail: "xxx", postamble: "yyy", important: true, tag: "zzz"}]
+      end
+
+      spec "[!33ma7] @option is a Proc object and saves args." do
+        class InheritedTest3 < Benry::CmdApp::ActionScope
+          @action.("description", detail: "xxx", postamble: "yyy")
+          @option.(:xx, "-x, --xxx=<N>", "desc 1", type: Integer, rexp: /\A\d+\z/, enum: [2,4,8], range: (2..8))
+          @option.(:yy, "-y, --yyy[=<on|off>]", "desc 2", type: TrueClass, value: false)
+        end
+        x = InheritedTest3.instance_variable_get('@__option__')
+        ok {x}.is_a?(Benry::CmdOpt::Schema)
+        items = x.each.to_a()
+        ok {items.length}    == 2
+        ok {items[0].key}    == :xx
+        ok {items[0].optdef} == "-x, --xxx=<N>"
+        ok {items[0].desc}   == "desc 1"
+        ok {items[0].type}   == Integer
+        ok {items[0].rexp}   == /\A\d+\z/
+        ok {items[0].enum}   == [2, 4, 8]
+        ok {items[0].range}  == (2..8)
+        ok {items[0].value}  == nil
+        ok {items[1].key}    == :yy
+        ok {items[1].optdef} == "-y, --yyy[=<on|off>]"
+        ok {items[1].desc}   == "desc 2"
+        ok {items[1].type}   == TrueClass
+        ok {items[1].rexp}   == nil
+        ok {items[1].enum}   == nil
+        ok {items[1].range}  == nil
+        ok {items[1].value}  == false
+      end
+
+      spec "[!gxybo] '@option.()' raises error when '@action.()' not called." do
+        pr = proc do
+          class InheritedTest4 < Benry::CmdApp::ActionScope
+            @option.(:xx, "-x, --xxx=<N>", "desc 1")
+          end
+        end
+        ok {pr}.raise?(Benry::CmdApp::OptionDefError,
+                       "@option.(:xx): `@action.()` Required but not called.")
+      end
+
+      spec "[!ga6zh] '@option.()' raises error when invalid option info specified." do
+        pr = proc do
+          class InheritedTest20 < Benry::CmdApp::ActionScope
+            @action.("test")
+            @option.(:xx, "-x, --xxx=<N>", "desc 1", range: (2..8))
+            def hello(xx: nil)
+            end
+          end
+        end
+        ok {pr}.raise?(Benry::CmdApp::OptionDefError,
+                       "2..8: Range value should be String, but not.")
+      end
+
+      spec "[!yrkxn] @copy_options is a Proc object and copies options from other action." do
+        class InheritedTest5 < Benry::CmdApp::ActionScope
+          @action.("copy src")
+          @option.(:xxx, "-x, --xxx=<arg>", "xxx #1")
+          def optcopy1(xxx: nil)
+          end
+          #
+          @action.("copy dst")
+          @copy_options.("optcopy1")
+          @option.(:yyy, "-y, --yyy=<on|off>", "yyy #2", type=TrueClass)
+        end
+        x = InheritedTest5.instance_variable_get('@__option__')
+        ok {x}.is_a?(Benry::CmdOpt::Schema)
+        items = x.each.to_a()
+        ok {items.length}    == 2
+        ok {items[0].key}    == :xxx
+        ok {items[0].short}  == "x"
+        ok {items[0].long}   == "xxx"
+        ok {items[1].key}    == :yyy
+        ok {items[1].short}  == "y"
+        ok {items[1].long}   == "yyy"
+      end
+
+      spec "[!mhhn2] '@copy_options.()' raises error when action not found." do
+        pr = proc do
+          class InheritedTest6 < Benry::CmdApp::ActionScope
+            @action.("copy")
+            @copy_options.("optcopy99")
+            def copytest2(yyy: nil)
+            end
+          end
+        end
+        ok {pr}.raise?(Benry::CmdApp::OptionDefError,
+                       "@copy_options.(\"optcopy99\"): Action not found.")
+      end
+
+    end
+
+
+    topic '.method_added()' do
+
+      def defined_actions()
+        actions = Benry::CmdApp::INDEX.instance_variable_get('@actions')
+        action_names = actions.keys()
+        yield
+        new_names = actions.keys() - action_names
+        metadata = new_names.length > 0 ? Benry::CmdApp::INDEX.get_action(new_names[0]) : nil
+        return new_names, metadata
+      end
+
+      spec "[!idh1j] do nothing if '@__action__' is nil." do
+        new_names, x = defined_actions() do
+          class Added1Test < Benry::CmdApp::ActionScope
+            prefix "added1"
+            def hello1(); end
+          end
+        end
+        ok {new_names} == []
+        ok {x} == nil
+      end
+
+      spec "[!ernnb] clears both '@__action__' and '@__option__'." do
+        new_names, x = defined_actions() do
+          class Added2Test < Benry::CmdApp::ActionScope
+            @action.("test", detail: "XXX", postamble: "YYY")
+            @option.(:foo, "--foo", "foo")
+          end
+          ok {Added2Test.instance_variable_get('@__action__')} != nil
+          ok {Added2Test.instance_variable_get('@__option__')} != nil
+          Added2Test.class_eval do
+            def hello2(foo: nil); end
+          end
+          ok {Added2Test.instance_variable_get('@__action__')} == nil
+          ok {Added2Test.instance_variable_get('@__option__')} == nil
+        end
+      end
+
+      spec "[!n8tem] creates ActionMetadata object if '@__action__' is not nil." do
+        new_names, x = defined_actions() do
+          class Added3Test < Benry::CmdApp::ActionScope
+            prefix "added3"
+            @action.("test", detail: "XXX", postamble: "YYY")
+            def hello3(); end
+          end
+        end
+        ok {new_names} == ["added3:hello3"]
+        ok {x}.is_a?(Benry::CmdApp::ActionMetadata)
+        ok {x.name}      == "added3:hello3"
+        ok {x.klass}     == Added3Test
+        ok {x.method}    == :hello3
+        ok {x.hidden?}   == false
+        ok {x.detail}    == "XXX"
+        ok {x.postamble} == "YYY"
+      end
+
+      spec "[!4pbsc] raises error if keyword param for option not exist in method." do
+        pr = proc do
+          class Added4Test < Benry::CmdApp::ActionScope
+            prefix "added4"
+            @action.("test")
+            @option.(:flag, "--flag=<on|off>", nil, type: TrueClass)
+            def hello4(xx: nil); end
+          end
+        end
+        ok {pr}.raise?(Benry::CmdApp::ActionDefError,
+                       "def hello4(): Should have keyword parameter 'flag' for '@option.(:flag)', but not.")
+      end
+
+      spec "[!t8vbf] raises error if action name duplicated." do
+        pr = proc do
+          class Added5Test < Benry::CmdApp::ActionScope
+            prefix "added5"
+            @action.("test")
+            def hello5(xx: nil); end
+            @action.("test")
+            def hello5(xx: nil); end
+          end
+        end
+        ok {pr}.raise?(Benry::CmdApp::ActionDefError,
+                       "def hello5(): Action 'added5:hello5' already exist.")
+      end
+
+      case_when '[!5e5o0] when method name is same as default action name...' do
+
+        spec "[!myj3p] uses prefix name (expect last char ':') as action name." do
+          new_names, x = defined_actions() do
+            class Added6Test < Benry::CmdApp::ActionScope
+              prefix "added6", action: :hello6
+              @action.("test")
+              def hello6(); end
+            end
+          end
+          ok {new_names} == ["added6"]
+          ok {x.klass} == Added6Test
+          ok {x.method} == :hello6
+        end
+
+        spec "[!j5oto] clears '@__default__'." do
+          class ClearDefaultTest1 < Benry::CmdApp::ActionScope
+            prefix "cleardefault1", action: :test2_   # symbol
+            @__default__ != nil  or
+              raise MiniTest::Assertion, "@__default__ should NOT be nil"
+            #
+            @action.("test")
+            def test1_(); end
+            @__default__ != nil  or
+              raise MiniTest::Assertion, "@__default__ should NOT be nil"
+            #
+            @action.("test")
+            def test2_(); end
+            @__default__ == nil  or
+              raise MiniTest::Assertion, "@__default__ should be nil"
+          end
+        end
+
+      end
+
+      case_else '[!agpwh] else...' do
+
+        spec "[!3icc4] uses method name as action name." do
+          new_names, x = defined_actions() do
+            class Added7Test < Benry::CmdApp::ActionScope
+              @action.("test")
+              def hello7xx(); end
+            end
+          end
+          ok {new_names} == ["hello7xx"]
+          ok {x.klass} == Added7Test
+          ok {x.method} == :hello7xx
+        end
+
+        spec "[!c643b] converts action name 'aa_bb_cc_' into 'aa_bb_cc'." do
+          new_names, x = defined_actions() do
+            class Added8Test < Benry::CmdApp::ActionScope
+              @action.("test")
+              def hello8xx_(); end
+            end
+          end
+          ok {new_names} == ["hello8xx"]
+          ok {x.klass} == Added8Test
+          ok {x.method} == :hello8xx_
+        end
+
+        spec "[!3fkb3] converts action name 'aa__bb__cc' into 'aa:bb:cc'." do
+          new_names, x = defined_actions() do
+            class Added9Test < Benry::CmdApp::ActionScope
+              @action.("test")
+              def hello9xx__yy__zz(); end
+            end
+          end
+          ok {new_names} == ["hello9xx:yy:zz"]
+          ok {x.klass} == Added9Test
+          ok {x.method} == :hello9xx__yy__zz
+        end
+
+        spec "[!o9s9h] converts action name 'aa_bb:_cc_dd' into 'aa-bb:_cc-dd'." do
+          new_names, x = defined_actions() do
+            class Added10Test < Benry::CmdApp::ActionScope
+              @action.("test")
+              def _hello10xx_yy_zz(); end
+            end
+          end
+          ok {new_names} == ["_hello10xx-yy-zz"]
+          ok {x.klass} == Added10Test
+          ok {x.method} == :_hello10xx_yy_zz
+        end
+
+        spec "[!8hlni] when action name is same as default name, uses prefix as action name." do
+          new_names, x = defined_actions() do
+            class Added11Test < Benry::CmdApp::ActionScope
+              prefix "added11", action: "hello11"
+              @action.("test")
+              def hello11(); end
+            end
+          end
+          ok {new_names} == ["added11"]
+          ok {x.klass} == Added11Test
+          ok {x.method} == :hello11
+        end
+
+        spec "[!q8oxi] clears '@__default__' when default name matched to action name." do
+          class ClearDefaultTest2 < Benry::CmdApp::ActionScope
+            prefix "cleardefault2", action: "test2"   # string
+            @__default__ != nil  or
+              raise MiniTest::Assertion, "@__default__ should NOT be nil"
+            #
+            @action.("test")
+            def test1_(); end
+            @__default__ != nil  or
+              raise MiniTest::Assertion, "@__default__ should NOT be nil"
+            #
+            @action.("test")
+            def test2_(); end
+            @__default__ == nil  or
+              raise MiniTest::Assertion, "@__default__ should be nil"
+          end
+        end
+
+        spec "[!xfent] when prefix is provided, adds it to action name." do
+          new_names, x = defined_actions() do
+            class Added12Test < Benry::CmdApp::ActionScope
+              prefix "added12"
+              @action.("test")
+              def hello12(); end
+            end
+          end
+          ok {new_names} == ["added12:hello12"]
+          ok {x.klass} == Added12Test
+          ok {x.method} == :hello12
+        end
+
+      end
+
+      spec "[!jpzbi] defines same name alias of action as prefix." do
+        ## when symbol
+        class AliasOfTest1 < Benry::CmdApp::ActionScope
+          prefix "blabla1", alias_of: :bla1    # symbol
+          @action.("test")
+          def bla1(); end
+        end
+        ok {Benry::CmdApp::INDEX.get_alias("blabla1")} != nil
+        ok {Benry::CmdApp::INDEX.get_alias("blabla1").action_name} == "blabla1:bla1"
+        ## when string
+        class AliasOfTest2 < Benry::CmdApp::ActionScope
+          prefix "bla:bla2", alias_of: "blala"    # string
+          @action.("test")
+          def blala(); end
+        end
+        ok {Benry::CmdApp::INDEX.get_alias("bla:bla2")} != nil
+        ok {Benry::CmdApp::INDEX.get_alias("bla:bla2").action_name} == "bla:bla2:blala"
+      end
+
+      spec "[!tvjb0] clears '@__aliasof__' only when alias created." do
+        class AliasOfTest3 < Benry::CmdApp::ActionScope
+          prefix "bla:bla3", alias_of: "bla3b"    # string
+          @__aliasof__ != nil  or
+            raise MiniTest::Assertion, "@__aliasof__ should NOT be nil"
+          #
+          @action.("test")
+          def bla3a(); end
+          @__aliasof__ != nil  or
+            raise MiniTest::Assertion, "@__aliasof__ should NOT be nil"
+          #
+          @action.("test")
+          def bla3b(); end
+          @__aliasof__ == nil  or
+            raise MiniTest::Assertion, "@__aliasof__ should be nil"
+        end
+        begin
+          ok {AliasOfTest3.instance_variable_get('@__aliasof__')} == nil
+        ensure
+          AliasOfTest3.class_eval do
+            @__aliasof__ = nil
+          end
+        end
+      end
+
+      spec "[!997gs] not raise error when action not found." do
+        pr = proc do
+          class AliasOfTest4 < Benry::CmdApp::ActionScope
+            prefix "blabla4", alias_of: :bla99     # action not exist
+            @action.("test")
+            def bla3(); end
+          end
+        end
+        begin
+          ok {pr}.NOT.raise?(Exception)
+        ensure
+          AliasOfTest4.class_eval { @__aliasof__ = nil }
+        end
+      end
+
+      spec "[!349nr] raises error when same name action or alias with prefix already exists." do
+        pr = proc do
+          class AliasOfTest5a < Benry::CmdApp::ActionScope
+            @action.("test")
+            def bla5(); end                    # define 'bla5' action
+          end
+          class AliasOfTest5b < Benry::CmdApp::ActionScope
+            prefix "bla5", alias_of: :blala    # define 'bla5' action, too
+            @action.("test")
+            def blala(); end
+          end
+        end
+        begin
+          ok {pr}.raise?(Benry::CmdApp::AliasDefError,
+                         'action_alias("bla5", "bla5:blala"): Not allowed to define same name alias as existing action.')
+        ensure
+          AliasOfTest5b.class_eval { @__aliasof__ = nil }
+        end
+      end
+
+    end
+
+
+  end
+
+
+  topic Benry::CmdApp::BuiltInAction do
+    include CommonTestingHelper
+
+    before do
+      @config = Benry::CmdApp::Config.new("test app", "1.0.0")
+      @config.app_name = "TestApp"
+      @config.app_command = "testapp"
+      @config.default_action = nil
+      @app = Benry::CmdApp::Application.new(@config)
+    end
+
+
+    topic '#help()' do
+
+      spec "[!jfgsy] prints help message of action if action name specified." do
+        sout, serr = capture_sio { @app.run("help", "help") }
+        ok {serr} == ""
+        ok {uncolorize(sout)} == <<"END"
+testapp help -- print help message (of action)
+
+Usage:
+  $ testapp help [<options>] [<action>]
+
+Options:
+  -a, --all          : show private (hidden) options, too
+END
+      end
+
+      spec "[!fhpjg] prints help message of command if action name not specified." do
+        sout, serr = capture_sio { @app.run("help") }
+        ok {serr} == ""
+        ok {sout}.start_with?(<<"END")
+TestApp (1.0.0) -- test app
+
+Usage:
+  $ testapp [<options>] [<action> [<arguments>...]]
+
+Options:
+  -h, --help         : print help message
+  -V, --version      : print version
+
+Actions:
+END
+      end
+
+      spec "[!6g7jh] prints colorized help message when color mode is on." do
+        sout, serr = capture_sio(tty: true) { @app.run("help") }
+        ok {serr} == ""
+        ok {sout}.start_with?(<<"END")
+\e[1mTestApp\e[0m (1.0.0) -- test app
+
+\e[34mUsage:\e[0m
+  $ \e[1mtestapp\e[0m [<options>] [<action> [<arguments>...]]
+
+\e[34mOptions:\e[0m
+  \e[1m-h, --help        \e[0m : print help message
+  \e[1m-V, --version     \e[0m : print version
+
+\e[34mActions:\e[0m
+END
+      end
+
+      spec "[!ihr5u] prints non-colorized help message when color mode is off." do
+        sout, serr = capture_sio(tty: false) { @app.run("help") }
+        ok {serr} == ""
+        ok {sout}.start_with?(<<"END")
+TestApp (1.0.0) -- test app
+
+Usage:
+  $ testapp [<options>] [<action> [<arguments>...]]
+
+Options:
+  -h, --help         : print help message
+  -V, --version      : print version
+
+Actions:
+END
+      end
+
+    end
+
+
+  end
+
+
+  topic Benry::CmdApp::Alias do
+
+    class Alias2Test < Benry::CmdApp::ActionScope
+      prefix "alias2"
+      #
+      @action.("alias test")
+      def a1(); end
+      #
+      @action.("alias test", important: true)
+      def a2(); end
+      #
+      @action.("alias test", important: false)
+      def a3(); end
+      #
+      private
+      @action.("alias test")
+      def a4(); end
+    end
+
+
+    topic '#important?()' do
+
+      spec "[!5juwq] returns true if `@important == true`." do
+        ali = Benry::CmdApp::Alias.new("a2-1", "alias2:a1", important: true)
+        ok {ali.important?} == true
+      end
+
+      spec "[!1gnbc] returns false if `@important == false`." do
+        ali = Benry::CmdApp::Alias.new("a2-2", "alias2:a1", important: false)
+        ok {ali.important?} == false
+      end
+
+      spec "[!h3nm3] returns true or false according to action object if `@important == nil`." do
+        ok {Benry::CmdApp::Alias.new("ali1", "alias2:a1").important?} == nil
+        ok {Benry::CmdApp::Alias.new("ali1", "alias2:a2").important?} == true
+        ok {Benry::CmdApp::Alias.new("ali1", "alias2:a3").important?} == false
+        ok {Benry::CmdApp::Alias.new("ali1", "alias2:a4").important?} == false
+      end
+
+    end
+
+
+  end
+
+
+end