+#!/usr/bin/env ruby
+# $:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'mocha'
+require 'biopieces'
+require 'pp'
+
+TYPES = %w[flag string list int uint float file file! files files! dir dir! genome]
+SCRIPT_PATH = "write_fasta.rb"
+
+class OptionTest < Test::Unit::TestCase
+
+ # >>>>>>>>>>>>>>>>>>>> Testing Options.new <<<<<<<<<<<<<<<<<<<<
+
+ test "Options.new with no argument don't raise" do
+ assert_nothing_raised { Options.new }
+ end
+
+ test "Options.new with empty list don't raise" do
+ assert_nothing_raised { Options.new([]) }
+ end
+
+ test "Options.new with non-array argument raises" do
+ %w[ "foo", 1, 1.2, {}, nil, false, true ].each do |arg|
+ assert_raise(TypeError) { Options.new(arg) }
+ end
+ end
+
+ test "Options.new with missing cast key raises" do
+ assert_raise(CastError) { Options.new([{}]) }
+ end
+
+ test "Options.new with all cast keys don't raise" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+
+ test "Options.new with illegal long cast values raises" do
+ [nil, true, false, 1, 0, "a"].each do |long|
+ casts = [{:long=>long, :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_raise(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal long cast values don't raise" do
+ ["foo", "!!", "0123"].each do |long|
+ casts = [{:long=>long, :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with illegal short cast values raises" do
+ [nil, true, false, "foo"].each do |short|
+ casts = [{:long=>"foo", :short=>short, :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_raise(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal short cast values don't raise" do
+ ["!", "1", "a"].each do |short|
+ casts = [{:long=>"foo", :short=>short, :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with illegal type cast values raises" do
+ [nil, true, false, "foo", 12, 0].each do |type|
+ casts = [{:long=>"foo", :short=>"f", :type=>type, :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_raise(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal type cast values don't raise" do
+ TYPES.each do |type|
+ casts = [{:long=>"foo", :short=>"f", :type=>type, :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with illegal mandatory cast values raises" do
+ ["yes", 12, 0, nil].each do |mandatory|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>mandatory, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_raise(CastError) {Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal mandatory cast values don't raise" do
+ [true, false].each do |mandatory|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>mandatory, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ assert_nothing_raised(CastError) {Options.new(casts) }
+ end
+ end
+
+ test "Options.new with illegal default cast values raises" do
+ [true, false, [], {}].each do |default|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>default, :allowed=>nil, :disallowed=>nil}]
+ assert_raise(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal default cast values don't raise" do
+ ["foo", nil, 0, 0.0, 1, 1.2].each do |default|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>default, :allowed=>nil, :disallowed=>nil}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with illegal allowed cast values raises" do
+ [true, false, {}, [], 0, 0.1].each do |allowed|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>allowed, :disallowed=>nil}]
+ assert_raise(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal allowed cast values don't raise" do
+ ["foo,bar",nil].each do |allowed|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>allowed, :disallowed=>nil}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with illegal disallowed cast values raises" do
+ [true, false, {}, [], 0, 0.1].each do |disallowed|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>disallowed}]
+ assert_raise(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with legal disallowed cast values don't raise" do
+ ["foo,bar",nil].each do |disallowed|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>disallowed}]
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+ end
+
+ test "Options.new with duplicate long cast values raises" do
+ casts = []
+ casts << {:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}
+ casts << {:long=>"foo", :short=>"b", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}
+ assert_raise(CastError) { Options.new(casts) }
+ end
+
+ test "Options.new with duplicate short cast values raises" do
+ casts = []
+ casts << {:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}
+ casts << {:long=>"bar", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}
+ assert_raise(CastError) { Options.new(casts) }
+ end
+
+ test "Options.new without duplicate long and short cast values don't raise" do
+ casts = []
+ casts << {:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}
+ casts << {:long=>"bar", :short=>"b", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}
+ assert_nothing_raised(CastError) { Options.new(casts) }
+ end
+
+ # >>>>>>>>>>>>>>>>>>>> Testing Options.parse <<<<<<<<<<<<<<<<<<<<
+
+ test "Options.parse with empty argv and missing wiki file raises" do
+ opt_parser = Options.new
+ assert_raise() { opt_parser.parse([], "foo") }
+ end
+
+ test "Options.parse with empty argv and existing wiki file don't raise" do
+ opt_parser = Options.new
+ opt_parser.expects(:print_usage_and_exit).with()
+ assert_nothing_raised { opt_parser.parse([], SCRIPT_PATH) }
+ end
+
+ test "Options.parse with --help in argv and existing wiki output long usage" do
+ opt_parser = Options.new
+ opt_parser.expects(:print_usage_and_exit).with(true)
+ assert_nothing_raised { opt_parser.parse(["--help"],SCRIPT_PATH) }
+ end
+
+# # FIXME This one fails because any argument to a flag is ignored and the flag value is set to true. Should it raise?
+# test "Options.parse with type cast flag with an argument raises" do
+# casts = [{:long=>"foo", :short=>"f", :type=>"flag", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+# opt_parser = Options.new(casts)
+# assert_raise(ArgumentError) { opt_parser.parse(["--foo", "bar"],SCRIPT_PATH) }
+# end
+
+ test "Options.parse with --stream_in <arg> returns options['stream_in']=>[<arg>]" do
+ opt_parser = Options.new
+ options = opt_parser.parse(["--stream_in", __FILE__],SCRIPT_PATH)
+ assert_equal([__FILE__], options["stream_in"])
+ end
+
+ test "Options.parse with -I <arg> returns options['stream_in']=>[<arg>]" do
+ opt_parser = Options.new
+ options = opt_parser.parse(["-I", __FILE__],SCRIPT_PATH)
+ assert_equal([__FILE__], options["stream_in"])
+ end
+
+ test "Options.parse use cast default value if no argument given" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>false, :default=>"bar", :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ options = opt_parser.parse(["-I", __FILE__],SCRIPT_PATH)
+ assert_equal(options["foo"], "bar")
+ end
+
+ test "Options.parse don't use default value if argument given" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>false, :default=>"bar", :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ options = opt_parser.parse(["--foo", "bleh", "-I", __FILE__],SCRIPT_PATH)
+ assert_equal(options["foo"], "bleh")
+ end
+
+ test "Options.parse with mandatory cast and no argument raises" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>true, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_raise(ArgumentError) { opt_parser.parse(["-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ test "Options.parse with mandatory cast and argument don't raise" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>true, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", "bar", "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+# # This one results in an error: "OptionParser::InvalidArgument: invalid argument: --foo bar"
+# # So it appears that this is tested in OptionParser already.
+# test "Options.parse with type cast int and non-int value raises" do
+# ["bar" ].each do |val| # what about nil, false, true, [], {}, 0.1 ?
+# casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+# opt_parser = Options.new(casts)
+# assert_raise(ArgumentError) { opt_parser.parse(["--foo", "#{val}"],SCRIPT_PATH) }
+# end
+# end
+
+ test "Options.parse with type cast int don't raise" do
+ [0,-1,1,327649123746293746374276347824].each do |val|
+ casts = [{:long=>"foo", :short=>"f", :type=>"int", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", "#{val}", "-I", __FILE__],SCRIPT_PATH) }
+ end
+ end
+
+ # TODO similar test for uint as "test "Options.parse with type cast int and non-int value raises" do"
+
+ test "Options.parse with type cast uint don't raise" do
+ [0,1,327649123746293746374276347824].each do |val|
+ casts = [{:long=>"foo", :short=>"f", :type=>"uint", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", "#{val}", "-I", __FILE__],SCRIPT_PATH) }
+ end
+ end
+
+ test "Options.parse with file! cast and file don't exists raises" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"file!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_raise(ArgumentError) { opt_parser.parse(["--foo", "bleh", "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ test "Options.parse with file! cast and existing file don't raise" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"file!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", __FILE__, "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ test "Options.parse with files! cast and a file don't exists raises" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"files!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_raise(ArgumentError) { opt_parser.parse(["--foo", __FILE__ + ",bleh", "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ test "Options.parse with files! cast and files exists don't raise" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"files!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", __FILE__ + "," + __FILE__, "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ # TODO replace the absolute part below the file location with File.dirname(__FILE__)
+ test "Options.parse with glob argument expands correctly" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"files!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ argv = ["--foo", "/Users/maasha/unit_test/foo*,/Users/maasha/unit_test/my_dir/*.fna", "-I", __FILE__]
+ opt_parser = Options.new(casts)
+ options = opt_parser.parse(argv,SCRIPT_PATH)
+ assert_equal(options["foo"], ["/Users/maasha/unit_test/foo.fna", "/Users/maasha/unit_test/my_dir/bar.fna"])
+ end
+
+ test "Options.parse with dir! cast and dir don't exists raises" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"dir!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_raise(ArgumentError) { opt_parser.parse(["--foo", "bleh", "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ test "Options.parse with dir! cast and dir exists don't raise" do
+ casts = [{:long=>"foo", :short=>"f", :type=>"dir!", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", "/", "-I", __FILE__],SCRIPT_PATH) }
+ end
+
+ test "Options.parse with allowed cast and not allowed value raises" do
+ ["bleh", "2", "3.3"].each do |val|
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>false, :default=>nil, :allowed=>"0,-1,0.0,1,bar", :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_raise(ArgumentError) { opt_parser.parse(["--foo", "#{val}", "-I", __FILE__],SCRIPT_PATH) }
+ end
+ end
+
+ test "Options.parse with allowed cast and allowed values don't raise" do
+ ["0", "-1", "0.0", "1", "bar"].each do |val|
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>false, :default=>nil, :allowed=>"0,-1,0.0,1,bar", :disallowed=>nil}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", "#{val}", "-I", __FILE__],SCRIPT_PATH) }
+ end
+ end
+
+ test "Options.parse with disallowed cast and disallowed value raises" do
+ ["0", "-1", "0.0", "1", "bar"].each do |val|
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>"0,-1,0.0,1,bar"}]
+ opt_parser = Options.new(casts)
+ assert_raise(ArgumentError) { opt_parser.parse(["--foo", "#{val}", "-I", __FILE__],SCRIPT_PATH) }
+ end
+ end
+
+ test "Options.parse with disallowed cast and allowed values don't raise" do
+ ["bleh", "2", "3.3"].each do |val|
+ casts = [{:long=>"foo", :short=>"f", :type=>"string", :mandatory=>false, :default=>nil, :allowed=>nil, :disallowed=>"0,-1,0.0,1,bar"}]
+ opt_parser = Options.new(casts)
+ assert_nothing_raised(ArgumentError) { opt_parser.parse(["--foo", "#{val}", "-I", __FILE__],SCRIPT_PATH) }
+ end
+ end
+end