bosonson 0.304.1

data/test/options_test.rb

@@ -0,0 +1,189 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Options" do
+  def create(opts)
+    @opt = OptionParser.new(opts)
+  end
+  
+  def parse(*args)
+    @non_opts = []
+    @opt.parse(args.flatten)
+  end
+
+  describe ":string type" do
+    before {
+      create "--foo" => :string, "--bar" => :string, :blah=>{:type=>:string, :default=>:huh}
+    }
+
+    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
+
+    it "can have symbolic default value" do
+      parse('--blah','ok')[:blah].should == 'ok'
+    end
+  end
+
+  describe ":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
+
+  describe ":string type with default value" do
+    before { create "--branch" => "master" }
+  
+    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
+  
+  describe ":numeric type" do
+    before { create "n" => :numeric, "m" => 5 }
+  
+    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
+
+  describe ":array type" do
+    before_all {
+      create :a=>:array, :b=>[1,2,3], :c=>{:type=>:array, :values=>%w{foo fa bar zebra}, :enum=>false},
+        :d=>{:type=>:array, :split=>" ", :values=>[:ab, :bc, :cd], :enum=>false},
+        :e=>{:type=>:array, :values=>%w{some so silly}, :regexp=>true}
+    }
+
+    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 "auto aliases symbolic :values" do
+      parse("-d","a c")[:d].should == [:ab,:cd]
+    end
+
+    it "supports a configurable splitter" do
+      parse("-d", "yogi berra")[:d].should == %w{yogi berra}
+    end
+
+    it "aliases * to all values" do
+      parse("-c", '*')[:c].sort.should == %w{bar fa foo zebra}
+      parse("-c", '*,ok')[:c].sort.should == %w{bar fa foo ok zebra}
+    end
+
+    it "aliases correctly with :regexp on" do
+      parse("-e", 'so')[:e].sort.should == %w{so some}
+    end
+  end
+
+  describe ":hash type" do
+    before_all {
+      create :a=>:hash, :b=>{:default=>{:a=>'b'}}, :c=>{:type=>:hash, :keys=>%w{one two three}},
+        :e=>{:type=>:hash, :keys=>[:one, :two, :three], :default_keys=>:three},
+        :d=>{:type=>:hash, :split=>" "}
+    }
+
+    it "converts comma delimited pairs to hash" do
+      parse("-a", "f:3,g:4")[:a].should == {'f'=>'3', 'g'=>'4'}
+    end
+
+    it "supports hash defaults" do
+      parse[:b].should == {:a=>'b'}
+    end
+
+    it "raises error when option has no value" do
+      assert_error(OptionParser::Error, "no value.*'a'") { parse("-a") }
+    end
+
+    it "raises error if invalid key-value pair given for unknown keys" do
+      assert_error(OptionParser::Error, "invalid.*pair.*'a'") { parse("-a", 'b') }
+    end
+
+    it "auto aliases :keys attribute" do
+      parse("-c","t:3,o:1")[:c].should == {'three'=>'3', 'one'=>'1'}
+    end
+
+    it "adds in explicit default keys with value only argument" do
+      parse('-e', 'whoop')[:e].should == {:three=>'whoop'}
+    end
+
+    it "adds in default keys from known :keys with value only argument" do
+      parse("-c","okay")[:c].should == {'one'=>'okay'}
+    end
+
+    it "auto aliases symbolic :keys" do
+      parse("-e","t:3,o:1")[:e].should == {:three=>'3', :one=>'1'}
+    end
+
+    it "supports a configurable splitter" do
+      parse("-d","a:ab b:bc")[:d].should == {'a'=>'ab', 'b'=>'bc'}
+    end
+
+    it "supports grouping keys" do
+      parse("-c", "t,tw:foo,o:bar")[:c].should == {'three'=>'foo','two'=>'foo', 'one'=>'bar'}
+    end
+
+    it "aliases * to all keys" do
+      parse("-c", "*:foo")[:c].should == {'three'=>'foo', 'two'=>'foo', 'one'=>'foo'}
+      parse('-a', '*:foo')[:a].should == {'*'=>'foo'}
+    end
+  end
+end

data/test/pipes_test.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Pipes" do
+  before_all { ::Ab = Struct.new(:a, :b) }
+  describe "query_pipe" do
+    before_all {
+      @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
+      @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
+    }
+
+    it "searches one query" do
+      [@hashes, @objects].each {|e|
+        Pipes.query_pipe(e, :a=>'some').should == e[0,1]
+      }
+    end
+
+    it "searches non-string values" do
+      [@hashes, @objects].each {|e|
+        Pipes.query_pipe(e, :a=>'more').should == e[1,1]
+      }
+    end
+
+    it "searches multiple search terms" do
+      [@hashes, @objects].each {|e|
+        Pipes.query_pipe(e, :a=>'some', :b=>'yep').size.should == 2
+      }
+    end
+
+    it "prints error for invalid search field" do
+      capture_stderr { Pipes.query_pipe(@objects, :blah=>'blah') }.should =~ /failed.*'blah'/
+    end
+  end
+
+  describe "sort_pipe" do
+    before_all {
+      @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
+      @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
+    }
+    it "sorts objects with values of different types" do
+      Pipes.sort_pipe(@objects, :a).should == @objects.reverse
+    end
+
+    it "sorts hashes with values of different types" do
+      Pipes.sort_pipe(@hashes, :a).should == @hashes.reverse
+    end
+
+    it "sorts numeric values" do
+      hashes = [{:a=>10, :b=>4}, {:a=>5, :b=>3}]
+      Pipes.sort_pipe(hashes, :a).should == hashes.reverse
+    end
+
+    it "sorts numeric hash keys by string" do
+      hashes = [{2=>'thing'}, {2=>'some'}]
+      Pipes.sort_pipe(hashes, '2').should == hashes.reverse
+    end
+
+    it "sorts numeric hash keys by string" do
+      Pipes.sort_pipe(@hashes, 'a').should == @hashes.reverse
+    end
+
+    it "prints error for invalid sort field" do
+      capture_stderr { Pipes.sort_pipe(@objects, :blah)}.should =~ /failed.*'blah'/
+    end
+  end
+end

data/test/repo_index_test.rb

@@ -0,0 +1,122 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "RepoIndex" do
+  # since we're defining our own @commands, @libraries, @lib_hashes
+  def index
+    @index ||= begin
+      ind = RepoIndex.new(Boson.repo)
+      ind.instance_variable_set "@read", true
+      ind
+    end
+  end
+
+  describe "read_and_transfer" do
+    before { reset_boson; index.instance_eval "@libraries = @commands = nil" }
+
+    def transfers(options={})
+      index.instance_variable_set "@libraries", [Library.new(:name=>'blah', :commands=>['blurb']),
+        Library.new(:name=>'bling')]
+      index.instance_variable_set "@commands", [Command.new(:name=>'blurb', :lib=>'blah')]
+      index.read_and_transfer options[:ignored] || []
+      Boson.libraries.map {|e| e.name}.should == options[:libraries]
+      Boson.commands.map {|e| e.name}.should == options[:commands]
+    end
+
+    it "transfers libraries with no libraries to ignore" do
+      transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}, :ignored=>[]
+    end
+
+    it "transfers libraries and commands except for ignored libraries and its commands" do
+      transfers :libraries=>%w{bling}, :commands=>[], :ignored=>%w{blah}
+    end
+
+    it "doesn't replace existing libraries" do
+      lib = Library.new(:name=>'blah')
+      cmd = Command.new(:name=>'blurb', :lib=>'blah')
+      Boson.libraries << lib
+      Boson.commands << cmd
+      transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}
+      Boson.libraries.include?(lib).should == true
+      Boson.commands.include?(cmd).should == true
+    end
+  end
+
+  describe "find_library" do
+    before_all {
+      reset_boson
+      commands = [Command.new(:name=>'blurb', :lib=>'blah', :alias=>'bb'), 
+        Command.new(:name=>'sub', :lib=>'bling', :alias=>'s')
+      ]
+      index.instance_variable_set "@commands", commands
+      index.instance_variable_set "@libraries", [Library.new(:name=>'blah'), Library.new(:name=>'bling', :namespace=>'bling')]
+    }
+
+    it "finds command aliased or not" do
+      index.find_library('blurb').should == 'blah'
+      index.find_library('bb').should == 'blah'
+    end
+
+    it "doesn't find command" do
+      index.find_library('blah').should == nil
+    end
+
+    it "finds a subcommand aliased or not" do
+      index.find_library('bling.sub').should == 'bling'
+      # @index.find_library('bl.s').should == 'bling'
+    end
+
+    it "finds namespace command aliased or not without a subcommand" do
+      index.find_library('bling').should == 'bling'
+      # @index.find_library('bl').should == 'bling'
+    end
+
+    it "doesn't find a subcommand" do
+      index.find_library('d.d').should == nil
+    end
+  end
+
+  describe "changed_libraries" do
+    before_all { index.instance_eval "@lib_hashes = nil" }
+
+    def changed(string, all_libs=['file1'])
+      index.repo.expects(:all_libraries).returns(all_libs)
+      index.instance_variable_set "@lib_hashes", {"file1"=>Digest::MD5.hexdigest("state1")}
+      File.stubs(:exists?).returns(true)
+      File.expects(:read).returns(string)
+      index.changed_libraries
+    end
+
+    it "detects changed libraries" do
+      changed("state2").should == %w{file1}
+    end
+
+    it "detects new libraries" do
+      changed("state1", ['file2']).should == %w{file2}
+    end
+
+    it "detects no changed libraries" do
+      changed("state1").should == []
+    end
+  end
+
+  describe "write" do
+    before_all {
+      reset_boson
+      Boson.commands << Command.new(:name=>'blah', :lib=>'blah', :args=>[['arg1', {}], ['arg2', self.class]])
+      Boson.libraries << Library.new(:name=>'blah', :module=>self.class)
+      index.expects(:latest_hashes)
+      libraries = commands = []
+      index.expects(:save_marshal_index).with {|str| libraries, commands, hashes = Marshal.load(str) ; true}
+      index.write
+      @index_hash = {:libraries=>libraries, :commands=>commands}
+    }
+
+    it "saves library module constants as strings" do
+      @index_hash[:libraries][0].module.class.should == String
+    end
+
+    it "save commands with arg values as strings" do
+      @index_hash[:commands][0].args.each {|e| e[1].class.should == String}
+    end
+  end
+end

data/test/repo_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "config" do
+  before_all { reset }
+  before { @repo = Repo.new(File.dirname(__FILE__)) }
+
+  it "reloads config when passed true" do
+    @repo.config.object_id.should.not == @repo.config(true).object_id
+  end
+
+  it "reads existing config correctly" do
+    expected_hash = {:commands=>{'c1'=>{}}, :libraries=>{}}
+    File.expects(:exists?).returns(true)
+    YAML.expects(:load_file).returns(expected_hash)
+    @repo.config[:commands]['c1'].should == {}
+  end
+
+  it "ignores nonexistent file and sets config defaults" do
+    @repo.config[:command_aliases].class.should == Hash
+    @repo.config[:libraries].class.should == Hash
+  end
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/config', :force=>true }
+end

data/test/runner_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "repl_runner" do
+  def start(hash={})
+    Hirb.stubs(:enable)
+    Boson.start(hash.merge(:verbose=>false))
+  end
+
+  before_all { reset }
+  before { ConsoleRunner.instance_eval("@initialized = false") }
+
+  it "loads default libraries and libraries in :console_defaults config" do
+    defaults = Runner.default_libraries + ['yo']
+    with_config(:console_defaults=>['yo']) do
+      Manager.expects(:load).with {|*args| args[0] == defaults }
+      start
+    end
+  end
+
+  it "doesn't call init twice" do
+    capture_stderr { start }
+    ConsoleRunner.expects(:init).never
+    start
+  end
+
+  it "loads multiple libraries with :libraries option" do
+    ConsoleRunner.expects(:init)
+    Manager.expects(:load).with([:lib1,:lib2], anything)
+    start(:libraries=>[:lib1, :lib2])
+  end
+
+  it "autoloader autoloads libraries" do
+    start(:autoload_libraries=>true)
+    Index.expects(:read)
+    Index.expects(:find_library).with('blah').returns('blah')
+    Manager.expects(:load).with('blah', anything)
+    Boson.main_object.blah
+  end
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/config', :force=>true }
+end

data/test/scientist_test.rb

@@ -0,0 +1,341 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Scientist" do
+  before_all {
+    Runner.in_shell = nil
+    eval <<-EOF
+    module Blah
+      def blah(arg1, options={})
+        [arg1, options]
+      end
+      def splat_blah(*args)
+        args
+      end
+      def default_blah(arg1, arg2=default, options={})
+        [arg1, arg2, options]
+      end
+      def default; 'some default'; end
+      def default_option(options={})
+        options
+      end
+    end
+    EOF
+    @opt_cmd = Object.new.extend Blah
+  }
+
+  def command(hash, args)
+    hash = {:name=>'blah', :lib=>'bling', :options=>{:force=>:boolean, :level=>2}}.merge(hash)
+    @cmd = Command.new hash
+    @cmd.instance_variable_set("@file_parsed_args", true) if hash[:file_parsed_args]
+    Scientist.redefine_command(@opt_cmd, @cmd)
+    @opt_cmd.send(hash[:name], *args)
+  end
+
+  def command_with_arg_size(*args)
+    command({:args=>2}, args)
+  end
+
+  def command_with_args(*args)
+    command({:args=>[['arg1'],['options', {}]]}, args)
+  end
+
+  def basic_command(hash, args)
+    command({:name=>'splat_blah', :args=>'*'}.merge(hash), args)
+  end
+
+  def command_with_splat_args(*args)
+    command({:name=>'splat_blah', :args=>'*'}, args)
+  end
+
+  def command_with_arg_defaults(*args)
+    arg_defaults = [%w{arg1}, %w{arg2 default}, %w{options {}}]
+    command({:name=>'default_blah', :file_parsed_args=>true, :args=>arg_defaults}, args)
+  end
+
+  def args_are_equal(args, array)
+    command_with_args(*args).should == array
+    command_with_arg_size(*args).should == array
+    command_with_splat_args(*args).should == array
+  end
+
+  def all_commands
+    [:command_with_args, :command_with_arg_size, :command_with_splat_args]
+  end
+
+  describe "all commands" do
+    it "translate arg and options as one string" do
+      args_are_equal ['a1 -f'], ['a1', {:force=>true, :level=>2}]
+    end
+
+    it "translate arg and stringified options" do
+      args_are_equal [:cool, '-l3'], [:cool, {:level=>3}]
+    end
+
+    it "translate arg and normal hash options" do
+      args_are_equal [:cool, {:ok=>true}], [:cool, {:ok=>true, :level=>2}]
+    end
+
+    it "translate stringified arg without options sets default options" do
+      args_are_equal ['cool'], ['cool', {:level=>2}]
+    end
+
+    it "translate arg without options sets default options" do
+      args_are_equal [:cool], [:cool, {:level=>2}]
+    end
+
+    it "with invalid options print errors and delete them" do
+      all_commands.each do |cmd|
+        capture_stderr {
+          send(cmd, 'cool -f -z').should == ['cool', {:force=>true, :level=>2}]
+        }.should =~/invalid.*z/
+      end
+    end
+
+    it "print help with help option" do
+      all_commands.each do |cmd|
+        Boson.expects(:invoke).with(:usage, anything, anything)
+        send(cmd, '-h')
+      end
+    end
+  end
+
+  describe "command" do
+    describe "with arg defaults" do
+      it "sets defaults with stringified args" do
+        command_with_arg_defaults('1').should == ["1", "some default", {:level=>2}]
+      end
+
+      it "sets defaults with normal args" do
+        command_with_arg_defaults(1).should == [1, "some default", {:level=>2}]
+      end
+
+      it "sets default if optional arg is a valid option" do
+        command_with_arg_defaults("cool -f").should == ["cool", "some default", {:level=>2, :force=>true}]
+      end
+
+      it "doesn't set defaults if not needed" do
+        command_with_arg_defaults(1, 'nada').should == [1, "nada", {:level=>2}]
+      end
+
+      it "prints error for invalid defaults" do
+        arg_defaults = [%w{arg1}, %w{arg2 invalidzzz}, %w{options {}}]
+        capture_stderr {
+          command({:name=>'default_blah', :file_parsed_args=>true, :args=>arg_defaults}, [1])
+        }.should =~ /Error.*position 2/
+      end
+    end
+
+    describe "prints error" do
+      it "with option error" do
+        capture_stderr { command_with_args('a1 -l') }.should =~ /Error.*level/
+      end
+
+      it "with unexpected error in render" do
+        Scientist.expects(:can_render?).raises("unexpected")
+        capture_stderr { command_with_args('a1') }.should =~ /Error.*unexpected/
+      end
+
+      it "with no argument defined for options" do
+        assert_error(OptionCommand::CommandArgumentError, '2 for 1') { command({:args=>1}, 'ok') }
+      end
+    end
+
+    it "translates stringfied args + options starting at second arg" do
+      command_with_arg_defaults(1, 'nada -l3').should == [1, "nada", {:level=>3}]
+    end
+
+    it "with leading option-like args are translated as arguments" do
+      command_with_args('-z -f').should == ["-z", {:force=>true, :level=>2}]
+      command_with_args('--blah -f').should == ['--blah', {:force=>true, :level=>2}]
+    end
+
+    it "with splat args does not raise error for too few or many args" do
+      [[], [''], [1,2,3], ['1 2 3']].each do |args|
+        should.not.raise { command_with_splat_args *args }
+      end
+    end
+
+    it "with debug option prints debug" do
+      capture_stdout { command_with_args("-v ok") }.should =~ /Arguments.*ok/
+    end
+
+    it "with pretend option prints arguments and returns early" do
+      Scientist.expects(:render_or_raw).never
+      capture_stdout { command_with_args("-p ok") }.should =~ /Arguments.*ok/
+    end
+
+    it "with not enough args raises CommandArgumentError" do
+      args = [OptionCommand::CommandArgumentError, '0 for 1']
+      assert_error(*args) { command_with_args }
+      assert_error(*args) { command_with_args '' }
+      assert_error(*args) { command_with_arg_size }
+      assert_error(*args) { command_with_arg_size '' }
+    end
+
+    it "with too many args raises CommandArgumentError" do
+      args3 = [ArgumentError, '3 for 2']
+      args4 = [OptionCommand::CommandArgumentError, '4 for 2']
+      assert_error(*args3) { command_with_args 1,2,3 }
+      assert_error(*args4) { command_with_args '1 2 3' }
+      assert_error(*args3) { command_with_arg_size 1,2,3 }
+      assert_error(*args4) { command_with_arg_size '1 2 3' }
+    end
+  end
+
+  def command_with_render(*args)
+    basic_command({:render_options=>{:fields=>{:values=>['f1', 'f2']}} }, args)
+  end
+
+  def render_expected(options=nil)
+    View.expects(:render).with(anything, options || anything, false)
+  end
+
+  describe "render" do
+    it "called for command with render_options" do
+      render_expected
+      command_with_render('1')
+    end
+
+    it "called for command without render_options and --render" do
+      render_expected
+      command_with_args('--render 1')
+    end
+
+    it "not called for command with render_options and --render" do
+      Boson.expects(:invoke).never
+      command_with_render('--render 1')
+    end
+
+    it "not called for command without render_options" do
+      Boson.expects(:invoke).never
+      command_with_args('1')
+    end
+  end
+
+  describe "command renders" do
+    it "with basic render options" do
+      render_expected :fields => ['f1', 'f2']
+      command_with_render("--fields f1,f2 ab")
+    end
+
+    it "without non-render options" do
+      render_expected :fields=>['f1']
+      Scientist.expects(:can_render?).returns(true)
+      args = ["--render --fields f1 ab"]
+      basic_command({:render_options=>{:fields=>{:values=>['f1', 'f2']}} }, args)
+    end
+
+    it "with user-defined render options" do
+      render_expected :fields=>['f1'], :foo=>true
+      args = ["--foo --fields f1 ab"]
+      basic_command({:render_options=>{:foo=>:boolean, :fields=>{:values=>['f1', 'f2']}} }, args)
+    end
+
+    it "with non-hash user-defined render options" do
+      render_expected :fields=>['f1'], :foo=>true
+      args = ["--foo --fields f1 ab"]
+      basic_command({:render_options=>{:foo=>:boolean, :fields=>%w{f1 f2 f3}} }, args)
+    end
+  end
+
+  describe "command with default option" do
+    before_all { @cmd_attributes = {:name=>'default_option', :default_option=>'level', :args=>1} }
+
+    it "parses normally from irb" do
+      command(@cmd_attributes, '-f --level=3').should == {:level=>3, :force=>true}
+    end
+
+    it "parses normally from cmdline" do
+      Runner.expects(:in_shell?).times(2).returns true
+      command(@cmd_attributes, ['--force', '--level=3']).should == {:level=>3, :force=>true}
+    end
+
+    it "parses no arguments normally" do
+      command(@cmd_attributes, '').should == {:level=>2}
+    end
+
+    it "parses ruby arguments normally" do
+      command(@cmd_attributes, [{:force=>true, :level=>10}]).should == {:level=>10, :force=>true}
+    end
+
+    it "prepends correctly from irb" do
+      command(@cmd_attributes, '3 -f').should == {:level=>3, :force=>true}
+    end
+
+    it "prepends correctly from cmdline" do
+      Runner.expects(:in_shell?).times(2).returns true
+      command(@cmd_attributes, ['3','-f']).should == {:level=>3, :force=>true}
+    end
+  end
+
+  it "optionless command renders" do
+    render_expected :fields=>['f1']
+    command({:args=>2, :options=>nil, :render_options=>{:fields=>:array}}, ["--fields f1 ab ok"])
+  end
+
+  it "redefine_command prints error for command with nonexistant method" do
+    capture_stderr {
+      Scientist.redefine_command Object.new, Command.new(:name=>'blah', :lib=>'blah')
+    }.should =~ /Error: No method.*'blah'/
+  end
+
+  describe "global options:" do
+    def local_and_global(*args)
+      Scientist.stubs(:can_render?).returns(false) # turn off rendering caused by :render_options
+      @non_opts = basic_command(@command_options, args)
+      @non_opts.slice!(-1,1) << Scientist.global_options
+    end
+
+    before_all {
+      @command_options = {:options=>{:do=>:boolean, :foo=>:boolean},
+      :render_options=>{:dude=>:boolean}}
+      @expected_non_opts = [[], ['doh'], ['doh'], [:doh]]
+    }
+
+    it "local option overrides global one" do
+      ['-d', 'doh -d','-d doh', [:doh, '-d']].each_with_index do |args, i|
+        local_and_global(*args).should == [{:do=>true}, {}]
+        @non_opts.should == @expected_non_opts[i]
+      end
+    end
+
+    it "global option before local one is valid" do
+      args_arr = ['--dude -f', '--dude doh -f', '--dude -f doh', [:doh, '--dude -f']]
+      args_arr.each_with_index do |args, i|
+        local_and_global(*args).should == [{:foo=>true}, {:dude=>true}]
+        @non_opts.should == @expected_non_opts[i]
+      end
+    end
+
+    it "delete_options deletes global options" do
+      local_and_global('--delete_options=r,p -rp -f').should ==
+        [{:foo=>true}, {:delete_options=>["r", "p"]}]
+    end
+
+    it "global option after local one is invalid" do
+      args_arr = ['-f --dude', '-f doh --dude', '-f --dude doh', [:doh, '-f --dude'] ]
+      args_arr.each_with_index do |args, i|
+        capture_stderr {
+          local_and_global(*args).should == [{:foo=>true}, {}]
+          @non_opts.should == @expected_non_opts[i]
+        }.should =~ /invalid.*dude/
+      end
+    end
+
+    it "global option after local one and -" do
+      local_and_global("doh -r -f - --dude").should == [{:foo=>true}, {:dude=>true, :render=>true}]
+    end
+
+    it "conflicting global option after -" do
+      local_and_global('doh - -f=1,2').should == [{}, {:fields=>["1", "2"]}]
+    end
+
+    it "no options parsed after --" do
+      local_and_global('doh -f -- -r').should == [{:foo=>true}, {}]
+      local_and_global('doh -- -r -f').should == [{}, {}]
+      local_and_global('-- -r -f').should == [{}, {}]
+      local_and_global('doh -r -- -f').should == [{}, {:render=>true}]
+    end
+  end
+  after_all { Runner.in_shell = false }
+end