rubycut-babushka 0.10.6

data/spec/babushka/run_helpers_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class RunTester; extend RunHelpers end
+
+describe "grep" do
+  it "should grep existing files" do
+    RunTester.grep('include', 'spec/spec_helper.rb').should include("include Babushka\n")
+  end
+  it "should return nil when there are no matches" do
+    RunTester.grep('lol', 'spec/spec_helper.rb').should be_nil
+  end
+  it "should return nil for nonexistent files" do
+    RunTester.grep('lol', '/nonexistent').should be_nil
+  end
+end
+
+describe "change_line" do
+  path = "#{tmp_prefix}/babushka_run_helper_change_line"
+  it "should not mangle a file" do
+    File.open(path, "w") { |f| f.write "one\ntwo\nthree\n" }
+    RunTester.change_line("two", "changed", path)
+    lines = File.open(path, "r") { |f| f.readlines.map{ |l| l.chomp } }
+    lines.values_at(0,3,4).should == ["one", "changed", "three"]
+    lines.length.should == 5 # two comments added
+  end
+end

data/spec/babushka/shell_helpers_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+SucceedingLs = 'ls /bin'
+FailingLs = 'ls /nonexistent'
+
+describe "shell" do
+  it "should return something true on successful commands" do
+    shell('true').should_not be_nil
+  end
+  it "should return nil on failed commands" do
+    shell('false').should be_nil
+  end
+  it "should return output of successful commands" do
+    shell('echo lol').should == 'lol'
+  end
+  it "should accept multiline commands" do
+    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"
+  end
+  it "should provide the shell to supplied blocks when the command succeeds" do
+    (the_block = "").should_receive(:was_called)
+    shell(SucceedingLs) {|shell|
+      the_block.was_called
+      shell.stdout.should include('bash')
+      shell.stderr.should be_empty
+    }
+  end
+  it "should provide the shell to supplied blocks when the command fails" do
+    (the_block = "").should_receive(:was_called)
+    shell(FailingLs) {|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"
+  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
+    end
+    it "should run in the specified directory" do
+      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']
+    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'}")
+    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
+      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
+      end
+    end
+  end
+end
+
+describe "shell?" do
+  it "should return the output for successful commands" do
+    shell?('echo lol').should == 'lol'
+    shell?(SucceedingLs).should be_true
+  end
+  it "should return false for failed commands" do
+    shell?('false').should be_false
+    shell?(FailingLs).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
+  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)
+  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)
+  end
+  it "should return stdout for succeeding commands" do
+    shell = raw_shell(SucceedingLs)
+    shell.stdout.should include("bash")
+    shell.stderr.should be_empty
+  end
+  it "should return stderr for failed commands" do
+    shell = raw_shell(FailingLs)
+    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)
+  end
+  it "should handle env vars" do
+    raw_shell({'KEY' => 'value'}, 'echo $KEY').stdout.should == "value\n"
+  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'
+    end
+    it "should fail with unclosed quotes" do
+      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'
+    end
+    it "should escape unclosed quotes" do
+      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.")
+  end
+  it "should run as root when no user is given" do
+    should_receive(:shell_cmd).with({}, 'sudo -u root whoami', {}).once
+    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')
+  end
+  it "should treat :sudo => 'string' as a username" do
+    should_receive(:shell_cmd).with({}, 'sudo -u batman whoami', {}).once
+    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')
+  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')
+    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')
+    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')
+    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')
+    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')
+    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)
+    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)
+    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)
+    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'
+  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'
+  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'
+  end
+end
+
+describe "which" do
+  it "should return a string" do
+    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
+  end
+  it "should return nil for nonexistent commands" do
+    which('nonexistent').should be_nil
+  end
+  it "should handle command parameter passed as Symbol" do
+    path = `which ls`.chomp
+    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)
+  end
+  it "should return the cmd_dir of an existing command" do
+    cmd_dir('ruby').should == `which ruby`.chomp.gsub(/\/ruby$/, '')
+  end
+  it "should return nil for nonexistent commands" do
+    cmd_dir('nonexistent').should be_nil
+  end
+end

data/spec/babushka/shell_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Shell, '#ok?' do
+  it "should return true on success" do
+    Shell.new('true', {}).run(&:ok?).should be_true
+  end
+  it "should return false on failure" do
+    Shell.new('false', {}).run(&:ok?).should be_false
+  end
+end
+
+describe Shell, '#result' do
+  it "should return zero on success" do
+    Shell.new('true', {}).run(&:result).should == 0
+  end
+  it "should return non-zero on failure" do
+    Shell.new('false', {}).run(&:result).should == 1
+  end
+end

data/spec/babushka/source_pool_spec.rb

@@ -0,0 +1,320 @@
+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
+  end
+end
+
+describe Dep, '#dep_for, disregarding sources' do
+  before {
+    @dep = dep 'Base.sources.dep_for tests'
+  }
+  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
+    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
+    }
+    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'
+    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'
+    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
+    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
+  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
+  after {
+    Base.sources.anonymous.templates.clear!
+    Base.sources.core.templates.clear!
+  }
+end
+
+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
+  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'
+      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
+    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
+        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
+    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.")
+    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
+      end
+      it "should not find a template in the wrong source, 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.")
+      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
+      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
+      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
+  before {
+    @source = Source.new('spec/deps/good', :name => 'good source')
+    @source.load!
+    Source.stub!(:present).and_return([@source])
+  }
+  it "should have loaded deps" do
+    @source.deps.names.should =~ [
+      'test dep 1',
+      'test dep 2',
+      'option-templated dep',
+      'suffix-templated dep.test_template'
+    ]
+  end
+  it "should have loaded templates" do
+    @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')
+  end
+end
+
+describe "nested source loads" do
+  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!
+  }
+  it "should have loaded outer deps" do
+    @outer_source.deps.names.should =~ [
+      'test dep 1',
+      'externally templated',
+      'locally templated',
+      'locally templated.local_template',
+      'separate file',
+      'separate file.another_local_template'
+    ]
+    @nested_source.deps.names.should == []
+  end
+  it "should have loaded outer templates" do
+    @outer_source.templates.names.should =~ [
+      'local_template',
+      'another_local_template'
+    ]
+    @nested_source.templates.names.should == []
+  end
+  context "after defining external deps" do
+    before {
+      @outer_source.find('externally templated').context
+    }
+    it "should have loaded the nested deps" do
+      @nested_source.deps.names.should =~ [
+        'test dep 1',
+        'test dep 2',
+        'option-templated dep',
+        'suffix-templated dep.test_template'
+      ]
+    end
+    it "should have loaded the nested templates" do
+      @nested_source.templates.names.should =~ [
+        'test_template',
+        'test_meta_1'
+      ]
+    end
+  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')
+  end
+end