migr8 0.4.0

data/test/Application_test.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+
+require 'oktest'
+require 'migr8'
+require 'stringio'
+require File.join(File.dirname(File.expand_path(__FILE__)), 'helpers')
+
+
+Oktest.scope do
+
+
+  topic Migr8::Application do
+
+    klass = Migr8::Application
+
+
+    topic '.run()' do
+
+      fixture :app do
+        Migr8::Application.new
+      end
+
+      spec "[!dcggy] sets Migr8::DEBUG=true when '-d' or '--debug' specified." do |app|
+        [
+          ["-D"],
+          ["--debug"],
+        ].each do |args|
+          at_exit { Migr8.DEBUG = false }
+          sout, serr = Dummy.new.stdouterr do
+            Migr8::DEBUG = false
+            ok {Migr8::DEBUG} == false
+            status = app.run(args)
+            ok {Migr8::DEBUG} == true
+          end
+        end
+      end
+
+      spec "[!ktlay] prints help message and exit when '-h' or '--help' specified." do |app|
+        [
+          ["-h", "foo"],
+          ["--help", "foo"],
+        ].each do |args|
+          sout, serr = Dummy.new.stdouterr do
+            status = app.run(args)
+            ok {status} == 0
+            ok {args} == ["foo"]
+          end
+          expected = <<END
+#{File.basename($0)} -- database schema version management tool
+
+Usage: #{File.basename($0)} [global-options] [action [options] [...]]
+  -h, --help          : show help
+  -v, --version       : show version
+  -D, --debug         : not remove sql file ('migr8/tmp.sql') for debug
+
+Actions:  (default: status)
+  readme              : !!READ ME AT FIRST!!
+  help [action]       : show help message of action, or list action names
+  init                : create necessary files and a table
+  hist                : list history of versions
+  new                 : create new migration file and open it by $MIGR8_EDITOR
+  show [version]      : show migration file with expanding variables
+  edit [version]      : open migration file by $MIGR8_EDITOR
+  status              : show status
+  up                  : apply next migration
+  down                : unapply current migration
+  redo                : do migration down, and up it again
+  apply version ...   : apply specified migrations
+  unapply version ... : unapply specified migrations
+  delete version ...  : delete unapplied migration file
+
+(ATTENTION!! Run '#{File.basename($0)} readme' at first if you don't know #{File.basename($0)} well.)
+
+END
+          ok {sout} == expected
+          ok {serr} == ""
+        end
+      end
+
+      spec "[!n0ubh] prints version string and exit when '-v' or '--version' specified." do |app|
+        [
+          ["-v", "foo", "bar"],
+          ["--version", "foo", "bar"],
+        ].each do |args|
+          sout, serr = Dummy.new.stdouterr do
+            status = app.run(args)
+            ok {status} == 0
+            ok {args} == ["foo", "bar"]
+          end
+          expected = "#{Migr8::RELEASE}\n"
+          ok {sout} == expected
+          ok {serr} == ""
+        end
+      end
+
+      spec "[!saisg] returns 0 as status code when succeeded." do |app|
+        [
+          #["foo", "bar"],
+          [],
+        ].each do |args|
+          sout, serr = Dummy.new.stdouterr do
+            status = app.run(args)
+            ok {status} == 0
+            ok {args} == [] # ["foo", "bar"]
+          end
+          ok {sout}.NOT == ""
+          ok {serr} == ""
+        end
+      end
+
+    end
+
+
+    topic '.main()' do
+
+      spec "[!cy0yo] uses ARGV when args is not passed." do
+        bkup = ARGV.dup
+        ARGV[0..-1] = ["-h", "-v", "foo", "bar"]
+        Dummy.new.stdouterr do
+          klass.main()
+          ok {ARGV} == ["foo", "bar"]
+        end
+        ARGV[0..-1] = bkup
+      end
+
+      spec "[!t0udo] returns status code (0: ok, 1: error)." do
+        Dummy.new.stdouterr do
+          status = klass.main(["-hv"])
+          ok {status} == 0
+          status = klass.main(["-hx"])
+          ok {status} == 1
+        end
+      end
+
+      spec "[!maomq] command-option error is cached and not raised." do
+        Dummy.new.stdouterr do
+          pr = proc { klass.main(["-hx"]) }
+          ok {pr}.NOT.raise?(Migr8::Util::CommandOptionError)
+        end
+      end
+
+    end
+
+
+  end
+
+
+end

data/test/Migration_test.rb

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+
+require 'oktest'
+require 'migr8'
+require 'stringio'
+
+
+Oktest.scope do
+
+
+  topic Migr8::Migration do
+
+    klass = Migr8::Migration
+
+
+    topic '#initalize()' do
+
+      spec "[!y4dy3] takes version, author, and desc arguments." do
+        mig = klass.new('abcd1234', 'user1', 'desc1')
+        ok {mig.version} == 'abcd1234'
+        ok {mig.author}  == 'user1'
+        ok {mig.desc}    == 'desc1'
+      end
+
+    end
+
+
+    topic '#applied?' do
+
+      spec "[!ebzct] returns false when @applied_at is nil, else true." do
+        mig = klass.new()
+        ok {mig.applied?} == false
+        mig.applied_at = '2013-01-01 12:34:56'
+        ok {mig.applied?} == true
+      end
+
+    end
+
+
+    topic '#up_script' do
+
+      spec "[!200k7] returns @up_script if it is set." do
+        mig = klass.new()
+        mig.up_script = "xxx"
+        ok {mig.up_script} == "xxx"
+      end
+
+      spec "[!cfp34] returns nil when 'up' is not set." do
+        mig = klass.new()
+        mig.up = nil
+        ok {mig.up_script} == nil
+      end
+
+      spec "[!6gaxb] returns 'up' string expanding vars in it." do
+        original = <<END
+create table ${table} (
+  id    serial        primary key;
+  name  varchar(255)  not null;
+);
+create index ${table}_${column}_idx on ${table}(${column});
+END
+        expanded = <<END
+create table sample1 (
+  id    serial        primary key;
+  name  varchar(255)  not null;
+);
+create index sample1_name_idx on sample1(name);
+END
+        mig = klass.new
+        mig.up = original
+        mig.vars = {'table'=>'sample1', 'column'=>'name'}
+        ok {mig.up_script} == expanded
+      end
+
+      spec "[!jeomg] renders 'up' script as eRuby template." do
+        original = <<END
+insert into ${table}(${column}) values
+<% comma = "  " %>
+<% for name in %w[Haruhi Mikuru Yuki] %>
+  <%= comma %>('<%= name %>')
+  <% comma = ", " %>
+<% end %>
+;
+END
+        expanded = <<END
+insert into users(name) values
+    ('Haruhi')
+  , ('Mikuru')
+  , ('Yuki')
+;
+END
+        mig = klass.new
+        mig.up = original
+        mig.vars = {'table'=>'users', 'column'=>'name'}
+        ok {mig.up_script} == expanded
+      end
+
+    end
+
+
+    topic '#down_script' do
+
+      spec "[!27n2l] returns @down_script if it is set." do
+        mig = klass.new
+        mig.down_script = "xxx"
+        ok {mig.down_script} == "xxx"
+      end
+
+      spec "[!e45s1] returns nil when 'down' is not set." do
+        mig = klass.new
+        mig.down = nil
+        ok {mig.down_script} == nil
+      end
+
+      spec "[!0q3nq] returns 'down' string expanding vars in it." do
+        original = <<END
+drop index ${table}_${column}_idx;
+drop table ${table};
+END
+        expanded = <<END
+drop index sample1_name_idx;
+drop table sample1;
+END
+        mig = klass.new
+        mig.down = original
+        mig.vars = {'table'=>'sample1', 'column'=>'name'};
+        ok {mig.down_script} == expanded
+      end
+
+      spec "[!kpwut] renders 'up' script as eRuby template." do
+        original = <<END
+<% for name in %w[Haruhi Mikuru Yuki] %>
+delete from ${table} where ${column} = '<%= name %>';
+<% end %>
+END
+        expanded = <<END
+delete from users where name = 'Haruhi';
+delete from users where name = 'Mikuru';
+delete from users where name = 'Yuki';
+END
+        mig = klass.new
+        mig.down = original
+        mig.vars = {'table'=>'users', 'column'=>'name'}
+        ok {mig.down_script} == expanded
+      end
+
+    end
+
+
+    topic '#_render()' do
+
+      spec "[!1w3ov] renders string with 'vars' as context variables." do
+        mig = klass.new
+        mig.vars = {'table'=>'users', 'columns'=>['id', 'name']}
+        src = "@table: <%=@table.inspect%>; @columns: <%=@columns.inspect%>;"
+        output = mig.__send__(:_render, src)
+        ok {output} == '@table: "users"; @columns: ["id", "name"];'
+      end
+
+    end
+
+
+    topic '#applied_at_or()' do
+
+      spec "[!zazux] returns default arugment when not applied." do
+        mig = klass.new
+        ok {mig.applied?} == false
+        ok {mig.applied_at_or('(not applied)')} == '(not applied)'
+      end
+
+      spec "[!fxb4y] returns @applied_at without msec." do
+        mig = klass.new
+        mig.applied_at = '2013-01-01 12:34:56.789'
+        ok {mig.applied?} == true
+        ok {mig.applied_at_or('(not applied)')} == '2013-01-01 12:34:56'
+      end
+
+    end
+
+
+    topic '#filepath' do
+
+      spec "[!l9t5k] returns nil when version is not set." do
+        mig = klass.new
+        mig.version = nil
+        ok {mig.filepath} == nil
+      end
+
+      spec "[!p0d9q] returns filepath of migration file." do
+        mig = klass.new
+        mig.version = 'abcd1234'
+        ok {mig.filepath} == 'migr8/migrations/abcd1234.yaml'
+      end
+
+    end
+
+
+    topic '.load_from()' do
+
+      fixture :mig_filepath do
+        content = <<END
+# -*- coding: utf-8 -*-
+version:   wxyz7890
+author:    haruhi
+desc:      test migration '#1'
+vars:
+  - table:  members
+  - column: name
+  - index:  ${table}_${column}_idx
+
+up: |
+  cteate table ${table}(
+    id  serial   primary key,
+    name  varchar(255)  not null
+  );
+  create index ${index} on ${table}(${name});
+
+down: |
+  drop table ${table};
+END
+        fpath = "tmp.#{rand().to_s[2..5]}.yaml"
+        File.open(fpath, 'w') {|f| f.write(content) }
+        at_end { File.unlink(fpath) }
+        fpath
+      end
+
+      spec "[!fbea5] loads data from file and returns migration object." do |mig_filepath|
+        mig = klass.load_from(mig_filepath)
+        ok {mig}.is_a?(Migr8::Migration)
+        ok {mig.version} == 'wxyz7890'
+        ok {mig.author}  == 'haruhi'
+        ok {mig.desc}    == 'test migration \'#1\''
+      end
+
+      spec "[!sv21s] expands values of 'vars'." do |mig_filepath|
+        mig = klass.load_from(mig_filepath)
+        ok {mig.vars} == {'table'=>'members', 'column'=>'name',
+                          'index'=>'members_name_idx'}
+      end
+
+      spec "[!32ns3] not expand both 'up' and 'down'." do |mig_filepath|
+        mig = klass.load_from(mig_filepath)
+        ok {mig.up} == <<END
+cteate table ${table}(
+  id  serial   primary key,
+  name  varchar(255)  not null
+);
+create index ${index} on ${table}(${name});
+END
+        ok {mig.down} == <<END
+drop table ${table};
+END
+      end
+
+    end
+
+
+  end
+
+
+end

data/test/Util_test.rb

@@ -0,0 +1,873 @@
+# -*- coding: utf-8 -*-
+
+require 'oktest'
+require 'migr8'
+
+
+Oktest.scope do
+
+
+  topic Migr8::Util::CommandOptionDefinition do
+
+    klass = Migr8::Util::CommandOptionDefinition
+    errclass = Migr8::Util::CommandOptionDefinitionError
+
+
+    topic '.new()' do
+
+      spec "parses definition string of short and long options without arg." do
+        [
+          "-h, --help: show help",
+          "-h,--help: show help",
+          "  -h, --help :   show help ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'h'
+          ok {x.long}  == 'help'
+          ok {x.name}  == 'help'
+          ok {x.arg}   == nil
+          ok {x.desc}  == 'show help'
+          ok {x.arg_required} == false
+        end
+      end
+
+      spec "parses definition string of short and long options with required arg." do
+        [
+          "-a, --action=name: action name.",
+          "-a,--action=name: action name.",
+          "  -a,   --action=name  :  action name. ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'a'
+          ok {x.long}  == 'action'
+          ok {x.name}  == 'action'
+          ok {x.arg}   == 'name'
+          ok {x.desc}  == 'action name.'
+          ok {x.arg_required} == true
+        end
+      end
+
+      spec "parses definition string of short and long options with optional arg." do
+        [
+          "-i, --indent[=N]: indent depth (default 2).",
+          "-i,--indent[=N]: indent depth (default 2).",
+          "  -i,  --indent[=N]  :  indent depth (default 2). ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'i'
+          ok {x.long}  == 'indent'
+          ok {x.name}  == 'indent'
+          ok {x.arg}   == 'N'
+          ok {x.desc}  == 'indent depth (default 2).'
+          ok {x.arg_required} == nil
+        end
+      end
+
+      spec "parses definition string of short-only options without arg." do
+        [
+          "-q: be quiet",
+          "  -q  :   be quiet ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'q'
+          ok {x.long}  == nil
+          ok {x.name}  == 'q'
+          ok {x.arg}   == nil
+          ok {x.desc}  == 'be quiet'
+          ok {x.arg_required} == false
+        end
+      end
+
+      spec "parses definition string of short-only options with required arg." do
+        [
+          "-a name: action name.",
+          "  -a  name  :  action name. ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'a'
+          ok {x.long}  == nil
+          ok {x.name}  == 'a'
+          ok {x.arg}   == 'name'
+          ok {x.desc}  == 'action name.'
+          ok {x.arg_required} == true
+        end
+      end
+
+      spec "parses definition string of short-only options with optional arg." do
+        [
+          "-i[N]: indent depth (default 2).",
+          "  -i[N]  :  indent depth (default 2). ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'i'
+          ok {x.long}  == nil
+          ok {x.name}  == 'i'
+          ok {x.arg}   == 'N'
+          ok {x.desc}  == 'indent depth (default 2).'
+          ok {x.arg_required} == nil
+        end
+      end
+
+      spec "parses definition string of long-only options without arg." do
+        [
+          "--verbose: be verbose",
+          "  --verbose  :  be verbose ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == nil
+          ok {x.long}  == 'verbose'
+          ok {x.name}  == 'verbose'
+          ok {x.arg}   == nil
+          ok {x.desc}  == 'be verbose'
+          ok {x.arg_required} == false
+        end
+      end
+
+      spec "parses definition string of long-only options with required arg." do
+        [
+          "--action=name: action name.",
+          "  --action=name  :  action name. ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == nil
+          ok {x.long}  == 'action'
+          ok {x.name}  == 'action'
+          ok {x.arg}   == 'name'
+          ok {x.desc}  == 'action name.'
+          ok {x.arg_required} == true
+        end
+      end
+
+      spec "parses definition string of long-only options with optional arg." do
+        [
+          "--indent[=N]: indent depth (default 2).",
+          "  --indent[=N]  :  indent depth (default 2). ",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == nil
+          ok {x.long}  == 'indent'
+          ok {x.name}  == 'indent'
+          ok {x.arg}   == 'N'
+          ok {x.desc}  == 'indent depth (default 2).'
+          ok {x.arg_required} == nil
+        end
+      end
+
+      spec "detects '#name' notation to override option name." do
+        #
+        [
+          "-h #usage : show usage.",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'h'
+          ok {x.long}  == nil
+          ok {x.name}  == 'usage'
+          ok {x.arg}   == nil
+          ok {x.desc}  == 'show usage.'
+          ok {x.arg_required} == false
+        end
+        #
+        [
+          "-h, --help  #usage : show usage.",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'h'
+          ok {x.long}  == 'help'
+          ok {x.name}  == 'usage'
+          ok {x.arg}   == nil
+          ok {x.desc}  == 'show usage.'
+          ok {x.arg_required} == false
+        end
+        #
+        [
+          "--help  #usage : show usage.",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == nil
+          ok {x.long}  == 'help'
+          ok {x.name}  == 'usage'
+          ok {x.arg}   == nil
+          ok {x.desc}  == 'show usage.'
+          ok {x.arg_required} == false
+        end
+        #
+        [
+          "-a name #command : action name.",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'a'
+          ok {x.long}  == nil
+          ok {x.name}  == 'command'
+          ok {x.arg}   == 'name'
+          ok {x.desc}  == 'action name.'
+          ok {x.arg_required} == true
+        end
+        #
+        [
+          "--action=name #command : action name.",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == nil
+          ok {x.long}  == 'action'
+          ok {x.name}  == 'command'
+          ok {x.arg}   == 'name'
+          ok {x.desc}  == 'action name.'
+          ok {x.arg_required} == true
+        end
+        #
+        [
+          "-i, --indent[=N] #width : indent width (default 2).",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'i'
+          ok {x.long}  == 'indent'
+          ok {x.name}  == 'width'
+          ok {x.arg}   == 'N'
+          ok {x.desc}  == 'indent width (default 2).'
+          ok {x.arg_required} == nil
+        end
+        #
+        [
+          "-i[N] #width : indent width (default 2).",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == 'i'
+          ok {x.long}  == nil
+          ok {x.name}  == 'width'
+          ok {x.arg}   == 'N'
+          ok {x.desc}  == 'indent width (default 2).'
+          ok {x.arg_required} == nil
+        end
+        #
+        [
+          "--indent[=N] #width : indent width (default 2).",
+        ].each do |defstr|
+          x = klass.new(defstr)
+          ok {x.short} == nil
+          ok {x.long}  == 'indent'
+          ok {x.name}  == 'width'
+          ok {x.arg}   == 'N'
+          ok {x.desc}  == 'indent width (default 2).'
+          ok {x.arg_required} == nil
+        end
+      end
+
+      spec "raises error when failed to parse definition string." do
+        pr = proc { klass.new("-h, --help:show help") }
+        ok {pr}.raise?(errclass, "'-h, --help:show help': invalid definition.")
+      end
+
+    end
+
+
+    topic '#usage()' do
+
+      spec "[!xd9do] returns option usage with specified width." do
+        optdef = klass.new("-h, --help: show help")
+        ok {optdef.usage(15)} == "-h, --help     : show help"
+        ok {optdef.usage()}   == "-h, --help          : show help"
+        optdef = klass.new("-h: show help")
+        ok {optdef.usage()}   == "-h                  : show help"
+        optdef = klass.new("--help: show help")
+        ok {optdef.usage()}   == "--help              : show help"
+        #
+        optdef = klass.new("-a, --action=name: action name")
+        ok {optdef.usage(15)} == "-a, --action=name: action name"
+        ok {optdef.usage()}   == "-a, --action=name   : action name"
+        optdef = klass.new("-a name: action name")
+        ok {optdef.usage()}   == "-a name             : action name"
+        optdef = klass.new("--action=name: action name")
+        ok {optdef.usage()}   == "--action=name       : action name"
+        #
+        optdef = klass.new("-i, --indent[=N]: indent width")
+        ok {optdef.usage(15)} == "-i, --indent[=N]: indent width"
+        ok {optdef.usage()}   == "-i, --indent[=N]    : indent width"
+        optdef = klass.new("-i[N]: indent width")
+        ok {optdef.usage()}   == "-i[N]               : indent width"
+        optdef = klass.new("--indent[=N]: indent width")
+        ok {optdef.usage()}   == "--indent[=N]        : indent width"
+      end
+
+    end
+
+  end
+
+
+  topic Migr8::Util::CommandOptionParser do
+
+    klass = Migr8::Util::CommandOptionParser
+    errclass = Migr8::Util::CommandOptionError
+
+
+    topic '#add()' do
+
+      spec "[!tm89j] parses definition string and adds optdef object." do
+        parser = klass.new
+        parser.add("-h, --help: show help")
+        parser.add("-a, --action=name: action name.")
+        ok {parser.optdefs.length} == 2
+        ok {parser.optdefs[0].short} == 'h'
+        ok {parser.optdefs[0].long}  == 'help'
+        ok {parser.optdefs[0].arg}   == nil
+        ok {parser.optdefs[1].short} == 'a'
+        ok {parser.optdefs[1].long}  == 'action'
+        ok {parser.optdefs[1].arg}   == 'name'
+      end
+
+      spec "[!00kvl] returns self." do
+        parser = klass.new
+        ret = parser.add("-h, --help: show help")
+        ok {ret}.same?(parser)
+      end
+
+    end
+
+
+    topic '#parse()' do
+
+      fixture :parser do
+        parser = klass.new
+        parser.add("-h, --help        : show help")
+        parser.add("-V   #version     : show version")
+        parser.add("-a, --action=name : action name")
+        parser.add("-i, --indent[=N]  : indent width (default N=2)")
+        parser
+      end
+
+      spec "returns options parsed." do |parser|
+        args = "-hVi4 -a print foo bar".split(' ')
+        options = parser.parse(args)
+        ok {options} == {'help'=>true, 'version'=>true, 'indent'=>4, 'action'=>'print'}
+        ok {args} == ["foo", "bar"]
+      end
+
+      spec "parses short options." do |parser|
+        # short options
+        args = "-hVi4 -a print foo bar".split(' ')
+        options = parser.parse(args)
+        ok {options} == {'help'=>true, 'version'=>true, 'indent'=>4, 'action'=>'print'}
+        ok {args} == ["foo", "bar"]
+        #
+        args = "-hi foo bar".split(' ')
+        options = parser.parse(args)
+        ok {options} == {'help'=>true, 'indent'=>true}
+        ok {args} == ["foo", "bar"]
+      end
+
+      spec "parses long options." do |parser|
+        # long options
+        args = "--help --action=print --indent=4 foo bar".split(' ')
+        options = parser.parse(args)
+        ok {options} == {'help'=>true, 'indent'=>4, 'action'=>'print'}
+        ok {args} == ["foo", "bar"]
+        #
+        args = "--indent foo bar".split(' ')
+        options = parser.parse(args)
+        ok {options} == {'indent'=>true}
+        ok {args} == ["foo", "bar"]
+      end
+
+      spec "[!2jo9d] stops to parse options when '--' found." do |parser|
+        args = ["-h", "--", "-V", "--action=print", "foo", "bar"]
+        options = parser.parse(args)
+        ok {options} == {'help'=>true}
+        ok {args} == ["-V", "--action=print", "foo", "bar"]
+      end
+
+      spec "[!7pa2x] raises error when invalid long option." do |parser|
+        pr1 = proc { parser.parse(["--help?", "aaa"]) }
+        ok {pr1}.raise?(errclass, "--help?: invalid option format.")
+        pr2 = proc { parser.parse(["---help", "aaa"]) }
+        ok {pr2}.raise?(errclass, "---help: invalid option format.")
+      end
+
+      spec "[!sj0cv] raises error when unknown long option." do |parser|
+        pr = proc { parser.parse(["--foobar", "aaa"]) }
+        ok {pr}.raise?(errclass, "--foobar: unknown option.")
+      end
+
+      spec "[!a7qxw] raises error when argument required but not provided." do |parser|
+        pr = proc { parser.parse(["--action", "foo", "bar"]) }
+        ok {pr}.raise?(errclass, "--action: argument required.")
+      end
+
+      spec "[!8eu9s] raises error when option takes no argument but provided." do |parser|
+        pr = proc { parser.parse(["--help=true", "foo", "bar"]) }
+        ok {pr}.raise?(errclass, "--help=true: unexpected argument.")
+      end
+
+      case_when "[!1l2dn] when argname is 'N'..." do
+
+        spec "[!cfjp3] raises error when argval is not an integer." do |parser|
+          parser.add("-n, --num=N: number")
+          pr = proc { parser.parse(["--num=314"]) }
+          ok {pr}.NOT.raise?(Exception)
+          pr = proc { parser.parse(["--num=3.14"]) }
+          ok {pr}.raise?(errclass, "--num=3.14: integer expected.")
+          #
+          pr = proc { parser.parse(["--indent=4"]) }
+          ok {pr}.NOT.raise?(Exception)
+          pr = proc { parser.parse(["--indent=4i"]) }
+          ok {pr}.raise?(errclass, "--indent=4i: integer expected.")
+        end
+
+        spec "[!18p1g] raises error when argval <= 0." do |parser|
+          parser.add("-n, --num=N: number")
+          opts = parser.parse(["--num=9"])
+          ok {opts['num']} == 9
+          #
+          pr = proc { parser.parse(["--num=-9"]) }
+          ok {pr}.raise?(errclass, "--num=-9: positive value expected.")
+          pr = proc { parser.parse(["--num=0"]) }
+          ok {pr}.raise?(errclass, "--num=0: positive value expected.")
+        end
+
+      end
+
+      spec "[!dtbdd] uses option name instead of long name when option name specified." do |parser|
+        pr = proc { parser.parse(["--help=true", "foo", "bar"]) }
+        ok {pr}.raise?(errclass, "--help=true: unexpected argument.")
+      end
+
+      spec "[!7mp75] sets true as value when argument is not provided." do |parser|
+        args = ["--help", "foo", "bar"]
+        options = parser.parse(args)
+        ok {options} == {'help'=>true}
+        ok {args} == ["foo", "bar"]
+      end
+
+      spec "[!8aaj0] raises error when unknown short option provided." do |parser|
+        args = ["-hxV", "foo"]
+        pr = proc { parser.parse(args) }
+        ok {pr}.raise?(errclass, "-x: unknown option.")
+      end
+
+      case_when "[!mnwxw] when short option takes no argument..." do
+
+        spec "[!8atm1] sets true as value." do |parser|
+          args = ["-hV", "foo", "bar"]
+          options = parser.parse(args)
+          ok {options} == {'help'=>true, 'version'=>true}
+          ok {args} == ["foo", "bar"]
+        end
+
+      end
+
+      case_when "[!l5mee] when short option takes required argument..." do
+
+        spec "[!crvxx] uses following string as argument." do |parser|
+          [
+            ["-aprint", "foo", "bar"],
+            ["-a", "print", "foo", "bar"],
+          ].each do |args|
+            options = parser.parse(args)
+            ok {options} == {'action'=>'print'}
+            ok {args} == ["foo", "bar"]
+          end
+        end
+
+        spec "[!7t6l3] raises error when no argument provided." do |parser|
+          pr = proc { parser.parse(["-a"]) }
+          ok {pr}.raise?(errclass, "-a: argument required.")
+        end
+
+        case_when "[!h3gt8] when argname is 'N'..." do
+
+          spec "[!yzr2p] argument must be an integer." do |parser|
+            parser.add("-n, --num=N: number.")
+            pr = proc { parser.parse(["-n", "314", "hoo"]) }
+            ok {pr}.NOT.raise?(Exception)
+            #
+            pr = proc { opts = parser.parse(["-n", "3.14", "hoo"]) }
+            ok {pr}.raise?(errclass, "-n 3.14: integer expected.")
+          end
+
+          spec "[!mcwu7] argument must be positive value." do |parser|
+            parser.add("-n, --num=N: number.")
+            opts = parser.parse(["-n", "9"])
+            ok {opts['num']} == 9
+            #
+            pr = proc { parser.parse(["-n", "-9"]) }
+            ok {pr}.raise?(errclass, "-n -9: positive value expected.")
+            pr = proc { parser.parse(["-n", "0"]) }
+            ok {pr}.raise?(errclass, "-n 0: positive value expected.")
+          end
+
+        end
+
+      end
+
+      case_when "[!pl97z] when short option takes optional argument..." do
+
+        spec "[!4k3zy] uses following string as argument if provided." do |parser|
+          args = ["-hi4", "foo", "bar"]
+          options = parser.parse(args)
+          ok {options} == {'help'=>true, 'indent'=>4}
+          ok {args} == ["foo", "bar"]
+        end
+
+        spec "[!9k2ip] uses true as argument value if not provided." do |parser|
+          args = ["-hi", "foo", "bar"]
+          options = parser.parse(args)
+          ok {options} == {'help'=>true, 'indent'=>true}
+          ok {args} == ["foo", "bar"]
+        end
+
+        case_when "[!lk761] when argname is 'N'..." do
+
+          spec "[!6oy04] argument must be an integer." do |parser|
+            parser.add("-n, --num[=N]: number.")
+            pr = proc { parser.parse(["-n314", "hoo"]) }
+            ok {pr}.NOT.raise?(Exception)
+            #
+            pr = proc { parser.parse(["-n3.14", "hoo"]) }
+            ok {pr}.raise?(errclass, "-n3.14: integer expected.")
+          end
+
+          spec "[!nc3av] argument must be positive value." do |parser|
+            parser.add("-n, --num[=N]: number")
+            opts = parser.parse(["-n9"])
+            ok {opts['num']} == 9
+            #
+            pr = proc { opts = parser.parse(["-n-9"]) }
+            ok {pr}.raise?(errclass, "-n-9: positive value expected.")
+            pr = proc { opts = parser.parse(["-n0"]) }
+            ok {pr}.raise?(errclass, "-n0: positive value expected.")
+          end
+
+        end
+
+      end
+
+      spec "[!35eof] returns parsed options." do |parser|
+        [
+          ["-hVi4", "--action=print", "foo", "bar"],
+          ["--indent=4", "-hVa", "print", "foo", "bar"],
+        ].each do |args|
+          options = parser.parse(args)
+          ok {options} == {'help'=>true, 'version'=>true, 'indent'=>4, 'action'=>'print'}
+          ok {args} == ["foo", "bar"]
+        end
+      end
+
+    end
+
+
+    topic '#usage()' do
+
+      spec "[!w9v9c] returns usage string of all options." do
+        parser = klass.new
+        parser.add("-h, --help        : show help")
+        parser.add("-V   #version     : show version")
+        parser.add("-a, --action=name : action name")
+        parser.add("-i, --indent[=N]  : indent width (default N=2)")
+        #
+        expected = <<'END'
+-h, --help          : show help
+-V                  : show version
+-a, --action=name   : action name
+-i, --indent[=N]    : indent width (default N=2)
+END
+        ok {parser.usage()} == expected
+        #
+        expected = <<'END'
+-h, --help      : show help
+-V              : show version
+-a, --action=name: action name
+-i, --indent[=N]: indent width (default N=2)
+END
+        ok {parser.usage(16)} == expected
+      end
+
+      spec "[!i0uvr] adds indent when specified." do
+        parser = klass.new
+        parser.add("-h, --help        : show help")
+        parser.add("--quiet           : be quiet")
+        #
+        expected = <<'END'
+  -h, --help          : show help
+  --quiet             : be quiet
+END
+        ok {parser.usage(nil, '  ')} == expected
+      end
+
+      spec "[!lbjai] skips options when desc is empty." do
+        parser = klass.new
+        parser.add("-h, --help        : show help")
+        parser.add("-D, --debug[=N]   : ")
+        parser.add("--quiet           : be quiet")
+        #
+        expected = <<'END'
+-h, --help          : show help
+--quiet             : be quiet
+END
+        ok {parser.usage()} == expected
+      end
+
+
+    end
+
+
+  end
+
+
+  topic Migr8::Util::Template do
+
+    tmpl_class = Migr8::Util::Template
+
+
+    topic '#initialize()' do
+
+      spec "[!6z4kp] converts input string into ruby code." do
+        input = <<'END'
+<p>
+  <% x = 10 %>
+  <%= x %>
+  <%== x %>
+</p>
+END
+        expected = <<'END'
+_buf = ''; _buf << %q`<p>
+`;   x = 10 
+; _buf << %q`  `; _buf << (escape( x )).to_s; _buf << %q`
+`; _buf << %q`  `; _buf << ( x ).to_s; _buf << %q`
+`; _buf << %q`</p>
+`;
+_buf.to_s
+END
+        tmpl = tmpl_class.new(input)
+        ok {tmpl.src} == expected
+      end
+
+    end
+
+    topic '#convert()' do
+
+      spec "[!118pw] converts template string into ruby code." do
+        input = <<'END'
+<div>
+  <% for i in 1..3 do %>
+    <%== i %>
+  <% end %>
+</div>
+END
+        expected = <<'END'
+_buf = ''; _buf << %q`<div>
+`;   for i in 1..3 do 
+; _buf << %q`    `; _buf << ( i ).to_s; _buf << %q`
+`;   end 
+; _buf << %q`</div>
+`;
+_buf.to_s
+END
+        tmpl = tmpl_class.new()
+        actual = tmpl.convert(input)
+        ok {actual} == expected
+      end
+
+      spec "[!7ht59] escapes '`' and '\\' characters." do
+        input = <<'END'
+output = `ls`
+newline = "\n"
+END
+        expected = <<'END'
+_buf = ''; _buf << %q`output = \`ls\`
+newline = "\\n"
+`;
+_buf.to_s
+END
+        tmpl = tmpl_class.new()
+        actual = tmpl.convert(input)
+        ok {actual} == expected
+      end
+
+      spec "[!u93y5] wraps expression by 'escape()' when <%= %>." do
+        input = "val=<%= val %>"
+        expected = <<'END'
+_buf = ''; _buf << %q`val=`; _buf << (escape( val )).to_s;
+_buf.to_s
+END
+        tmpl = tmpl_class.new()
+        ok {tmpl.convert(input)} == expected
+      end
+
+      spec "[!auj95] leave expression as it is when <%== %>." do
+        input = "val=<%== val %>"
+        expected = <<'END'
+_buf = ''; _buf << %q`val=`; _buf << ( val ).to_s;
+_buf.to_s
+END
+        tmpl = tmpl_class.new()
+        ok {tmpl.convert(input)} == expected
+      end
+
+      spec "[!b10ns] generates ruby code correctly even when no embedded code." do
+        input = <<'END'
+create table (users) (
+  id     serial        primary key,
+  name   varchar(255)  not null
+);
+END
+        expected = <<'END'
+_buf = ''; _buf << %q`create table (users) (
+  id     serial        primary key,
+  name   varchar(255)  not null
+);
+`;
+_buf.to_s
+END
+        tmpl = tmpl_class.new()
+        actual = tmpl.convert(input)
+        ok {actual} == expected
+      end
+
+    end
+
+
+    topic '#render()' do
+
+      spec "[!48pfc] returns rendered string." do
+        input = <<'END'
+<p>
+  <% for item in ['Haruhi', 'Mikuru', 'Yuki'] %>
+  <%= item %>
+  <% end %>
+</p>
+END
+        expected = <<'END'
+<p>
+  Haruhi
+  Mikuru
+  Yuki
+</p>
+END
+        tmpl = tmpl_class.new(input)
+        actual = tmpl.render()
+        ok {actual} == expected
+      end
+
+      spec "[!umsfx] takes hash object as context variables." do
+        input = <<'END'
+<p>
+  <% for item in @members %>
+  <%= item %>
+  <% end %>
+</p>
+END
+        expected = <<'END'
+<p>
+  Haruhi
+  Mikuru
+  Yuki
+</p>
+END
+        context = {
+          :members=>['Haruhi', 'Mikuru', 'Yuki'],
+        }
+        tmpl = tmpl_class.new(input)
+        actual = tmpl.render(context)
+        ok {actual} == expected
+      end
+
+      spec "[!p0po0] context argument can be null." do
+        input = "Hello"
+        context = nil
+        tmpl = tmpl_class.new(input)
+        actual = nil
+        pr = proc { actual = tmpl.render(nil) }
+        ok {pr}.NOT.raise?()
+        ok {actual} == "Hello"
+      end
+
+      spec "[!1i0v8] escapes \"'\" into \"''\" when '<%= %>', and not when '<%== %>'." do
+        input = <<'END'
+  <% for item in @items %>
+  <%= item %>
+  <%== item %>
+  <% end %>
+END
+        expected = <<'END'
+  Rock''n Roll
+  Rock'n Roll
+  xx''yy''''zz''''''
+  xx'yy''zz'''
+END
+        items = ["Rock'n Roll", "xx'yy''zz'''"]
+        tmpl = tmpl_class.new(input)
+        ok {tmpl.render({:items=>items})} == expected
+      end
+
+    end
+
+
+  end
+
+
+  topic Migr8::Util::TemplateContext do
+    klass = Migr8::Util::TemplateContext
+
+
+    topic '#initialize()' do
+
+      spec "[!p69q1] takes vars and sets them into instance variables." do
+        ctx = klass.new({'title'=>'hello', 'members'=>%w[Haruhi Mikuru Yuki]})
+        ok {ctx.instance_variable_get('@title')} == 'hello'
+        ok {ctx.instance_variable_get('@members')} == ['Haruhi', 'Mikuru', 'Yuki']
+      end
+
+      spec "[!p853f] do nothing when vars is nil." do
+        pr = proc { klass.new(nil) }
+        ok {pr}.NOT.raise?(Exception)
+      end
+
+    end
+
+
+    topic '#escape()' do
+
+      spec "[!f3yy9] escapes \"'\" into \"''\" for default." do
+        $MIGR8_DBMS = nil
+        ctx = klass.new()
+        ok {ctx.escape("lock'n roll!")} == "lock''n roll!"
+        ok {ctx.escape("aa'bb''cc'''")} == "aa''bb''''cc''''''"
+      end
+
+      spec "[!to5kz] converts any value into string." do
+        $MIGR8_DBMS = nil
+        ctx = klass.new()
+        ok {ctx.escape(1)} == "1"
+        ok {ctx.escape(nil)} == ""
+        ok {ctx.escape(true)} == "true"
+        ok {ctx.escape(false)} == "false"
+      end
+
+      spec "[!6v5yq] escapes "'" into "\\'" when on MySQL dbms." do
+        at_exit { $MIGR8_DBMS = nil }
+        #
+        $MIGR8_DBMS = Migr8::DBMS::MySQL.new('mysql -q -u user1 example1')
+        ctx = klass.new()
+        ok {ctx.escape("aa'bb''cc'''")} == "aa\\'bb\\'\\'cc\\'\\'\\'"
+        ok {ctx.escape(123)} == "123"
+        ok {ctx.escape(nil)} == ""
+        #
+        $MIGR8_DBMS = Migr8::DBMS::SQLite3.new('sqlite3 example1.db')
+        ctx = klass.new()
+        ok {ctx.escape("aa'bb''cc'''")} == "aa''bb''''cc''''''"
+        ok {ctx.escape(123)} == "123"
+        ok {ctx.escape(nil)} == ""
+        #
+        $MIGR8_DBMS = Migr8::DBMS::PostgreSQL.new('psql -q -U user1 example1')
+        ctx = klass.new()
+        ok {ctx.escape("aa'bb''cc'''")} == "aa''bb''''cc''''''"
+        ok {ctx.escape(123)} == "123"
+        ok {ctx.escape(nil)} == ""
+      end
+
+
+    end
+
+
+  end
+
+
+end