wesabe-robot-army 0.1.1 → 0.1.7

data/spec/at_exit_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::AtExit do
+  before do
+    @at_exit = RobotArmy::AtExit.shared_instance
+  end
+
+  it "runs the provided block when directed" do
+    foo = 'foo'
+    @at_exit.at_exit { foo = 'bar' }
+    foo.must == 'foo'
+    @at_exit.do_exit
+    foo.must == 'bar'
+  end
+
+  it "does not run the same block twice" do
+    foo = 0
+    @at_exit.at_exit { foo += 1 }
+    foo.must == 0
+    @at_exit.do_exit
+    foo.must == 1
+    @at_exit.do_exit
+    foo.must == 1
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Connection do
+  before do
+    # given
+    @host = 'example.com'
+    @connection = RobotArmy::Connection.new(@host)
+    @messenger  = mock(:messenger)
+    @messenger.stub!(:post)
+    @connection.stub!(:messenger).and_return(@messenger)
+    @connection.stub!(:start_child)
+  end
+  
+  it "is not closed after opening" do
+    # when
+    @connection.open
+    
+    # then
+    @connection.must_not be_closed
+  end
+  
+  it "returns itself from open" do
+    @connection.open.must == @connection
+  end
+  
+  it "returns the result of the block passed to open" do
+    # when
+    @connection.stub!(:close)
+    
+    # then
+    @connection.open{ 3 }.must == 3
+  end
+  
+  it "closes the connection if a block is passed to open" do
+    # then
+    proc{ @connection.open{ 3 } }.
+      must_not change(@connection, :closed?).from(true)
+  end
+  
+  it "closes the connection even if an exception is raised in the block passed to open" do
+    # then
+    proc do
+      proc{ @connection.open{ raise 'BOO!' } }.
+        must_not change(@connection, :closed?).from(true)
+    end.
+      must raise_error('BOO!')
+  end
+  
+  it "does not start another child process if we're already open" do
+    # then
+    @connection.should_not_receive(:start_child)
+    
+    # when
+    @connection.stub!(:closed?).and_return(false)
+    @connection.open
+  end
+  
+  it "raises an exception when calling close if a connection is already closed" do
+    # when
+    @connection.stub!(:closed?).and_return(true)
+    
+    # then
+    proc{ @connection.close }.must raise_error(RobotArmy::ConnectionNotOpen)
+  end
+  
+  it "sends an exit command to its child upon closing" do
+    # then
+    @messenger.should_receive(:post).with(:command => :exit)
+    
+    # when
+    @connection.stub!(:closed?).and_return(false)
+    @connection.close
+  end
+  
+  it "starts a closed local connection when calling localhost" do
+    RobotArmy::Connection.localhost.must be_closed
+  end
+  
+  it "raises a Warning when handling a message with status=warning" do
+    proc{ @connection.handle_response(:status => 'warning', :data => 'foobar') }.
+      must raise_error(RobotArmy::Warning)
+  end
+end
+
+describe RobotArmy::Connection, 'answer_sudo_prompt' do
+  before do
+    @connection = RobotArmy::Connection.new(:localhost, 'root')
+    @password_proc = proc { 'password' }
+    @stdin = StringIO.new
+    @stderr = stub(:stderr, :readpartial => nil)
+  end
+  
+  it "calls back using the password proc if it is a proc" do
+    # when
+    @connection.stub!(:password).and_return(@password_proc)
+    @connection.stub!(:asking_for_password?).and_return(true, false)
+    @connection.answer_sudo_prompt(@stdin, @stderr)
+    
+    # then
+    @stdin.string.must == "password\n"
+  end
+  
+  it "raises if password is a string and is rejected" do
+    # when
+    @connection.stub!(:password).and_return('password')
+    @connection.stub!(:asking_for_password?).and_return(true)
+    
+    # then
+    proc { @connection.answer_sudo_prompt(@stdin, @stderr) }.
+      must raise_error(RobotArmy::InvalidPassword)
+  end
+  
+  it "calls back three times before raising if password is a proc" do
+    calls = 0
+    
+    # when
+    @connection.stub!(:password).and_return(proc{ calls += 1 })
+    
+    # then
+    @connection.should_receive(:asking_for_password?).
+      exactly(4).times.and_return(true)
+    proc { @connection.answer_sudo_prompt(@stdin, @stderr) }.
+      must raise_error(RobotArmy::InvalidPassword)
+    calls.must == 3
+  end
+end

data/spec/dependency_loader_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::DependencyLoader do
+  before do
+    @loader = RobotArmy::DependencyLoader.new
+  end
+  
+  it "should have no dependencies by default" do
+    @loader.dependencies.must == []
+  end
+  
+  it "should store the dependency requirement by name" do
+    name = "RedCloth"
+    @loader.add_dependency name
+    @loader.dependencies.must == [[name]]
+  end
+  
+  it "should store the dependency requirement with version restriction" do
+    name = "RedCloth"
+    version_str = "> 3.1.0"
+    @loader.add_dependency name, version_str
+    @loader.dependencies.must == [[name, version_str]]
+  end
+  
+  it "should gem load a dependency by name only" do
+    name = "foobarbaz"
+    @loader.add_dependency name
+    @loader.should_receive(:gem).with(name)
+    @loader.load!
+  end
+  
+  it "should gem load a dependency by name and version" do
+    name = "foobarbaz"
+    version = "> 3.1"
+    @loader.add_dependency name, version
+    @loader.should_receive(:gem).with(name, version)
+    @loader.load!
+  end
+  
+  
+  it "should raise when a dependency is not met" do
+    @loader.add_dependency "foobarbaz"
+    @loader.should_receive(:gem).and_raise Gem::LoadError
+    lambda { @loader.load! }.must raise_error(RobotArmy::DependencyError)
+  end
+end

data/spec/gate_keeper_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::GateKeeper do
+  before do
+    # given
+    @keeper = RobotArmy::GateKeeper.new
+    @host = 'example.com'
+    @connection = mock(:connection)
+    @connection.stub!(:closed?).and_return(false)
+  end
+  
+  it "establishes a new connection to a host if one does not already exist" do
+    # then
+    @keeper.should_receive(:establish_connection).with(@host)
+    
+    # when
+    @keeper.stub!(:get_connection).and_return(nil)
+    @keeper.connect(@host)
+  end
+  
+  it "terminates all connections on close" do
+    # then
+    @connection.should_receive(:close)
+    
+    # when
+    @keeper.stub!(:connections).and_return(@host => @connection)
+    @keeper.close
+  end
+  
+  it "creates a new Connection with the given host when establish_connection is called" do
+    # then
+    RobotArmy::OfficerConnection.should_receive(:new).with(@host).and_return(@connection)
+    @connection.should_receive(:open).and_return(@connection)
+    
+    # when
+    @keeper.establish_connection(@host)
+    
+    # and
+    @keeper.connections[@host].must == @connection
+  end
+  
+  it "has a shared instance that doesn't change" do
+    RobotArmy::GateKeeper.shared_instance.must be_an_instance_of(RobotArmy::GateKeeper)
+    RobotArmy::GateKeeper.shared_instance.must == RobotArmy::GateKeeper.shared_instance
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+# THIS SPEC IS INTENDED TO BE RUN BY ITSELF:
+#
+#   env SUDO_AS=brad INTEGRATION_HOST=example.com spec spec/integration_spec.rb --format=specdoc --color
+#
+
+if $INTEGRATION_HOST = ENV['INTEGRATION_HOST']
+  $TESTING = false
+  $ROBOT_ARMY_DEBUG = true
+
+  class Integration < RobotArmy::TaskMaster
+    host $INTEGRATION_HOST
+  end
+
+  describe Integration do
+    before do
+      @tm = Integration.new
+    end
+
+    it "can do sudo" do
+      @tm.sudo { Time.now }.must be_a(Time)
+    end
+
+    it "does sudo as root by default" do
+      @tm.sudo { Process.uid }.must == 0
+    end
+
+    it "can do sudo as ourselves" do
+      my_remote_uid = @tm.remote { Process.uid }
+      @tm.sudo(:user => ENV['USER']) { Process.uid }.must == my_remote_uid
+    end
+
+    if sudo_user = ENV['SUDO_AS']
+      it "can sudo as another non-root user" do
+        @tm.sudo(:user => sudo_user) { ENV['USER'] }.must == sudo_user
+      end
+    end
+  end
+end

data/spec/io_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::IO, 'class method read_data' do
+  before do
+    @stream = stub(:stream)
+  end
+  
+  it "reads all data as long as it is available" do
+    RobotArmy::IO.stub!(:has_data?).and_return(true, true, false)
+    @stream.stub!(:readpartial).and_return('foo', 'bar')
+    
+    RobotArmy::IO.read_data(@stream).must == "foobar"
+  end
+end
+
+describe RobotArmy::IO do
+  before do
+    @stream = RobotArmy::IO.new(:stdout)
+    @upstream = RobotArmy.upstream = stub(:upstream)
+  end
+  
+  it "can capture output of IO method calls" do
+    @stream.send(:capture, :print, 'foo').must == 'foo'
+  end
+  
+  it "proxies output upstream" do
+    @upstream.should_receive(:post).
+      with(:status => 'output', :data => {:stream => 'stdout', :string => "foo\n"})
+    
+    @stream.puts 'foo'
+  end
+  
+  after do
+    @stream.stop_capture
+  end
+end

data/spec/keychain_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Keychain do
+  before do
+    @keychain = RobotArmy::Keychain.new
+  end
+
+  it "asks for all passwords over stdin" do
+    @keychain.
+      should_receive(:read_with_prompt).
+      with("[sudo] password for bob@example.com: ").
+      and_return("god")
+    @keychain.get_password_for_user_on_host('bob', 'example.com').must == 'god'
+  end
+end

data/spec/loader_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Loader do
+  before do
+    @loader = RobotArmy::Loader.new
+    @messenger = @loader.messenger = mock(:messenger)
+    @messenger.stub!(:post)
+  end
+  
+  it "doesn't catch the RobotArmy::Exit exception" do
+    proc{ @loader.safely{ raise RobotArmy::Exit } }.must raise_error(RobotArmy::Exit)
+  end
+end

data/spec/marshal_ext_spec.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class CannotMarshalMe
+  def marshalable?
+    false
+  end
+end
+
+class CustomContainer
+  def initialize(child)
+    @child = child
+  end
+end
+
+describe Marshal do
+  it "can dump Fixnums" do
+    42.must be_marshalable
+  end
+
+  it "can dump Strings" do
+    "foo".must be_marshalable
+  end
+
+  it "can dump Arrays" do
+    [2, 'foo'].must be_marshalable
+  end
+
+  it "can't dump things that return false for marshalable?" do
+    CannotMarshalMe.new.must_not be_marshalable
+  end
+
+  it "can't dump Arrays containing unmarshalable items" do
+    [2, $stdin].must_not be_marshalable
+    [2, CannotMarshalMe.new].must_not be_marshalable
+  end
+
+  it "can dump hashes" do
+    {:foo => 'bar'}.must be_marshalable
+  end
+
+  it "can't dump hashes with unmarshalable keys" do
+    {$stdin => 'bar'}.must_not be_marshalable
+    {CannotMarshalMe.new => 'bar'}.must_not be_marshalable
+  end
+
+  it "can't dump hashes with unmarshalable values" do
+    {:foo => $stdin}.must_not be_marshalable
+    {:foo => CannotMarshalMe.new}.must_not be_marshalable
+  end
+
+  it "can't dump hashes with an unmarshalable default value" do
+    Hash.new($stdin).must_not be_marshalable
+    Hash.new(CannotMarshalMe.new).must_not be_marshalable
+  end
+
+  it "can dump hashes with a marshalable default value" do
+    Hash.new(0).must be_marshalable
+  end
+
+  it "can't dump hashes with a default proc" do
+    Hash.new {|a,b| a[b] = rand}.must_not be_marshalable
+  end
+
+  it "can't dump objects containing references to unmarshalable objects" do
+    CustomContainer.new(CannotMarshalMe.new).must_not be_marshalable
+  end
+
+  it "can't dump IOs" do
+    $stdin.must_not be_marshalable
+  end
+
+  it "can't dump Methods" do
+    method(:to_s).must_not be_marshalable
+  end
+
+  it "can't dump bindings" do
+    binding.must_not be_marshalable
+  end
+
+  it "can't dump Procs" do
+    proc{ 2 }.must_not be_marshalable
+  end
+
+  it "can't dump anything whose _dump method raises a TypeError" do
+    class NotDumpable; def _dump(*args); raise TypeError; end; end
+    NotDumpable.new.must_not be_marshalable
+  end
+end
+