robot-army 0.1.8

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.should == []
+  end
+  
+  it "should store the dependency requirement by name" do
+    name = "RedCloth"
+    @loader.add_dependency name
+    @loader.dependencies.should == [[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.should == [[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! }.should 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].should == @connection
+  end
+  
+  it "has a shared instance that doesn't change" do
+    RobotArmy::GateKeeper.shared_instance.should be_an_instance_of(RobotArmy::GateKeeper)
+    RobotArmy::GateKeeper.shared_instance.should == 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 }.should be_a(Time)
+    end
+
+    it "does sudo as root by default" do
+      @tm.sudo { Process.uid }.should == 0
+    end
+
+    it "can do sudo as ourselves" do
+      my_remote_uid = @tm.remote { Process.uid }
+      @tm.sudo(:user => ENV['USER']) { Process.uid }.should == 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'] }.should == 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).should == "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').should == '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').should == '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 } }.should 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.should be_marshalable
+  end
+
+  it "can dump Strings" do
+    "foo".should be_marshalable
+  end
+
+  it "can dump Arrays" do
+    [2, 'foo'].should be_marshalable
+  end
+
+  it "can't dump things that return false for marshalable?" do
+    CannotMarshalMe.new.should_not be_marshalable
+  end
+
+  it "can't dump Arrays containing unmarshalable items" do
+    [2, $stdin].should_not be_marshalable
+    [2, CannotMarshalMe.new].should_not be_marshalable
+  end
+
+  it "can dump hashes" do
+    {:foo => 'bar'}.should be_marshalable
+  end
+
+  it "can't dump hashes with unmarshalable keys" do
+    {$stdin => 'bar'}.should_not be_marshalable
+    {CannotMarshalMe.new => 'bar'}.should_not be_marshalable
+  end
+
+  it "can't dump hashes with unmarshalable values" do
+    {:foo => $stdin}.should_not be_marshalable
+    {:foo => CannotMarshalMe.new}.should_not be_marshalable
+  end
+
+  it "can't dump hashes with an unmarshalable default value" do
+    Hash.new($stdin).should_not be_marshalable
+    Hash.new(CannotMarshalMe.new).should_not be_marshalable
+  end
+
+  it "can dump hashes with a marshalable default value" do
+    Hash.new(0).should be_marshalable
+  end
+
+  it "can't dump hashes with a default proc" do
+    Hash.new {|a,b| a[b] = rand}.should_not be_marshalable
+  end
+
+  it "can't dump objects containing references to unmarshalable objects" do
+    CustomContainer.new(CannotMarshalMe.new).should_not be_marshalable
+  end
+
+  it "can't dump IOs" do
+    $stdin.should_not be_marshalable
+  end
+
+  it "can't dump Methods" do
+    method(:to_s).should_not be_marshalable
+  end
+
+  it "can't dump bindings" do
+    binding.should_not be_marshalable
+  end
+
+  it "can't dump Procs" do
+    proc{ 2 }.should_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.should_not be_marshalable
+  end
+end
+

data/spec/messenger_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Messenger do
+  before do
+    # given
+    @in, @out = StringIO.new, StringIO.new
+    
+    @messenger = RobotArmy::Messenger.new(@in, @out)
+    @response  = {:status => 'ok', :data => 1}
+    @dump      = "#{Base64.encode64(Marshal.dump(@response))}|"
+  end
+  
+  it "posts messages to @out" do
+    # when
+    @messenger.post(@response)
+    
+    # then
+    @out.string.should == @dump
+  end
+  
+  it "gets messages from @in" do
+    # when
+    @in.string = @dump
+    
+    # then
+    @messenger.get.should == @response
+  end
+end

data/spec/officer_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Officer do
+  before do
+    # given
+    @messenger = mock(:messenger)
+    @officer = RobotArmy::Officer.new(@messenger)
+  end
+  
+  it "evaluates each command in a different process" do
+    # when
+    pid = proc{ @officer.run(:eval, :code => 'Process.pid', :file => __FILE__, :line => __LINE__) }
+    
+    # then
+    pid.call.should_not == pid.call
+  end
+  
+  it "asks for a password by posting back status=password" do
+    # then
+    @messenger.should_receive(:post).
+      with(:status => 'password', :data => {:as => 'root', :user => ENV['USER']})
+    
+    # when
+    @messenger.stub!(:get).and_return(:status => 'ok', :data => 'password')
+    @officer.ask_for_password('root')
+  end
+  
+  it "returns the password given upstream" do
+    # when
+    @messenger.stub!(:post)
+    @messenger.stub!(:get).and_return(:status => 'ok', :data => 'password')
+    
+    # then
+    @officer.ask_for_password('root').should == 'password'
+  end
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Proxy do
+  before do
+    # given
+    @messenger = stub(:messenger, :post => nil, :get => nil)
+    @hash = self.hash
+    @proxy = RobotArmy::Proxy.new(@messenger, @hash)
+  end
+  
+  it "posts back a proxy status when a method is called on it" do
+    # then
+    @messenger.should_receive(:post).
+      with(:status => 'proxy', :data => {:hash => @hash, :call => [:to_s]})
+    
+    # when
+    @messenger.stub!(:get).and_return(:status => 'ok', :data => 'foo')
+    RobotArmy::Connection.stub!(:handle_response)
+    @proxy.to_s
+  end
+  
+  it "returns the value returned by a successful incoming message" do
+    # when
+    @messenger.stub!(:get).and_return(:status => 'ok', :data => 'bar')
+    
+    # then
+    @proxy.to_s.should == 'bar'
+  end
+  
+  it "lets exceptions bubble up from handling the message" do
+    # when
+    RobotArmy::Connection.stub!(:handle_response).and_raise
+    
+    # then
+    proc { @proxy.to_s }.should raise_error
+  end
+  
+  it "returns a new proxy if the response has status 'proxy'" do
+    # then
+    RobotArmy::Proxy.should_receive(:new).
+      with(@messenger, @hash)
+    
+    # when
+    @messenger.stub!(:get).and_return(:status => 'proxy', :data => @hash)
+    @proxy.me
+  end
+  
+  it "can generate Ruby code to create a Proxy for an object" do
+    RobotArmy::Proxy.generator_for(self).
+      should == "RobotArmy::Proxy.new(RobotArmy.upstream, #{self.hash.inspect})"
+  end
+end

data/spec/ruby2ruby_ext_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Proc, "to_ruby" do
+  before do
+    @proc = proc{ 1 }
+  end
+  
+  it "can render itself as ruby not enclosed in a proc" do
+    @proc.to_ruby_without_proc_wrapper.should == "1"
+  end
+  
+  it "can render itself as ruby that evaluates to a Proc" do
+    @proc.to_ruby.should == "proc { 1 }"
+  end
+  
+  it "can get a list of arguments" do
+    proc{ |a, b| a + b }.arguments.should == %w[a b]
+  end
+end
+
+class MethodToRubyFixture
+  def one
+    1
+  end
+  
+  def echo(a)
+    a
+  end
+  
+  def add(a, b)
+    a + b
+  end
+end
+
+describe Method, "to_ruby" do
+  before do
+    @method = MethodToRubyFixture.new.method(:one)
+  end
+  
+  it "can render itself as ruby that executes itself" do
+    @method.to_ruby_without_method_declaration.should =~ /\A\s*1\s*\Z/
+  end
+  
+  it "can render itself as ruby that evaluates to a Method" do
+    @method.to_ruby.should == "def one\n  1\nend"
+  end
+end
+
+describe Method, "arguments" do
+  before do
+    @no_args = MethodToRubyFixture.new.method(:one)
+    @one_arg = MethodToRubyFixture.new.method(:echo)
+    @many_args = MethodToRubyFixture.new.method(:add)
+  end
+  
+  it "returns an empty list for a method without arguments" do
+    @no_args.arguments.should == []
+  end
+  
+  it "returns a single argument for a method with a single argument" do
+    @one_arg.arguments.should == %w[a]
+  end
+  
+  it "returns a comma-separated list of arguments when there are many args" do
+    @many_args.arguments.should == %w[a b]
+  end
+end