rubycut-babushka 0.10.8 → 0.15.6.1

data/spec/babushka/shell_helpers_spec.rb

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
-SucceedingLs = 'ls /bin'
-FailingLs = 'ls /nonexistent'
+SUCCEEDING_LS = 'ls /bin'
+FAILING_LS = 'ls /missing'
 
 describe "shell" do
   it "should return something true on successful commands" do
-    shell('true').should_not be_nil
+    ShellHelpers.shell('true').should_not be_nil
   end
   it "should return nil on failed commands" do
-    shell('false').should be_nil
+    ShellHelpers.shell('false').should be_nil
   end
   it "should return output of successful commands" do
-    shell('echo lol').should == 'lol'
+    ShellHelpers.shell('echo lol').should == 'lol'
   end
   it "should accept multiline commands" do
-    shell("echo babu &&\necho shka").should == "babu\nshka"
+    ShellHelpers.shell("echo babu &&\necho shka").should == "babu\nshka"
   end
   it "should accept environment variables as the first argument" do
-    shell({'KEY' => 'value'}, "echo $KEY").should == "value"
+    ShellHelpers.shell({'KEY' => 'value'}, "echo $KEY").should == "value"
   end
   it "should provide the shell to supplied blocks when the command succeeds" do
     (the_block = "").should_receive(:was_called)
-    shell(SucceedingLs) {|shell|
+    ShellHelpers.shell(SUCCEEDING_LS) {|shell|
       the_block.was_called
       shell.stdout.should include('bash')
       shell.stderr.should be_empty
@@ -29,37 +29,43 @@ describe "shell" do
   end
   it "should provide the shell to supplied blocks when the command fails" do
     (the_block = "").should_receive(:was_called)
-    shell(FailingLs) {|shell|
+    ShellHelpers.shell(FAILING_LS) {|shell|
       the_block.was_called
       shell.stdout.should be_empty
       shell.stderr.should include("No such file or directory")
     }
   end
   it "should accept :input parameter" do
-    shell('cat', :input => 'lol').should == "lol"
+    ShellHelpers.shell('cat', :input => 'lol').should == "lol"
   end
   context ":cd parameter" do
     before { (tmp_prefix / 'dir_param').mkdir }
     it "should run in the current directory when :cd isn't specified" do
-      shell("pwd").should == Dir.pwd
+      ShellHelpers.shell("pwd -P").should == Dir.pwd
     end
     it "should run in the specified directory" do
-      shell("pwd", :cd => (tmp_prefix / 'dir_param')).should == (tmp_prefix / 'dir_param').to_s
+      ShellHelpers.shell("pwd", :cd => (tmp_prefix / 'dir_param')).should == (tmp_prefix / 'dir_param').to_s
     end
     it "should expand the path" do
-      shell("pwd", :cd => '~').should == ENV['HOME']
+      ShellHelpers.shell("pwd", :cd => '~').should == ENV['HOME']
     end
     it "should raise when the path is nonexistent" do
       L{
-        shell("pwd", :cd => (tmp_prefix / 'nonexistent'))
-      }.should raise_error(Errno::ENOENT, "No such file or directory - #{tmp_prefix / 'nonexistent'}")
+        ShellHelpers.shell("pwd", :cd => (tmp_prefix / 'missing'))
+      }.should raise_error(Errno::ENOENT, "No such file or directory - #{tmp_prefix / 'missing'}")
+    end
+    it "should raise when the path isn't a directory" do
+      L{
+        (tmp_prefix / 'notadir').touch
+        ShellHelpers.shell("pwd", :cd => (tmp_prefix / 'notadir'))
+      }.should raise_error(Errno::ENOTDIR, "Not a directory - #{tmp_prefix / 'notadir'}")
     end
     context "with :create option" do
       it "should run in the specified directory" do
-        shell("pwd", :cd => (tmp_prefix / 'dir_param'), :create => true).should == (tmp_prefix / 'dir_param').to_s
+        ShellHelpers.shell("pwd", :cd => (tmp_prefix / 'dir_param'), :create => true).should == (tmp_prefix / 'dir_param').to_s
       end
       it "should create and run when the path is nonexistent" do
-        shell("pwd", :cd => (tmp_prefix / 'dir_param_with_create'), :create => true).should == (tmp_prefix / 'dir_param_with_create').to_s
+        ShellHelpers.shell("pwd", :cd => (tmp_prefix / 'dir_param_with_create'), :create => true).should == (tmp_prefix / 'dir_param_with_create').to_s
       end
     end
   end
@@ -67,178 +73,197 @@ end
 
 describe "shell?" do
   it "should return the output for successful commands" do
-    shell?('echo lol').should == 'lol'
-    shell?(SucceedingLs).should be_true
+    ShellHelpers.shell?('echo lol').should == 'lol'
+    ShellHelpers.shell?(SUCCEEDING_LS).should be_true
   end
   it "should return false for failed commands" do
-    shell?('false').should be_false
-    shell?(FailingLs).should be_false
+    ShellHelpers.shell?('false').should be_false
+    ShellHelpers.shell?(FAILING_LS).should be_false
   end
 end
 
 describe "shell!" do
   it "should return the output for successful commands" do
-    shell!('echo lol').should == 'lol'
-    shell!(SucceedingLs).should be_true
+    ShellHelpers.shell!('echo lol').should == 'lol'
+    ShellHelpers.shell!(SUCCEEDING_LS).should be_true
   end
   it "should return false for failed commands" do
-    L{ shell!('false') }.should raise_error(Shell::ShellCommandFailed, "Shell command failed: 'false'")
-    L{ shell!(FailingLs) }.should raise_error(Shell::ShellCommandFailed)
+    L{ ShellHelpers.shell!('false') }.should raise_error(Shell::ShellCommandFailed, "Shell command failed: 'false'")
+    L{ ShellHelpers.shell!(FAILING_LS) }.should raise_error(Shell::ShellCommandFailed)
   end
 end
 
 describe "raw_shell" do
   it "should always return a Shell" do
-    raw_shell('true').should be_a(Shell)
-    raw_shell('false').should be_a(Shell)
+    ShellHelpers.raw_shell('true').should be_a(Shell)
+    ShellHelpers.raw_shell('false').should be_a(Shell)
   end
   it "should return stdout for succeeding commands" do
-    shell = raw_shell(SucceedingLs)
+    shell = ShellHelpers.raw_shell(SUCCEEDING_LS)
     shell.stdout.should include("bash")
     shell.stderr.should be_empty
   end
   it "should return stderr for failed commands" do
-    shell = raw_shell(FailingLs)
+    shell = ShellHelpers.raw_shell(FAILING_LS)
     shell.stdout.should be_empty
     shell.stderr.should include("No such file or directory")
   end
   it "should support sudo" do
-    should_receive(:shell).with('whoami', :sudo => true).once
-    raw_shell('whoami', :sudo => true)
+    ShellHelpers.should_receive(:shell).with('whoami', :sudo => true).once
+    ShellHelpers.raw_shell('whoami', :sudo => true)
   end
   it "should handle env vars" do
-    raw_shell({'KEY' => 'value'}, 'echo $KEY').stdout.should == "value\n"
+    ShellHelpers.raw_shell({'KEY' => 'value'}, 'echo $KEY').stdout.should == "value\n"
+  end
+end
+
+describe 'login_shell' do
+  it "should return something true on successful commands" do
+    ShellHelpers.login_shell('true').should_not be_nil
+  end
+  it "should return nil on failed commands" do
+    ShellHelpers.login_shell('false').should be_nil
+  end
+  it "should run as the given user" do
+    ShellHelpers.should_receive(:shell_cmd).with('echo $SHELL', {}).and_return('')
+    ShellHelpers.should_receive(:shell_cmd).with({}, "sudo -u batman bash -l -c 'whoami'", {}).once
+    ShellHelpers.login_shell('whoami', :as => 'batman')
   end
 end
 
 describe 'argument behaviour' do
   context "with a single string" do
     it "should support compound commands" do
-      shell("echo trousers | tr a-z A-Z").should == 'TROUSERS'
+      ShellHelpers.shell("echo trousers | tr a-z A-Z").should == 'TROUSERS'
     end
     it "should fail with unclosed quotes" do
-      shell('echo blah"').should be_nil
+      ShellHelpers.shell('echo blah"').should be_nil
     end
   end
   context "with an array" do
     it "should treat as a command and args" do
-      shell(%w[echo trousers | tr a-z A-Z]).should == 'trousers | tr a-z A-Z'
+      ShellHelpers.shell(%w[echo trousers | tr a-z A-Z]).should == 'trousers | tr a-z A-Z'
     end
     it "should escape unclosed quotes" do
-      shell(['echo', 'blah"']).should == 'blah"'
+      ShellHelpers.shell(['echo', 'blah"']).should == 'blah"'
     end
   end
 end
 
 describe "sudo" do
   it "should reject array input" do
-    L{ sudo(%w[whoami]) }.should raise_error(ArgumentError, "#sudo commands have to be passed as a single string, not splatted strings or an array, since the `sudo` is composed from strings.")
+    L{ ShellHelpers.sudo(%w[whoami]) }.should raise_error(ArgumentError, "#sudo commands have to be passed as a single string, not splatted strings or an array, since the `sudo` is composed from strings.")
   end
   it "should run as root when no user is given" do
-    should_receive(:shell_cmd).with({}, 'sudo -u root whoami', {}).once
-    sudo('whoami')
+    ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo -u root whoami', {}).once
+    ShellHelpers.sudo('whoami')
   end
   it "should run as the given user" do
-    should_receive(:shell_cmd).with({}, 'sudo -u batman whoami', {}).once
-    sudo('whoami', :as => 'batman')
+    ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo -u batman whoami', {}).once
+    ShellHelpers.sudo('whoami', :as => 'batman')
   end
   it "should treat :sudo => 'string' as a username" do
-    should_receive(:shell_cmd).with({}, 'sudo -u batman whoami', {}).once
-    shell('whoami', :sudo => 'batman')
+    ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo -u batman whoami', {}).once
+    ShellHelpers.shell('whoami', :sudo => 'batman')
   end
   it "should sudo from #shell when :as is specified" do
-    should_receive(:shell_cmd).with({}, 'sudo -u root whoami', {}).once
-    shell('whoami', :as => 'root')
+    ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo -u root whoami', {}).once
+    ShellHelpers.shell('whoami', :as => 'root')
   end
   context "when already running as the sudo user" do
     it "should not sudo when the user is already root" do
-      stub!(:current_username).and_return('root')
-      should_receive(:shell_cmd).with({}, 'whoami', {}).once
-      sudo('whoami')
+      ShellHelpers.stub!(:current_username).and_return('root')
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'whoami', {}).once
+      ShellHelpers.sudo('whoami')
     end
     it "should not sudo with :as" do
-      stub!(:current_username).and_return('batman')
-      should_receive(:shell_cmd).with({}, 'whoami', {}).once
-      sudo('whoami', :as => 'batman')
+      ShellHelpers.stub!(:current_username).and_return('batman')
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'whoami', {}).once
+      ShellHelpers.sudo('whoami', :as => 'batman')
     end
     it "should not sudo with a :sudo => 'string' username" do
-      stub!(:current_username).and_return('batman')
-      should_receive(:shell_cmd).with({}, 'whoami', {}).once
-      shell('whoami', :sudo => 'batman')
+      ShellHelpers.stub!(:current_username).and_return('batman')
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'whoami', {}).once
+      ShellHelpers.shell('whoami', :sudo => 'batman')
+    end
+    it "should not sudo with a :sudo => Parameter username" do
+      ShellHelpers.stub!(:current_username).and_return('batman')
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'whoami', {}).once
+      ShellHelpers.shell('whoami', :sudo => Parameter.new('username').default!('batman'))
     end
     it "should not sudo from #shell when :as is specified" do
-      stub!(:current_username).and_return('root')
-      should_receive(:shell_cmd).with({}, 'whoami', {}).once
-      shell('whoami', :as => 'root')
+      ShellHelpers.stub!(:current_username).and_return('root')
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'whoami', {}).once
+      ShellHelpers.shell('whoami', :as => 'root')
     end
     it "should handle env vars properly" do
-      stub!(:current_username).and_return('root')
-      should_receive(:shell_cmd).with({'KEY' => 'value'}, 'echo $KEY', {}).once
-      sudo({'KEY' => 'value'}, 'echo $KEY')
+      ShellHelpers.stub!(:current_username).and_return('root')
+      ShellHelpers.should_receive(:shell_cmd).with({'KEY' => 'value'}, 'echo $KEY', {}).once
+      ShellHelpers.sudo({'KEY' => 'value'}, 'echo $KEY')
     end
   end
   describe "compound commands" do
     it "should use 'sudo su -' when opts[:su] is supplied" do
-      should_receive(:shell_cmd).with({}, 'sudo su - root -c "echo \\`whoami\\`"', {}).once
-      sudo("echo \\`whoami\\`", :su => true)
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo su - root -c "echo \\`whoami\\`"', {}).once
+      ShellHelpers.sudo("echo \\`whoami\\`", :su => true)
     end
     it "should use 'sudo su -' for redirects" do
-      should_receive(:shell_cmd).with({}, 'sudo su - root -c "echo \\`whoami\\` > %s/su_with_redirect"' % tmp_prefix, {}).once
-      sudo("echo \\`whoami\\` > %s/su_with_redirect" % tmp_prefix)
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo su - root -c "echo \\`whoami\\` > %s/su_with_redirect"' % tmp_prefix, {}).once
+      ShellHelpers.sudo("echo \\`whoami\\` > %s/su_with_redirect" % tmp_prefix)
     end
     it "should use 'sudo su -' for pipes" do
-      should_receive(:shell_cmd).with({}, 'sudo su - root -c "echo \\`whoami\\` | tee %s/su_with_pipe"' % tmp_prefix, {}).once
-      sudo("echo \\`whoami\\` | tee %s/su_with_pipe" % tmp_prefix)
+      ShellHelpers.should_receive(:shell_cmd).with({}, 'sudo su - root -c "echo \\`whoami\\` | tee %s/su_with_pipe"' % tmp_prefix, {}).once
+      ShellHelpers.sudo("echo \\`whoami\\` | tee %s/su_with_pipe" % tmp_prefix)
     end
   end
 end
 
 describe "log_shell" do
   it "should log correctly for a successful command" do
-    should_receive(:log).with("Getting uptime...", {:newline=>false}).once
-    should_receive(:shell).with('uptime', {:spinner=>true}).and_return("days and days")
-    should_receive(:log).with(" done.", {:as=>nil, :indentation=>false}).once
-    log_shell 'Getting uptime', 'uptime'
+    LogHelpers.should_receive(:log).with("Getting uptime...", {:newline=>false}).once
+    ShellHelpers.should_receive(:shell).with('uptime', {:spinner=>true}).and_return("days and days")
+    LogHelpers.should_receive(:log).with(" done.", {:as=>nil, :indentation=>false}).once
+    ShellHelpers.log_shell 'Getting uptime', 'uptime'
   end
   it "should log correctly for a failing command" do
-    should_receive(:log).with("Setting sail for fail...", {:newline=>false}).once
-    should_receive(:shell).with('false', {:spinner=>true}).and_return(nil)
-    should_receive(:log).with(" failed", {:as=>:error, :indentation=>false}).once
-    log_shell 'Setting sail for fail', 'false'
+    LogHelpers.should_receive(:log).with("Setting sail for fail...", {:newline=>false}).once
+    ShellHelpers.should_receive(:shell).with('false', {:spinner=>true}).and_return(nil)
+    LogHelpers.should_receive(:log).with(" failed", {:as=>:error, :indentation=>false}).once
+    ShellHelpers.log_shell 'Setting sail for fail', 'false'
   end
   it "should handle env vars" do
-    should_receive(:log).with("Echoing some vars...", {:newline=>false}).once
-    should_receive(:shell).with({'KEY' => 'value'}, 'echo $KEY', {:spinner=>true}).and_return('value')
-    should_receive(:log).with(" done.", {:as=>nil, :indentation=>false}).once
-    log_shell 'Echoing some vars', {'KEY' => 'value'}, 'echo $KEY'
+    LogHelpers.should_receive(:log).with("Echoing some vars...", {:newline=>false}).once
+    ShellHelpers.should_receive(:shell).with({'KEY' => 'value'}, 'echo $KEY', {:spinner=>true}).and_return('value')
+    LogHelpers.should_receive(:log).with(" done.", {:as=>nil, :indentation=>false}).once
+    ShellHelpers.log_shell 'Echoing some vars', {'KEY' => 'value'}, 'echo $KEY'
   end
 end
 
 describe "which" do
   it "should return a string" do
-    which('ls').should be_an_instance_of(String)
+    ShellHelpers.which('ls').should be_an_instance_of(String)
   end
   it "should return the path for valid commands" do
     path = `which ls`.chomp
-    which('ls').should == path
+    ShellHelpers.which('ls').should == path
   end
   it "should return nil for nonexistent commands" do
-    which('nonexistent').should be_nil
+    ShellHelpers.which('missing').should be_nil
   end
   it "should handle command parameter passed as Symbol" do
     path = `which ls`.chomp
-    which(:ls).should == path
+    ShellHelpers.which(:ls).should == path
   end
 end
 
 describe "cmd_dir" do
   it "should return a string" do
-    cmd_dir('ruby').should be_an_instance_of(String)
+    ShellHelpers.cmd_dir('ruby').should be_an_instance_of(String)
   end
   it "should return the cmd_dir of an existing command" do
-    cmd_dir('ruby').should == `which ruby`.chomp.gsub(/\/ruby$/, '')
+    ShellHelpers.cmd_dir('ruby').should == `which ruby`.chomp.gsub(/\/ruby$/, '')
   end
   it "should return nil for nonexistent commands" do
-    cmd_dir('nonexistent').should be_nil
+    ShellHelpers.cmd_dir('missing').should be_nil
   end
 end

data/spec/babushka/shell_spec.rb

@@ -1,4 +1,11 @@
 require 'spec_helper'
+require 'timeout'
+
+describe Shell, "arguments" do
+  it "should reject calls with no arguments, since exec will explode anyway" do
+    L{ Shell.new }.should raise_error(ArgumentError, "wrong number of arguments (0 for 1+)")
+  end
+end
 
 describe Shell, '#ok?' do
   it "should return true on success" do
@@ -17,3 +24,11 @@ describe Shell, '#result' do
     Shell.new('false', {}).run(&:result).should == 1
   end
 end
+
+describe Shell do
+  it "should close stdin, so subprocesses don't wait for input forever" do
+    Timeout::timeout(1) do
+      Shell.new('cat', {}).run(&:result).should == 0
+    end
+  end
+end

data/spec/babushka/source_pool_spec.rb

@@ -1,248 +1,244 @@
 require 'spec_helper'
 require 'source_support'
-require 'source_pool_support'
 
-describe SourcePool, '#source_for' do
-  before {
-    @source1 = Source.new nil, :name => 'source_1'
-    @source1.stub!(:load!)
-    @source2 = Source.new nil, :name => 'source_2'
-    @source2.stub!(:load!)
-    Base.sources.stub!(:current).and_return([@source1])
-    Source.stub!(:present).and_return([@source2])
-  }
-  it "should find core sources" do
-    Base.sources.source_for('source_1').should == @source1
-  end
-  it "should find cloned sources" do
-    Base.sources.source_for('source_2').should == @source2
+describe SourcePool do
+  def define_in source
+    Base.sources.load_context :source => source do
+      yield
+    end
   end
-end
 
-describe Dep, '#dep_for, disregarding sources' do
+  let(:source1) { Source.new(nil, :name => 'source_1').tap {|s| s.stub!(:load!) } }
+  let(:source2) { Source.new(nil, :name => 'source_2').tap {|s| s.stub!(:load!) } }
+  let!(:anonymous_meta) { define_in(Base.sources.anonymous) { meta 'anonymous_meta' } }
+  let!(:core_meta) { define_in(Base.sources.core) { meta 'core_meta' } }
+  let!(:core_from) { define_in(Base.sources.core) { meta 'core_from' } }
+  let!(:meta1) { define_in(source1) { meta :meta_1 } }
+  let!(:meta2) { define_in(source1) { meta 'meta_2' } }
+  let!(:meta3) { define_in(source2) { meta :meta_3 } }
+  let!(:meta4) { define_in(source2) { meta 'meta_4' } }
+  let!(:from1) { define_in(source1) { meta 'from_test' } }
+  let!(:from2) { define_in(source2) { meta 'from_test' } }
+  let!(:from2_2) { define_in(source2) { meta 'from_test_2' } }
+
   before {
-    @dep = dep 'Base.sources.dep_for tests'
+    [Base.sources.anonymous, Base.sources.core, source1, source2].each {|s| s.stub!(:load!) }
+    Source.stub!(:present).and_return [source1, source2]
   }
-  it "should work for strings" do
-    Base.sources.dep_for('Base.sources.dep_for tests').should == @dep
-  end
-  it "should work for deps" do
-    Base.sources.dep_for(@dep).should == @dep
-  end
-  it "should not find the dep with namespacing" do
-    Base.sources.dep_for('namespaced:namespaced Base.sources.dep_for tests').should be_nil
-  end
-  context "with namespaced dep defined" do
+
+  describe SourcePool, '#source_for' do
     before {
-      @source = Source.new(nil, :name => 'namespaced')
-      Source.stub!(:present).and_return([@source])
-      Base.sources.load_context :source => @source do
-        @namespaced_dep = dep 'Base.sources.dep_for tests'
-      end
+      Base.sources.stub!(:current).and_return([source1])
+      Source.stub!(:present).and_return([source2])
     }
-    it "should work with namespacing" do
-      Base.sources.dep_for('namespaced:Base.sources.dep_for tests').should == @namespaced_dep
-    end
-  end
-end
-
-describe SourcePool, '#dep_for' do
-  before {
-    @source1 = Source.new nil, :name => 'source_1'
-    @source1.stub!(:load!)
-    @source2 = Source.new nil, :name => 'source_2'
-    @source2.stub!(:load!)
-    Base.sources.load_context :source => @source1 do
-      @dep1 = dep 'dep 1'
-      @dep2 = dep 'dep 2'
-    end
-    Base.sources.load_context :source => @source2 do
-      @dep3 = dep 'dep 3'
-      @dep4 = dep 'dep 4'
+    it "should find core sources" do
+      Base.sources.source_for('source_1').should == source1
     end
-    Base.sources.stub!(:current).and_return([@source1, @source2])
-    Source.stub!(:present).and_return([@source1, @source2])
-  }
-  it "should look up the correct deps without namespacing" do
-    Base.sources.dep_for('dep 1').should == @dep1
-    Base.sources.dep_for('dep 4').should == @dep4
-  end
-  it "should find the dep when the namespace is correct" do
-    Base.sources.dep_for('source_1:dep 1').should == @dep1
-    Base.sources.dep_for('source_2:dep 4').should == @dep4
-  end
-  it "should not find the dep when the namespace is wrong" do
-    Base.sources.dep_for('source_1:dep 3').should be_nil
-    Base.sources.dep_for('source_2:dep 2').should be_nil
-  end
-end
-
-describe SourcePool, '#dep_for core' do
-  before {
-    @core = Source.new nil, :name => 'core'
-    @core.stub!(:load!)
-    Base.sources.load_context :source => @core do
-      @dep1 = dep 'dep 1'
-      @dep2 = dep 'dep 2'
+    it "should find cloned sources" do
+      Base.sources.source_for('source_2').should == source2
     end
-    Base.sources.stub!(:current).and_return([@core])
-  }
-  it "should find the correct deps without namespacing" do
-    Base.sources.dep_for('dep 1').should == @dep1
-    Base.sources.dep_for('dep 4').should == @dep4
   end
-  it "should find the dep when the namespace is correct" do
-    Base.sources.dep_for('core:dep 1').should == @dep1
-  end
-  it "should not find the dep when the namespace is wrong" do
-    Base.sources.dep_for('non_core:dep 1').should be_nil
-  end
-end
 
-describe SourcePool, '#template_for' do
-  before {
-    mock_sources
-  }
-  context "without namespacing" do
-    it "should find templates in the anonymous source" do
-      Base.sources.template_for('anonymous_meta').should == @anonymous_meta
+  describe Dep, '#dep_for, disregarding sources' do
+    let!(:the_dep) { dep 'Base.sources.dep_for tests' }
+    it "should work for strings" do
+      Base.sources.dep_for('Base.sources.dep_for tests').should == the_dep
     end
-    it "should find templates in the core source" do
-      Base.sources.template_for('core_meta').should == @core_meta
+    it "should work for deps" do
+      Base.sources.dep_for(the_dep).should == the_dep
     end
-    it "should not find templates from non-default sources" do
-      Base.sources.template_for('meta_1').should be_nil
-      Base.sources.template_for('meta_3').should be_nil
+    it "should not find the dep with namespacing" do
+      GitHelpers.stub!(:git) # To avoid cloning.
+      Base.sources.dep_for('namespaced:Base.sources.dep_for tests').should be_nil
     end
-    context "with :from" do
-      it "should find the template in the same source" do
-        Base.sources.template_for('from_test', :from => @source1).should == @from1
-        Base.sources.template_for('from_test', :from => @source2).should == @from2
-      end
-      context "when it doesn't exist in the :from source" do
-        it "should find the template in the core source" do
-          Base.sources.template_for('core_from', :from => @source1).should == @core_from
-        end
-        it "should not find the template in other sources" do
-          Base.sources.template_for('from_test_2', :from => @source1).should be_nil
-          Base.sources.template_for('from_test_2', :from => @source2).should_not be_nil
-        end
+    context "with namespaced dep defined" do
+      let(:source) { Source.new(nil, :name => 'namespaced') }
+      let!(:namespaced_dep) {
+        define_in(source) { dep 'Base.sources.dep_for tests' }
+      }
+      before {
+        Source.stub!(:present).and_return([source])
+      }
+      it "should find the dep" do
+        Base.sources.dep_for('namespaced:Base.sources.dep_for tests').should == namespaced_dep
       end
     end
   end
-  context "with namespacing" do
+
+  describe SourcePool, '#dep_for' do
+    let!(:dep1) { define_in(source1) { dep 'dep 1' } }
+    let!(:dep2) { define_in(source1) { dep 'dep 2' } }
+    let!(:dep3) { define_in(source2) { dep 'dep 3' } }
+    let!(:dep4) { define_in(source2) { dep 'dep 4' } }
+    before {
+      Base.sources.stub!(:current).and_return([source1, source2])
+      Source.stub!(:present).and_return([source1, source2])
+    }
+    it "should look up the correct deps without namespacing" do
+      Base.sources.dep_for('dep 1').should == dep1
+      Base.sources.dep_for('dep 4').should == dep4
+    end
     it "should find the dep when the namespace is correct" do
-      Base.sources.template_for('source_1:meta_1').should == @meta1
-      Base.sources.template_for('source_2:meta_4').should == @meta4
+      Base.sources.dep_for('source_1:dep 1').should == dep1
+      Base.sources.dep_for('source_2:dep 4').should == dep4
     end
     it "should not find the dep when the namespace is wrong" do
-      Base.sources.template_for('source_1:').should be_nil
-      Base.sources.template_for('source_2:meta 2').should be_nil
+      Base.sources.dep_for('source_1:dep 3').should be_nil
+      Base.sources.dep_for('source_2:dep 2').should be_nil
     end
   end
-  after {
-    Base.sources.anonymous.templates.clear!
-    Base.sources.core.templates.clear!
-  }
-end
 
-describe SourcePool, '#load_context' do
-  context "without a template" do
+  describe SourcePool, '#dep_for core' do
+    let(:core) { Source.new(nil, :name => 'core').tap {|s| s.stub!(:load!) } }
+    let!(:dep1) { define_in(core) { dep 'dep 1' } }
     before {
-      Dep.should_receive(:new).with('load_context', Base.sources.anonymous, [], {}, nil)
+      Base.sources.stub!(:current).and_return([core])
     }
-    it "should pass the correct options" do
-      dep 'load_context'
+    it "should find the correct deps without namespacing" do
+      Base.sources.dep_for('dep 1').should == dep1
+    end
+    it "should find the dep when the namespace is correct" do
+      Base.sources.dep_for('core:dep 1').should == dep1
+    end
+    it "should not find the dep when the namespace is wrong" do
+      GitHelpers.stub!(:git) # To avoid cloning.
+      Base.sources.dep_for('non_core:dep 1').should be_nil
     end
   end
-  context "with a template" do
-    let(:source) {
-      Source.new *make_source_remote('load_context')
-    }
-    let!(:template) {
-      Base.sources.load_context :source => source do
-        meta 'load_context_template'
+
+  describe SourcePool, '#load_context' do
+    context "without a template" do
+      before {
+        Dep.should_receive(:new).with('load_context', Base.sources.anonymous, [], {}, nil)
+      }
+      it "should pass the correct options" do
+        dep 'load_context'
       end
-    }
-    let!(:the_dep) {
-      Base.sources.load_context :source => source do
-        dep 'defining test with template.load_context_template'
+    end
+    context "with a template" do
+      let(:source) { Source.new(nil) }
+      let!(:template) {
+        Base.sources.load_context :source => source do
+          meta 'load_context_template'
+        end
+      }
+      let!(:the_dep) {
+        Base.sources.load_context :source => source do
+          dep 'defining test with template.load_context_template'
+        end
+      }
+      it "should use the template" do
+        the_dep.template.should == template
       end
-    }
-    it "should use the template" do
-      the_dep.template.should == template
+      after {
+        source.remove!
+      }
     end
-    after {
-      source.remove!
-    }
-  end
-  context "with nesting" do
-    before {
-      @source1, @source2 = Source.new(nil), Source.new(nil)
-    }
-    it "should maintain the outer context after the inner one returns" do
-      Base.sources.load_context :source => @source1 do
-        Base.sources.current_load_source.should == @source1
-        Base.sources.load_context :source => @source2 do
-          Base.sources.current_load_source.should == @source2
+    context "with nesting" do
+      it "should maintain the outer context after the inner one returns" do
+        Base.sources.load_context :source => source1 do
+          Base.sources.current_load_source.should == source1
+          Base.sources.load_context :source => source2 do
+            Base.sources.current_load_source.should == source2
+          end
+          Base.sources.current_load_source.should == source1
         end
-        Base.sources.current_load_source.should == @source1
       end
     end
   end
-end
 
-describe "template selection during defining" do
-  before {
-    mock_sources
-  }
-  context "with namespacing" do
-    it "should use templates from the named source" do
-      dep('template selection 1', :template => 'source_1:meta_1').template.should == @meta1
+  describe SourcePool, '#template_for' do
+
+    context "without namespacing" do
+      it "should find templates in the anonymous source" do
+        Base.sources.template_for('anonymous_meta').should == anonymous_meta
+      end
+      it "should find templates in the core source" do
+        Base.sources.template_for('core_meta').should == core_meta
+      end
+      it "should not find templates from non-default sources" do
+        Base.sources.template_for('meta_1').should be_nil
+        Base.sources.template_for('meta_3').should be_nil
+      end
+      context "with :from" do
+        it "should find the template in the same source" do
+          Base.sources.template_for('from_test', :from => source1).should == from1
+          Base.sources.template_for('from_test', :from => source2).should == from2
+        end
+        context "when it doesn't exist in the :from source" do
+          it "should find the template in the core source" do
+            Base.sources.template_for('core_from', :from => source1).should == core_from
+          end
+          it "should not find the template in other sources" do
+            Base.sources.template_for('from_test_2', :from => source1).should be_nil
+            Base.sources.template_for('from_test_2', :from => source2).should_not be_nil
+          end
+        end
+      end
     end
-    it "should not find the template with the wrong source prefix, and raise" do
-      L{
-        dep('template selection 2', :template => 'source_2:meta_1')
-      }.should raise_error(TemplateNotFound, "There is no template named 'source_2:meta_1' to define 'template selection 2' against.")
+
+    context "with namespacing" do
+      it "should find the dep when the namespace is correct" do
+        Base.sources.template_for('source_1:meta_1').should == meta1
+        Base.sources.template_for('source_2:meta_4').should == meta4
+      end
+      it "should not find the dep when the namespace is wrong" do
+        Base.sources.template_for('source_1:').should be_nil
+        Base.sources.template_for('source_2:meta 2').should be_nil
+      end
     end
   end
-  context "without namespacing" do
-    context "with :template option" do
-      it "should find a template in the same source" do
-        mock_dep('template selection 3', :template => 'meta_1', :in => @source1).template.should == @meta1
+
+  describe "template selection during defining" do
+    context "with namespacing" do
+      it "should use templates from the named source" do
+        dep('template selection 1', :template => 'source_1:meta_1').template.should == meta1
       end
-      it "should not find a template in the wrong source, and raise" do
+      it "should not find the template with the wrong source prefix, and raise" do
         L{
-          mock_dep('template selection 4', :template => 'meta_3', :in => @source1).template
-        }.should raise_error(TemplateNotFound, "There is no template named 'meta_3' to define 'template selection 4' against.")
+          dep('template selection 2', :template => 'source_2:meta_1').template
+        }.should raise_error(TemplateNotFound, "There is no template named 'source_2:meta_1' to define 'template selection 2' against.")
       end
     end
-    context "with suffixes" do
-      it "should find a template in the same source" do
-        mock_dep('template selection 3.meta_1', :in => @source1).template.should == @meta1
-      end
-      it "should find a template in the core source" do
-        mock_dep('template selection 3.core_meta', :in => @source1).template.should == @core_meta
+    context "without namespacing" do
+      context "with :template option" do
+        it "should find a template in the same source" do
+          define_in(source1) { dep 'template selection 3', :template => 'meta_1' }.template.should == meta1
+        end
+        it "should not find a template in the wrong source, and raise" do
+          L{
+            define_in(source1) { dep 'template selection 4', :template => 'meta_3' }.template
+          }.should raise_error(TemplateNotFound, "There is no template named 'meta_3' to define 'template selection 4' against.")
+        end
       end
-      it "should not find a template in the wrong source, and use the base template" do
-        mock_dep('template selection 4.meta_3', :in => @source1).template.should == Dep::BaseTemplate
+      context "with suffixes" do
+        it "should find a template in the same source" do
+          define_in(source1) { dep 'template selection 3.meta_1' }.template.should == meta1
+        end
+        it "should find a template in the core source" do
+          define_in(source1) { dep 'template selection 3.core_meta' }.template.should == core_meta
+        end
+        it "should not find a template in the wrong source, and use the base template" do
+          define_in(source1) { dep 'template selection 4.meta_3' }.template.should == Dep::BaseTemplate
+        end
       end
     end
   end
+
   after {
     Base.sources.anonymous.templates.clear!
     Base.sources.core.templates.clear!
   }
 end
 
+
 describe "template selection during defining from a real source" do
+  let(:source) { Source.new('spec/deps/good', :name => 'good source').tap(&:load!) }
   before {
-    @source = Source.new('spec/deps/good', :name => 'good source')
-    @source.load!
-    Source.stub!(:present).and_return([@source])
+    Source.stub!(:present).and_return([source])
   }
   it "should have loaded deps" do
-    @source.deps.names.should =~ [
+    source.deps.names.should =~ [
       'test dep 1',
       'test dep 2',
       'option-templated dep',
@@ -250,29 +246,27 @@ describe "template selection during defining from a real source" do
     ]
   end
   it "should have loaded templates" do
-    @source.templates.names.should =~ [
+    source.templates.names.should =~ [
       'test_template',
       'test_meta_1'
     ]
   end
   it "should have defined deps against the correct template" do
-    @source.find('test dep 1').template.should == Dep::BaseTemplate
-    @source.find('test dep 2').template.should == Dep::BaseTemplate
-    @source.find('option-templated dep').template.should == @source.find_template('test_template')
-    @source.find('suffix-templated dep.test_template').template.should == @source.find_template('test_template')
+    source.find('test dep 1').template.should == Dep::BaseTemplate
+    source.find('test dep 2').template.should == Dep::BaseTemplate
+    source.find('option-templated dep').template.should == source.find_template('test_template')
+    source.find('suffix-templated dep.test_template').template.should == source.find_template('test_template')
   end
 end
 
 describe "nested source loads" do
+  let(:outer_source) { Source.new('spec/deps/outer', :name => 'outer source').tap(&:load!) }
+  let(:nested_source) { Source.new('spec/deps/good', :name => 'nested source') }
   before {
-    @outer_source = Source.new('spec/deps/outer', :name => 'outer source')
-    @nested_source = Source.new('spec/deps/good', :name => 'nested source')
-
-    Source.stub!(:present).and_return([@outer_source, @nested_source])
-    @outer_source.load!
+    Source.stub!(:present).and_return([outer_source, nested_source])
   }
   it "should have loaded outer deps" do
-    @outer_source.deps.names.should =~ [
+    outer_source.deps.names.should =~ [
       'test dep 1',
       'externally templated',
       'locally templated',
@@ -280,21 +274,21 @@ describe "nested source loads" do
       'separate file',
       'separate file.another_local_template'
     ]
-    @nested_source.deps.names.should == []
+    nested_source.deps.names.should == []
   end
   it "should have loaded outer templates" do
-    @outer_source.templates.names.should =~ [
+    outer_source.templates.names.should =~ [
       'local_template',
       'another_local_template'
     ]
-    @nested_source.templates.names.should == []
+    nested_source.templates.names.should == []
   end
   context "after defining external deps" do
     before {
-      @outer_source.find('externally templated').context
+      outer_source.find('externally templated').context
     }
     it "should have loaded the nested deps" do
-      @nested_source.deps.names.should =~ [
+      nested_source.deps.names.should =~ [
         'test dep 1',
         'test dep 2',
         'option-templated dep',
@@ -302,7 +296,7 @@ describe "nested source loads" do
       ]
     end
     it "should have loaded the nested templates" do
-      @nested_source.templates.names.should =~ [
+      nested_source.templates.names.should =~ [
         'test_template',
         'test_meta_1'
       ]
@@ -310,11 +304,11 @@ describe "nested source loads" do
   end
 
   it "should have defined deps against the correct template" do
-    @outer_source.find('test dep 1').template.should == Dep::BaseTemplate
-    @outer_source.find('externally templated').template.should == @nested_source.find_template('test_template')
-    @outer_source.find('locally templated').template.should == @outer_source.find_template('local_template')
-    @outer_source.find('locally templated.local_template').template.should == @outer_source.find_template('local_template')
-    @outer_source.find('separate file').template.should == @outer_source.find_template('another_local_template')
-    @outer_source.find('separate file.another_local_template').template.should == @outer_source.find_template('another_local_template')
+    outer_source.find('test dep 1').template.should == Dep::BaseTemplate
+    outer_source.find('externally templated').template.should == nested_source.find_template('test_template')
+    outer_source.find('locally templated').template.should == outer_source.find_template('local_template')
+    outer_source.find('locally templated.local_template').template.should == outer_source.find_template('local_template')
+    outer_source.find('separate file').template.should == outer_source.find_template('another_local_template')
+    outer_source.find('separate file.another_local_template').template.should == outer_source.find_template('another_local_template')
   end
 end