bosonson 0.304.1

data/test/bin_runner_test.rb

@@ -0,0 +1,223 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'boson/runners/bin_runner'
+BinRunner = Boson::BinRunner
+
+describe "BinRunner" do
+  def start(*args)
+    Hirb.stubs(:enable)
+    BinRunner.start(args)
+  end
+
+  before {|e|
+    BinRunner.instance_variables.each {|e| BinRunner.instance_variable_set(e, nil)}
+  }
+  describe "at commandline" do
+    before_all { reset }
+
+    it "no arguments prints usage" do
+      capture_stdout { start }.should =~ /^boson/
+    end
+
+    it "invalid option value prints error" do
+      aborts_with(/Error: no value/) { start("-l") }
+    end
+
+    it "help option but no arguments prints usage" do
+      capture_stdout { start '-h' }.should =~ /^boson/
+    end
+
+    it "help option and command prints help" do
+      capture_stdout { start('-h', 'commands') }.should =~ /^commands/
+    end
+
+    it "load option loads libraries" do
+      Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0][0] == 'blah'}.times(2)
+      BinRunner.stubs(:execute_command)
+      start('-l', 'blah', 'libraries')
+    end
+
+    it "console option starts irb" do
+      ConsoleRunner.expects(:start)
+      Util.expects(:which).returns("/usr/bin/irb")
+      ConsoleRunner.expects(:load_repl).with("/usr/bin/irb")
+      start("--console")
+    end
+
+    it "console option but no irb found prints error" do
+      ConsoleRunner.expects(:start)
+      Util.expects(:which).returns(nil)
+      ConsoleRunner.expects(:abort).with {|arg| arg[/Console not found/] }
+      start '--console'
+    end
+
+    it "execute option executes string" do
+      BinRunner.expects(:define_autoloader)
+      capture_stdout { start("-e", "p 1 + 1") }.should == "2\n"
+    end
+
+    it "global option takes value with whitespace" do
+      View.expects(:render).with {|*args| args[1][:fields] = %w{f1 f2} }
+      start('commands', '-f', 'f1, f2')
+    end
+
+    it "debug option sets Runner.debug" do
+      View.expects(:render)
+      start('-d', 'commands')
+      Runner.debug.should == true
+      Runner.debug = nil
+    end
+
+    it "ruby_debug option sets $DEBUG" do
+      View.expects(:render)
+      start('-D', 'commands')
+      $DEBUG.should == true
+      $DEBUG = nil
+    end
+
+    it "execute option errors are caught" do
+      aborts_with(/^Error:/) { start("-e", "raise 'blah'") }
+    end
+
+    it "option command and too many arguments prints error" do
+      capture_stdout {
+        aborts_with(/'commands'.*incorrect/) { start('commands','1','2','3') }
+      }
+    end
+
+    it "normal command and too many arguments prints error" do
+      capture_stdout {
+        aborts_with(/'render'.*incorrect/) { start('render') }
+      }
+    end
+
+    it "failed subcommand prints error and not command not found" do
+      BinRunner.expects(:execute_command).raises("bling")
+      aborts_with(/Error: bling/) { start("commands.to_s") }
+    end
+
+    it "nonexistant subcommand prints command not found" do
+      aborts_with(/'to_s.bling' not found/) { start("to_s.bling") }
+    end
+
+    it "undiscovered command prints error" do
+      BinRunner.expects(:autoload_command).returns(false)
+      aborts_with(/Error.*not found/) { start 'blah' }
+    end
+
+    it "with backtrace option prints backtrace" do
+      BinRunner.expects(:autoload_command).returns(false)
+      aborts_with(/not found\nOriginal.*runner\.rb:/m) { start("--backtrace", "blah") }
+    end
+
+    it "basic command executes" do
+      BinRunner.expects(:init).returns(true)
+      BinRunner.stubs(:render_output)
+      Boson.main_object.expects(:send).with('kick','it')
+      start 'kick','it'
+    end
+
+    it "sub command executes" do
+      obj = Object.new
+      Boson.main_object.extend Module.new { def phone; Struct.new(:home).new('done'); end }
+      BinRunner.expects(:init).returns(true)
+      BinRunner.expects(:render_output).with('done')
+      start 'phone.home'
+    end
+
+    it "bin_defaults config loads by default" do
+      defaults = Runner.default_libraries + ['yo']
+      with_config(:bin_defaults=>['yo']) do
+        Manager.expects(:load).with {|*args| args[0] == defaults }
+        aborts_with(/blah/) { start 'blah' }
+      end
+    end
+  end
+
+  describe "autoload_command" do
+    def index(options={})
+      Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0] == options[:load]
+        }.at_least(1).returns(!options[:fails])
+      Index.indexes[0].expects(:write)
+    end
+
+    it "with index option, no existing index and core command updates index and prints index message" do
+      index :load=>Runner.all_libraries
+      Index.indexes[0].stubs(:exists?).returns(false)
+      capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
+    end
+
+    it "with index option, existing index and core command updates incremental index" do
+      index :load=>['changed']
+      Index.indexes[0].stubs(:exists?).returns(true)
+      capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+    end
+
+    it "with index option, failed indexing prints error" do
+      index :load=>['changed'], :fails=>true
+      Index.indexes[0].stubs(:exists?).returns(true)
+      Manager.stubs(:failed_libraries).returns(['changed'])
+      capture_stderr {
+        capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+      }.should =~ /Error:.*failed.*changed/
+    end
+
+    it "with core command updates index and doesn't print index message" do
+      Index.indexes[0].expects(:write)
+      Boson.main_object.expects(:send).with('libraries')
+      capture_stdout { start 'libraries'}.should.not =~ /index/i
+    end
+
+    it "with non-core command not finding library, does update index" do
+      Index.expects(:find_library).returns(nil, 'sweet_lib')
+      Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
+      Index.indexes[0].expects(:update).returns(true)
+      aborts_with(/sweet/) { start 'sweet' }
+    end
+  end
+
+  describe "render_output" do
+    before { Scientist.rendered = false; BinRunner.instance_eval "@options = {}" }
+
+    it "doesn't render when nil, false or true" do
+      View.expects(:render).never
+      [nil, false, true].each do |e|
+        BinRunner.render_output e
+      end
+    end
+
+    it "doesn't render when rendered with Scientist" do
+      Scientist.rendered = true
+      View.expects(:render).never
+      BinRunner.render_output 'blah'
+    end
+
+    it "render with puts when non-string" do
+      View.expects(:render).with('dude', {:method => 'puts'})
+      BinRunner.render_output 'dude'
+    end
+
+    it "renders with inspect when non-array and non-string" do
+      [{:a=>true}, :ok].each do |e|
+        View.expects(:puts).with(e.inspect)
+        BinRunner.render_output e
+      end
+    end
+
+    it "renders with inspect when Scientist rendering toggled off with :render" do
+      Scientist.global_options = {:render=>true}
+      View.expects(:puts).with([1,2].inspect)
+      BinRunner.render_output [1,2]
+      Scientist.global_options = nil
+    end
+
+    it "renders with hirb when array" do
+      View.expects(:render_object)
+      BinRunner.render_output [1,2,3]
+    end
+  end
+
+  it "parse_args only translates options before command" do
+    BinRunner.parse_args(['-v', 'com', '-v']).should == ["com", {:verbose=>true}, ['-v']]
+    BinRunner.parse_args(['com', '-v']).should == ["com", {}, ['-v']]
+  end
+end

data/test/command_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Command" do
+  describe ".find" do
+    before_all {
+      reset_boson
+      Boson.libraries << Library.new(:name=>'bling', :namespace=>true)
+      @namespace_command = Command.new(:name=>'blah', :lib=>'bling', :namespace=>'bling')
+      @top_level_command = Command.new(:name=>'blah', :lib=>'bling')
+      Boson.commands << @namespace_command
+      Boson.commands << @top_level_command
+    }
+
+    it 'finds correct command when a subcommand of the same name exists' do
+      Command.find('blah').should == @top_level_command
+    end
+
+    it 'finds correct command when a top level command of the same name exists' do
+      Command.find('bling.blah').should == @namespace_command
+    end
+  end
+end

data/test/commands_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "WebCore" do
+  it "#get with no options" do
+    request = mock { expects(:request).with({}) }
+    Commands::WebCore::Get.expects(:new).with('blah.com').returns(request)
+    Commands::WebCore.get 'blah.com'
+  end
+
+  it "#post with no options" do
+    Net::HTTP.expects(:post_form).with(anything, {}).returns(nil)
+    Commands::WebCore.post 'blah.com'
+  end
+
+  it "#build_url with string params" do
+    Commands::WebCore.build_url('ababd.com', :q=>'search').should == 'ababd.com?q=search'
+  end
+
+  it "#build_url with array params" do
+    Commands::WebCore.build_url('ababd.com', :q=>%w{multi word search}).should == 'ababd.com?q=multi+word+search'
+  end
+end

data/test/comment_inspector_test.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "CommentInspector" do
+  before_all { eval "module ::Optional; def self.bling; {:a=>'bling'}; end; end" }
+  describe "scrapes description" do
+    before { 
+      @lines = ["module Foo", "  # some comments yay", "  def foo", "  end", "end"]
+    }
+    def description(options={})
+      CommentInspector.scrape(@lines.join("\n"), options[:line] || 3, Optional)[:desc]
+    end
+
+    it "directly above method returns desc" do
+      description.should == "some comments yay"
+    end
+
+    it "with explicit @desc returns desc" do
+      @lines[1] = '#@desc   some comments yay'
+      description.should == "some comments yay"
+    end
+
+    it "of multiple lines returns desc" do
+      @lines.delete_at(1)
+      @lines.insert(1, '#@options :b=>1', '#@desc here be', '# comments')
+      description(:line=>5).should == "here be comments"
+    end
+
+    it "that is empty returns nil" do
+      @lines[1] = ""
+      description.should == nil
+    end
+
+    it "that is empty with options keyword returns nil" do
+      @lines[1] = '#@options {:a=>1}'
+      description.should == nil
+    end
+
+    it "not directly above returns nil" do
+      @lines.insert(2, "   ")
+      description(:line=>4).should == nil
+    end
+  end
+
+  describe "scrapes options" do
+    before {
+      @lines = ["module Foo", '  #@options {:a=>true}', "  def foo", "  end", "end"]
+    }
+    def options(opts={})
+      @lines[1] = opts[:value] if opts[:value]
+      args = [@lines.join("\n"), opts[:line] || 3, Optional]
+      CommentInspector.scrape(*args)[:options]
+    end
+
+    it "that are basic" do
+      options.should == {:a=>true}
+    end
+
+    it "that are hash-like" do
+      options(:value=>'#@options :a => 2').should == {:a=>2}
+    end
+
+    it "that are whitespaced" do
+      options(:value=>"\t"+ '#    @options {:a=>1}').should == {:a=>1}
+    end
+
+    it "that have a local value" do
+      options(:value=>'#@options bling').should == {:a=>'bling'}
+    end
+
+    it "that are multi-line" do
+      @lines.delete_at(1)
+      @lines.insert(1, '#@options {:a =>', " # 1}", "# some comments")
+      options(:line=>5).should == {:a=>1}
+    end
+
+    it "with failed eval and returns nil" do
+      options(:value=>'#@options !--').should == nil
+    end
+
+    it "that are empty and returns nil" do
+      options(:value=>"# nada").should == nil
+    end
+
+    it "when @option overwrites @options" do
+      @lines.insert(1, '  #@option :a, :boolean')
+      options(:line=>4).should == {:a=>:boolean}
+    end
+
+    it "when set by @option and @options" do
+      @lines.insert(1, '  #@option :b, :boolean')
+      options(:line=>4).should == {:b=>:boolean, :a=>true}
+    end
+
+    it "when set by @option" do
+      @lines.delete_at(1)
+      @lines.insert(1, ' #@option :b, :string', '  #@option :a, 4')
+      options(:line=>4).should == {:b=>:string, :a=>4}
+    end
+
+    it "when set by multi-line @option" do
+      @lines.delete_at(1)
+      @lines.insert(1, ' #@option :b, :type=>:string,', '  # :values=>%w{one two}', '# some comments')
+      options(:line=>5).should == {:b=>{:type=>:string, :values=>%w{one two}}}
+    end
+
+    it "and ignores invalid @option's" do
+      @lines.delete_at(1)
+      @lines.insert(1, '  #@option :b=>:string', '  #@option :a, :string')
+      options(:line=>4).should == {:a=>:string}
+    end
+  end
+
+  it "scrapes all comment types with implicit desc" do
+    @lines = ["module Foo", '# @config :a=>true', '# @render_options :b=>1', '  # @options {:a=>true}',
+      '#blah', "  def foo", "  end", "end"]
+    expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}, :config=>{:a=>true}}
+    CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
+  end
+
+  it "scrapes all comment types with explicit desc" do
+    @lines = ["module Foo",  '#@desc blah', '# @render_options :b=>1,', '# :c=>2',
+      '  # @options {:a=>true}', '  # @config :a=>true', "  def foo", "  end", "end"]
+    expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}, :config=>{:a=>true}}
+    CommentInspector.scrape(@lines.join("\n"), 7, Optional).should == expected
+  end
+end

data/test/deps.rip

@@ -0,0 +1,4 @@
+mocha >=0
+bacon >=1.1.0
+mocha-on-bacon >=0
+bacon-bits >=0

data/test/file_library_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "file library" do
+  before { reset; FileLibrary.reset_file_cache }
+  before { Gem.stubs(:loaded_specs).returns({}) } if RUBY_VERSION >= '1.9.2' && defined? Gem
+
+  it "loads" do
+    load :blah, :file_string=>"module Blah; def blah; end; end"
+    library_has_module('blah', 'Boson::Commands::Blah')
+    command_exists?('blah')
+  end
+
+  it "in a subdirectory loads" do
+    load 'site/delicious', :file_string=>"module Delicious; def blah; end; end"
+    library_has_module('site/delicious', "Boson::Commands::Site::Delicious")
+    command_exists?('blah')
+  end
+
+  it "in a sub subdirectory loads" do
+    load 'web/site/delicious', :file_string=>"module Delicious; def blah; end; end"
+    library_has_module('web/site/delicious', "Boson::Commands::Web::Site::Delicious")
+    command_exists?('blah')
+  end
+
+  it "loads by basename" do
+    Dir.stubs(:[]).returns([RUBY_VERSION < '1.9.2' ? './test/commands/site/github.rb' :
+      File.expand_path('./test/commands/site/github.rb')])
+    load 'github', :file_string=>"module Github; def blah; end; end", :exists=>false
+    library_has_module('site/github', "Boson::Commands::Site::Github")
+    command_exists?('blah')
+  end
+
+  it "loads a plugin library by creating its module" do
+    load(:blah, :file_string=>"def blah; end")
+    library_has_module('blah', "Boson::Commands::Blah")
+    command_exists?('blah', false)
+  end
+
+  it "prints error for file library with multiple modules" do
+    capture_stderr { load(:blah, :file_string=>"module Doo; end; module Daa; end") }.should =~ /Can't.*config/
+  end
+end

data/test/loader_test.rb

@@ -0,0 +1,235 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Loader" do
+  def load_namespace_library
+    Manager.load([Boson::Commands::Namespace])
+  end
+
+  before { Gem.stubs(:loaded_specs).returns({}) } if RUBY_VERSION >= '1.9.2' && defined? Gem
+  describe "config" do
+    before { reset }
+    it "from callback overridden by user's config" do
+      with_config(:libraries=>{'blih'=>{:namespace=>false}}) do
+        load :blih, :file_string=>"module Blah; def self.config; {:namespace=>'bling'}; end; end"
+        library('blih').namespace.should == false
+      end
+    end
+
+    # if this test fails, other exists? using methods fail
+    it "from callback recursively merges with user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'bling', :options=>{:num=>3}}}}}) do
+        File.stubs(:exists?).returns(true)
+        load :blah, :file_string=> "module Blah; def self.config; {:commands=>{'blang'=>{:alias=>'ba'}, " +
+          "'bling'=>{:options=>{:verbose=>:boolean}}}}; end; end"
+        library('blah').command_object('bling').options.should == {:verbose=>:boolean, :num=>3}
+        library('blah').command_object('bling').desc.should == 'bling'
+        library('blah').command_object('blang').alias.should == 'ba'
+      end
+    end
+
+    it "non-hash from inspector overridden by user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'already'}}}}) do
+        load :blah, :file_string=>"module Blah; #from file\ndef bling; end; end"
+        library('blah').command_object('bling').desc.should == 'already'
+      end
+    end
+
+    it "from inspector attribute config sets command's config" do
+      load :blah, :file_string=>"module Blah; config :alias=>'ok'\n; def bling; end; end"
+      library('blah').command_object('bling').alias.should == 'ok'
+    end
+
+    it "hash from inspector recursively merged with user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'blung'=>{:args=>[], :render_options=>{:sort=>'this'}}}}}) do
+        CommentInspector.expects(:scrape).returns({:render_options=>{:fields=>['this']}})
+        load :blah, :file_string=>"module Blah; def blung; end; end"
+        library('blah').command_object('blung').render_options.should == {:fields=>["this"], :sort=>"this"}
+      end
+    end
+  end
+
+  describe "load" do
+    before { reset }
+    it "calls included callback" 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
+
+    it "calls after_included callback" do
+      capture_stdout {
+        load :blah, :file_string=>"module Blah; def self.after_included; puts 'yo'; end; end"
+      }.should == "yo\n"
+    end
+
+    it "prints error if library module conflicts with top level constant/module" do
+      capture_stderr {
+        load :blah, :file_string=>"module Object; def self.blah; end; end"
+      }.should =~ /conflict.*'Object'/
+      library_loaded?('blah')
+    end
+
+    it "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
+
+    it "loads and strips aliases from a library's commands" do
+      with_config(:command_aliases=>{"blah"=>'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
+
+    it "loads a library and creates its class commands" do
+      with_config(:libraries=>{"blah"=>{:class_commands=>{"bling"=>"Blah.bling", "Blah"=>['hmm']}}}) do
+        load :blah, :file_string=>"module Blah; def self.bling; end; def self.hmm; end; end"
+        command_exists? 'bling'
+        command_exists? 'hmm'
+      end
+    end
+
+    it "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
+
+    it "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
+
+    it "prints error for method conflicts with main_object method" do
+      with_config(:error_method_conflicts=>true) do
+        capture_stderr {
+          load('blah', :file_string=>"module Blah; def require; end; end")
+        }.should =~ /Unable to load library blah.*conflict.*require/
+      end
+    end
+
+    it "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
+
+    it "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
+
+    describe "module library" do
+      def mock_library(*args); end
+
+      it "loads a module library and all its class methods by default" do
+        eval %[module ::Harvey; def self.bird; end; def self.eagle; end; end]
+        load ::Harvey, :no_mock=>true
+        library_has_command('harvey', 'bird')
+        library_has_command('harvey', 'eagle')
+      end
+
+      it "loads a module library with specified commands" do
+        eval %[module ::Peanut; def self.bird; end; def self.eagle; end; end]
+        load ::Peanut, :no_mock=>true, :commands=>%w{bird}
+        library('peanut').commands.size.should == 1
+        library_has_command('peanut', 'bird')
+      end
+
+      it "loads a module library as a class" do
+        eval %[class ::Mentok; def self.bird; end; def self.eagle; end; end]
+        load ::Mentok, :no_mock=>true, :commands=>%w{bird}
+        library('mentok').commands.size.should == 1
+        library_has_command('mentok', 'bird')
+      end
+    end
+
+    describe "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
+
+      it "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
+
+      it "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
+
+      it "prints error when nonexistent" do
+        capture_stderr { load('blah') }.should =~ /Library blah did not/
+      end
+
+      it "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
+
+  describe "library with namespace" do
+    before_all { reset_main_object }
+    before { reset_boson }
+
+    it "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
+
+    it "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
+
+    it "prints error if namespace conflicts with existing commands" do
+      eval "module ::Conflict; def self.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
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/commands/', :force=>true }
+end