boson 0.0.1

data/test/loader_test.rb

@@ -0,0 +1,181 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class LoaderTest < Test::Unit::TestCase
+
+    def load_namespace_library
+      Manager.load([Boson::Commands::Namespace])
+    end
+
+    context "load" do
+      before(:each) { reset }
+      test "calls included hook" do
+        capture_stdout {
+          load :blah, :file_string=>"module Blah; def self.included(mod); puts 'included blah'; end; def blah; end; end"
+        }.should =~ /included blah/
+      end
+
+      test "calls methods in config init_methods" do
+        with_config(:libraries=>{"blah"=>{:init_methods=>['blah']}}) do
+          capture_stdout {
+            load :blah, :file_string=>"module Blah; def blah; puts 'yo'; end; end"
+          }.should == "yo\n"
+        end
+      end
+
+      test "prints error and returns false for existing library" do
+        libs = create_library('blah', :loaded=>true)
+        Manager.stubs(:loader_create).returns(libs[0])
+        capture_stderr { load('blah', :no_mock=>true, :verbose=>true).should == false }.should =~ /already exists/
+      end
+
+      test "loads and strips aliases from a library's commands" do
+        with_config(:commands=>{"blah"=>{:alias=>'b'}}) do
+          load :blah, :file_string=>"module Blah; def blah; end; alias_method(:b, :blah); end"
+          library_loaded?('blah')
+          library('blah').commands.should == ['blah']
+        end
+      end
+
+      test "loads a library with dependencies" do
+        File.stubs(:exists?).returns(true)
+        File.stubs(:read).returns("module Water; def water; end; end", "module Oaks; def oaks; end; end")
+        with_config(:libraries=>{"water"=>{:dependencies=>"oaks"}}) do
+          load 'water', :no_mock=>true
+          library_has_module('water', "Boson::Commands::Water")
+          library_has_module('oaks', "Boson::Commands::Oaks")
+          command_exists?('water')
+          command_exists?('oaks')
+        end
+      end
+
+      test "prints error for library with invalid dependencies" do
+        GemLibrary.stubs(:is_a_gem?).returns(true) #mock all as gem libs
+        Util.stubs(:safe_require).returns(true)
+        with_config(:libraries=>{"water"=>{:dependencies=>"fire"}, "fire"=>{:dependencies=>"man"}}) do
+          capture_stderr { 
+            load('water', :no_mock=>true)
+          }.should == "Unable to load library fire. Reason: Can't load dependency man\nUnable to load"+
+          " library water. Reason: Can't load dependency fire\n"
+        end
+      end
+
+      test "prints error for method conflicts with config error_method_conflicts" do
+        with_config(:error_method_conflicts=>true) do
+          load('blah', :file_string=>"module Blah; def chwhat; end; end")
+          capture_stderr {
+            load('chwhat', :file_string=>"module Chwhat; def chwhat; end; end")
+          }.should =~ /Unable to load library chwhat.*conflict.*chwhat/
+        end
+      end
+
+      test "namespaces a library that has a method conflict" do
+        load('blah', :file_string=>"module Blah; def chwhat; end; end")
+        capture_stderr {
+          load('chwhat2', :file_string=>"module Chwhat2; def chwhat; end; end")
+        }.should =~ /conflict.*chwhat.*chwhat2/
+        library_has_command('namespace', 'chwhat2')
+        library_has_command('chwhat2', 'chwhat')
+      end
+
+      context "module library" do
+        def mock_library(*args); end
+
+        test "loads a module library" do
+          eval %[module ::Harvey; def bird; end; end]
+          load ::Harvey, :no_mock=>true
+          library_has_module('harvey', "Harvey")
+          command_exists?('bird')
+        end
+      end
+
+      context "gem library" do
+        def mock_library(lib, options={})
+          options[:file_string] ||= ''
+          File.stubs(:exists?).returns(false)
+          GemLibrary.expects(:is_a_gem?).returns(true)
+          Util.expects(:safe_require).with { eval options.delete(:file_string) || ''; true}.returns(true)
+        end
+
+        test "loads" do
+          with_config(:libraries=>{"dude"=>{:module=>'Dude'}}) do
+            load "dude", :file_string=>"module ::Dude; def blah; end; end"
+            library_has_module('dude', "Dude")
+            command_exists?("blah")
+          end
+        end
+
+        test "with kernel methods loads" do
+          load "dude", :file_string=>"module ::Kernel; def dude; end; end"
+          library_loaded? 'dude'
+          library('dude').module.should == nil
+          command_exists?("dude")
+        end
+
+        test "prints error when nonexistent" do
+          capture_stderr { load('blah') }.should =~ /Unable.*load/
+        end
+
+        test "with invalid module prints error" do
+          with_config(:libraries=>{"coolio"=>{:module=>"Cool"}}) do
+            capture_stderr {
+              load('coolio', :file_string=>"module ::Coolio; def coolio; end; end")
+            }.should =~ /Unable.*coolio.*No module/
+          end
+        end
+      end
+    end
+
+    context "library with namespace" do
+      before(:all) { reset_main_object }
+      before(:each) { reset_boson }
+
+      test "loads and defaults to library name" do
+        with_config(:libraries=>{'blang'=>{:namespace=>true}}) do
+          load 'blang', :file_string=>"module Blang; def bling; end; end"
+          library_has_command('blang', 'bling')
+        end
+      end
+
+      test "loads with config namespace" do
+        with_config(:libraries=>{'blung'=>{:namespace=>'dope'}}) do
+          load 'blung', :file_string=>"module Blung; def bling; end; end"
+          library_has_command('blung', 'bling')
+          library('blung').commands.size.should == 1
+        end
+      end
+
+      test "loads with config except" do
+        with_config(:libraries=>{'blong'=>{:namespace=>true, :except=>['wrong']}}) do
+          load 'blong', :file_string=>"module Blong; def bling; end; def wrong; end; end"
+          library_has_command('blong', 'bling')
+          library_has_command('blong', 'wrong', false)
+          library('blong').commands.size.should == 1
+        end
+      end
+
+      test "prints error if namespace conflicts with existing commands" do
+        eval "module Conflict; def bleng; end; end"
+        load Conflict, :no_mock=>true
+        with_config(:libraries=>{'bleng'=>{:namespace=>true}}) do
+          capture_stderr {
+            load 'bleng', :file_string=>"module Bleng; def bling; end; end"
+          }.should =~ /conflict.*bleng/
+        end
+      end
+    end
+
+    context "reload" do
+      before(:each) { reset }
+      test "loads currently unloaded library" do
+        create_library('blah')
+        Manager.expects(:load).with('blah', anything)
+        Manager.reload('blah')
+      end
+
+      test "doesn't load nonexistent library" do
+        capture_stdout { Manager.reload('bling', :verbose=>true) }.should =~ /bling doesn't/
+      end
+    end
+  end
+end

data/test/manager_test.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class ManagerTest < Test::Unit::TestCase
+    context "after_load" do
+      def load_library(hash)
+        new_attributes = {:name=>hash.delete(:name), :commands=>[], :created_dependencies=>[], :loaded=>true}
+        [:module, :except, :commands].each {|e| new_attributes[e] = hash.delete(e) if hash[e] }
+        Manager.expects(:load_once).returns(Library.new(new_attributes))
+        Manager.load([hash[:name]])
+      end
+
+      before(:each) { reset_boson }
+
+      test "loads basic library" do
+        load_library :name=>'blah'
+        library_loaded? 'blah'
+      end
+
+      test "loads library with commands" do
+        load_library :name=>'blah', :commands=>['frylock','meatwad']
+        library_loaded? 'blah'
+        command_exists?('frylock')
+        command_exists?('meatwad')
+      end
+
+      test "loads library with commands and except option" do
+        Boson.main_object.instance_eval("class<<self;self;end").expects(:undef_method).with('frylock')
+        load_library :name=>'blah', :commands=>['frylock','meatwad'], :except=>['frylock']
+        library_loaded? 'blah'
+        command_exists?('frylock', false)
+        command_exists?('meatwad')
+      end
+
+      context "command aliases" do
+        before(:each) { eval %[module ::Aquateen; def frylock; end; end] }
+        after(:each) { Object.send(:remove_const, "Aquateen") }
+
+        test "created with command specific config" do
+          with_config(:commands=>{'frylock'=>{:alias=>'fr'}}) do
+            Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+            load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+            library_loaded? 'aquateen'
+          end
+        end
+
+        test "created with config command_aliases" do
+          with_config(:command_aliases=>{"frylock"=>"fr"}) do
+            Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+            load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+            library_loaded? 'aquateen'
+          end
+        end
+
+        test "not created and warns for commands with no module" do
+          with_config(:commands=>{'frylock'=>{:alias=>'fr'}}) do
+            capture_stderr {
+              load_library(:name=>'aquateen', :commands=>['frylock'])
+            }.should =~ /No aliases/
+            library_loaded? 'aquateen'
+            Aquateen.method_defined?(:fr).should == false
+          end
+        end
+      end
+
+      test "merges with existing created library" do
+        create_library('blah')
+        load_library :name=>'blah'
+        library_loaded? 'blah'
+        Boson.libraries.size.should == 1
+      end
+    end
+
+    context "option commands without args" do
+      before(:all) {
+        reset_boson
+        @library = Library.new(:name=>'blah', :commands=>['foo', 'bar'])
+        Boson.libraries << @library
+        @foo = Command.new(:name=>'foo', :lib=>'blah', :options=>{:fool=>:string}, :args=>'*')
+        Boson.commands << @foo
+        Boson.commands << Command.new(:name=>'bar', :lib=>'blah', :options=>{:bah=>:string})
+      }
+
+      test "are deleted" do
+        Scientist.expects(:create_option_command).with(anything, @foo)
+        Manager.create_option_commands(@library, @library.commands)
+      end
+
+      test "are deleted and printed when verbose" do
+        Scientist.expects(:create_option_command).with(anything, @foo)
+        @library.instance_eval("@options = {:verbose=>true}")
+        capture_stdout { Manager.create_option_commands(@library, @library.commands) } =~ /options.*blah/
+      end
+    end
+
+    context "loaded" do
+      before(:each) { reset_libraries }
+
+      test "returns false when library isn't loaded" do
+        create_library('blah')
+        Manager.loaded?('blah').should be(false)
+      end
+
+      test "returns true when library is loaded" do
+        create_library('blah', :loaded=>true)
+        Manager.loaded?('blah').should be(true)
+      end
+    end
+  end
+end

data/test/method_inspector_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class InspectorTest < Test::Unit::TestCase
+    test "non commands module can't set anything" do
+      eval "module Blah; end"
+      MethodInspector.current_module = Blah
+      Inspector.enable
+      Blah.module_eval("desc 'test'; def test; end; options :a=>1; def test2; end")
+      Inspector.disable
+      MethodInspector.store[:desc].empty?.should == true
+      MethodInspector.store[:options].empty?.should == true
+    end
+
+    context "commands module with" do
+      def parse(string)
+        Inspector.enable
+        ::Boson::Commands::Zzz.module_eval(string)
+        Inspector.disable
+        MethodInspector.store
+      end
+
+      before(:all) { eval "module ::Boson::Commands::Zzz; end" }
+      before(:each) { MethodInspector.mod_store[::Boson::Commands::Zzz] = {} }
+
+      test "desc sets descriptions" do
+        parsed = parse "desc 'test'; def m1; end; desc 'one'; desc 'more'; def m2; end"
+        parsed[:desc].should == {"m1"=>"test", "m2"=>"more"}
+      end
+
+      test "options sets options" do
+        parse("options :z=>'b'; def zee; end")[:options].should == {"zee"=>{:z=>'b'}}
+      end
+
+      test "render_options sets render_options" do
+        parse("render_options :z=>true; def zee; end")[:render_options].should == {"zee"=>{:z=>true}}
+      end
+
+      test "neither options or desc set, sets method_locations" do
+        MethodInspector.stubs(:find_method_locations).returns(["/some/path", 10])
+        parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; render_options :a=>1; desc 'z'; options :a=>1; def az; end"
+        parsed[:method_locations].key?('yo').should == true
+        parsed[:method_locations].key?('yep').should == true
+        parsed[:method_locations].key?('az').should == false
+      end
+
+      test "no find_method_locations doesn't set method_locations" do
+        MethodInspector.stubs(:find_method_locations).returns(nil)
+        parse("def bluh; end")[:method_locations].key?('bluh').should == false
+      end
+
+      test "options calls scrape_with_eval" do
+        ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
+        parse("desc 'desc'; options :some=>:opts; def doy(arg1); end")[:method_args]['doy'].should == [['arg1']]
+      end
+
+      test "options in file calls scrape_with_eval" do
+        MethodInspector.expects(:inspector_in_file?).returns(true)
+        ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
+        parse("desc 'desc'; def doz(arg1); end")[:method_args]['doz'].should == [['arg1']]
+      end
+    end
+  end
+end

data/test/option_parser_test.rb

@@ -0,0 +1,365 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class OptionParserTest < Test::Unit::TestCase
+  def create(opts)
+    @opt = OptionParser.new(opts)
+  end
+  
+  def parse(*args)
+    @non_opts = []
+    @opt.parse(args.flatten)
+  end
+  
+  context "IndifferentAccessHash" do
+    before(:each) {
+      @hash = IndifferentAccessHash.new 'foo' => 'bar', 'baz' => 'bee'
+    }
+    it "can access values indifferently" do
+      @hash['foo'].should == 'bar'
+      @hash[:foo].should  == 'bar'
+      @hash.values_at(:foo, :baz).should == ['bar', 'bee']
+    end
+
+    it "can be initialized with either strings or symbols and be equal" do
+      hash2 = IndifferentAccessHash.new :foo=>'bar', :baz=>'bee'
+      @hash.should == hash2
+    end
+
+    it "returns keys as symbols by default" do
+      @hash.should == {:foo=>'bar', :baz=>'bee'}
+    end
+
+    it "can set values indifferently" do
+      @hash['foo'] = 'duh'
+      @hash[:foo].should == 'duh'
+      @hash[:baz] = 'wasp'
+      @hash['baz'].should == 'wasp'
+    end
+  end
+
+  context "naming" do
+    it "automatically aliases long options with their first letter" do
+      create "--foo" => true
+      parse("-f")["foo"].should == true
+    end
+
+    it "automatically aliases two options with same first letters by aliasing alphabetical first with lowercase and second with uppercase" do
+      create :verbose=>:boolean, :vertical=>:string, :verz=>:boolean
+      parse('-v', '-V','2').should == {:verbose=>true, :vertical=>'2'}
+    end
+    
+    it "doesn't auto-alias options that have multiple names given" do
+      create ["--foo", "--bar"] => :boolean
+      parse("-f")["foo"].should == nil
+    end
+
+    it "allows aliases to be symbols or strings" do
+      create [:foo, :bar, 'baz'] =>:string
+      parse("--foo", "12")[:foo].should == "12"
+      parse("--bar", "12")[:foo].should == "12"
+      parse("--baz", "12")[:foo].should == "12"
+    end
+    
+    it "allows multiple aliases for a given opt" do
+      create ["--foo", "--bar", "--baz"] => :string
+      parse("--foo", "12")["foo"].should == "12"
+      parse("--bar", "12")["foo"].should == "12"
+      parse("--baz", "12")["foo"].should == "12"
+    end
+    
+    it "allows custom short names" do
+      create "-f" => :string
+      parse("-f", "12").should == {:f => "12"}
+    end
+
+    it "allows capital short names" do
+      create :A => :boolean
+      parse("-A")[:A].should == true
+    end
+
+    it "allows capital short aliases" do
+      create [:awesome, :A] => :string
+      parse("--awesome", "bar")[:awesome].should == 'bar'
+      parse("-A", "bar")[:awesome].should == 'bar'
+    end
+
+    it "allows custom short aliases" do
+      create ["--bar", "-f"] => :string
+      parse("-f", "12").should == {:bar => "12"}
+    end
+    
+    it "allows humanized opt name" do
+      create 'foo' => :string, :bar => :required
+      parse("-f", "1", "-b", "2").should == {:foo => "1", :bar => "2"}
+    end
+
+    it "allows humanized symbol opt name" do
+      create :foo=>:string
+      parse('-f','1').should == {:foo=>'1'}
+    end
+
+    it "doesn't allow alias to override another option" do
+      create :foo=>:string, [:bar, :foo]=>:boolean
+      parse("--foo", "boo")[:foo].should == 'boo'
+    end
+
+    it "doesn't recognize long opt format for a opt that is originally short" do
+      create 'f' => :string
+      parse("-f", "1").should == {:f => "1"}
+      parse("--f", "1").should == {}
+    end
+    
+    it "accepts --[no-]opt variant for booleans, setting false for value" do
+      create "--foo" => :boolean
+      parse("--no-foo")["foo"].should == false
+      parse("--foo")["foo"].should == true
+    end
+    
+    it "will prefer 'no-opt' variant over inverting 'opt' if explicitly set" do
+      create "--no-foo" => true
+      parse("--no-foo")["no-foo"].should == true
+    end
+    
+  end
+
+  context "option values can be set with" do
+    it "a opt=<value> assignment" do
+      create "--foo" => :required
+      parse("--foo=12")["foo"].should == "12"
+      parse("-f=12")["foo"].should == "12"
+      parse("--foo=bar=baz")["foo"].should == "bar=baz"
+      parse("--foo=sentence with spaces")["foo"].should == "sentence with spaces"
+    end
+  
+    it "a -nXY assignment" do
+      create "--num" => :required
+      parse("-n12")["num"].should == "12"
+    end
+  
+    it "conjoined short options" do
+      create "--foo" => true, "--bar" => true, "--app" => true
+      opts = parse "-fba"
+      opts["foo"].should == true
+      opts["bar"].should == true
+      opts["app"].should == true
+    end
+  
+    it "conjoined short options with argument" do
+      create "--foo" => true, "--bar" => true, "--app" => :required
+      opts = parse "-fba", "12"
+      opts["foo"].should == true
+      opts["bar"].should == true
+      opts["app"].should == "12"
+    end
+  end
+
+  context "parse" do
+    it "extracts non-option arguments" do
+      create "--foo" => :required, "--bar" => true
+      parse("foo", "bar", "--baz", "--foo", "12", "--bar", "-T", "bang").should == {
+        :foo => "12", :bar => true
+      }
+      @opt.leading_non_opts.should == ["foo", "bar", "--baz"]
+      @opt.trailing_non_opts.should == ["-T", "bang"]
+      @opt.non_opts.should == ["foo", "bar", "--baz", "-T", "bang"]
+    end
+
+    context "with parse flag" do
+      it ":delete_invalid_opts deletes and warns of invalid options" do
+        create(:foo=>:boolean)
+        capture_stderr {
+          @opt.parse(%w{-f -d ok}, :delete_invalid_opts=>true)
+        }.should =~ /Deleted invalid option '-d'/
+        @opt.non_opts.should == ['ok']
+      end
+
+      it ":opts_before_args only allows options before args" do
+        create(:foo=>:boolean)
+        @opt.parse(%w{ok -f}, :opts_before_args=>true).should == {}
+        @opt.parse(%w{-f ok}, :opts_before_args=>true).should == {:foo=>true}
+      end
+    end
+
+    context "with no arguments" do
+      it "and no options returns an empty hash" do
+        create({})
+        parse.should == {}
+      end
+
+      it "and several options returns an empty hash" do
+        create "--foo" => :boolean, "--bar" => :string
+        parse.should == {}
+      end
+    end
+  end
+
+  context "option hashes" do
+    it "make hash keys available as symbols as well" do
+      create "--foo" => :string
+      parse("--foo", "12")[:foo].should == "12"
+    end
+
+    it "don't set nonexistant options" do
+      create "--foo" => :boolean
+      parse("--foo")["bar"].should == nil
+      opts = parse
+      opts["foo"].should == nil
+    end
+  end
+
+  it ":required type raises an error if it isn't given" do
+    create "--foo" => :required, "--bar" => :string
+    assert_error(OptionParser::Error, 'no value.*required.*foo') { parse("--bar", "str") }
+  end
+  
+  context ":string type" do
+    before :each do
+      create "--foo" => :string, "--bar" => :string
+    end
+
+    it "doesn't set nonexistant options" do
+      parse("--bling")[:bar].should == nil
+    end
+
+    it "sets values correctly" do
+      parse("--foo", "12")[:foo].should == "12"
+      parse("--bar", "12")[:bar].should == "12"
+    end
+
+    it "raises error if passed another valid option" do
+      assert_error(OptionParser::Error, "cannot pass.*'foo'") { parse("--foo", "--bar") }
+    end
+
+    it "raises error if not passed a value" do
+      assert_error(OptionParser::Error, "no value.*'foo'") { parse("--foo") }
+    end
+
+    it "overwrites earlier values with later values" do
+      parse("--foo", "12", "--foo", "13")[:foo].should == "13"
+    end
+  end
+  
+  context ":string type with :values attribute" do
+    before(:all ) { create :foo=>{:type=>:string, :values=>%w{angola abu abib}} }
+    it "auto aliases if a match exists" do
+      parse("-f", "an")[:foo].should == 'angola'
+    end
+
+    it "auto aliases first sorted match" do
+      parse("-f", "a")[:foo].should == 'abib'
+    end
+
+    it "raises error if option doesn't auto alias or match given values" do
+      assert_error(OptionParser::Error, "invalid.*'z'") { parse("-f", "z") }
+    end
+
+    it "doesn't raise error for a nonmatch if enum is false" do
+      create :foo=>{:type=>:string, :values=>%w{angola abu abib}, :enum=>false}
+      parse("-f", "z")[:foo].should == 'z'
+    end
+  end
+  
+  context ":string type with default value" do
+    before(:each) do
+      create "--branch" => "master"
+    end
+    
+    it "should get the specified value" do
+      parse("--branch", "bugfix").should == { :branch => "bugfix" }
+    end
+  
+    it "should get the default value when not specified" do
+      parse.should == { :branch => "master" }
+    end
+  end
+  
+  context ":numeric type" do
+    before(:each) do
+      create "n" => :numeric, "m" => 5
+    end
+    
+    it "supports numeric defaults" do
+      parse["m"].should == 5
+    end
+    
+    it "converts values to numeric types" do
+      parse("-n", "3", "-m", ".5").should == {:n => 3, :m => 0.5}
+    end
+    
+    it "raises error when value isn't numeric" do
+	  assert_error(OptionParser::Error, "expected numeric value for.*'n'") { parse("-n", "foo") }
+    end
+    
+    it "raises error when opt is present without value" do
+	    assert_error(OptionParser::Error, "no value.*'n'") { parse("-n") }
+    end
+  end
+
+  context ":array type" do
+    before(:all) {
+      create :a=>:array, :b=>[1,2,3], :c=>{:type=>:array, :values=>%w{foo fa bar zebra}},
+        :d=>{:type=>:array, :split=>" "}
+    }
+
+    it "supports array defaults" do
+      parse[:b].should == [1,2,3]
+    end
+
+    it "converts comma delimited values to an array" do
+      parse("-a","1,2,5")[:a].should == %w{1 2 5}
+    end
+
+    it "raises error when option has no value" do
+      assert_error(OptionParser::Error, "no value.*'a'") { parse("-a") }
+    end
+
+    it "auto aliases :values attribute" do
+      parse("-c","f,b")[:c].should == %w{fa bar}
+    end
+
+    it "allows a configurable splitter" do
+      parse("-d", "yogi berra")[:d].should == %w{yogi berra}
+    end
+  end
+
+  context "option with attributes" do
+    it "can get type from :type" do
+      create :foo=>{:type=>:numeric}
+      parse("-f", '3')[:foo] == 3
+    end
+
+    it "can get type and default from :default" do
+      create :foo=>{:default=>[]}
+      parse("-f", "1")[:foo].should == ['1']
+      parse[:foo].should == []
+    end
+
+    it "assumes :boolean type if no type found" do
+      create :foo=>{:some=>'params'}
+      parse('-f')[:foo].should == true
+    end
+  end
+  
+  context "#formatted_usage" do
+    def usage
+      @opt.formatted_usage.split(" ").sort
+    end
+    
+    it "outputs string args with sample values" do
+      create "--repo" => :string, "--branch" => "bugfix", "-n" => 6
+      usage.should == %w([--branch=bugfix] [--repo=REPO] [-n=6])
+    end
+    
+    it "outputs numeric args with 'N' as sample value" do
+      create "--iter" => :numeric
+      usage.should == ["[--iter=N]"]
+    end
+
+    it "outputs array args with sample value" do
+      create "--libs" => :array
+      usage.should == ["[--libs=A,B,C]"]
+    end
+  end
+end
+end