wesabe-robot-army 0.1.1 → 0.1.7

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.must == @dump
+  end
+  
+  it "gets messages from @in" do
+    # when
+    @in.string = @dump
+    
+    # then
+    @messenger.get.must == @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.must_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').must == '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.must == '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 }.must 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).
+      must == "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.must == "1"
+  end
+  
+  it "can render itself as ruby that evaluates to a Proc" do
+    @proc.to_ruby.must == "proc { 1 }"
+  end
+  
+  it "can get a list of arguments" do
+    proc{ |a, b| a + b }.arguments.must == %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.must =~ /\A\s*1\s*\Z/
+  end
+  
+  it "can render itself as ruby that evaluates to a Method" do
+    @method.to_ruby.must == "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.must == []
+  end
+  
+  it "returns a single argument for a method with a single argument" do
+    @one_arg.arguments.must == %w[a]
+  end
+  
+  it "returns a comma-separated list of arguments when there are many args" do
+    @many_args.arguments.must == %w[a b]
+  end
+end

data/spec/soldier_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Soldier do
+  before do
+    # given
+    @messenger = mock(:messenger)
+    @soldier = RobotArmy::Soldier.new(@messenger)
+  end
+  
+  it "can accept eval commands" do
+    # then
+    @soldier.run(:eval, :code => '3+4', :file => __FILE__, :line => __LINE__).
+      must == 7
+    
+    # and
+    @soldier.run(:eval, :code => 'Time.now', :file => __FILE__, :line => __LINE__).
+      must be_an_instance_of(Time)
+  end
+  
+  it "evaluates each command in the same process" do
+    # when
+    pid = proc{ @soldier.run(:eval, :code => 'Process.pid', :file => __FILE__, :line => __LINE__) }
+    
+    # then
+    pid.call.must == pid.call
+  end
+  
+  it "raises on unrecognized commands" do
+    proc{ @soldier.run(:foo, nil) }.must raise_error(ArgumentError)
+  end
+  
+  it "listens for commands from the messenger to run" do
+    # then
+    @soldier.should_receive(:run).with(:eval, :code => 'Hash.new')
+    
+    # when
+    @messenger.stub!(:post)
+    @messenger.stub!(:get).and_return(:command => :eval, :data => {:code => 'Hash.new'})
+    @soldier.listen
+  end
+  
+  it "posts through the messenger the result of commands run by listening" do
+    # then
+    @messenger.should_receive(:post).with(:status => 'ok', :data => 1)
+    
+    # when
+    @messenger.stub!(:get).and_return(:command => :eval, :data => {:code => '1'})
+    @soldier.stub!(:run).and_return(1)
+    @soldier.listen
+  end
+  
+  it "posts back and raises RobotArmy::Exit when running the exit command" do
+    @messenger.should_receive(:post).with(:status => 'ok')
+    proc{ @soldier.run(:exit, nil) }.must raise_error(RobotArmy::Exit)
+  end
+  
+  it "returns the pid and type when asked for info" do
+    @soldier.run(:info, nil).must == {:pid => Process.pid, :type => 'RobotArmy::Soldier'}
+  end
+  
+  it "posts back a warning if the :eval return value is not marshalable" do
+    # then
+    @messenger.should_receive(:post).
+      with(:status => 'warning', :data => "ignoring invalid remote return value #{$stdin.inspect}")
+    
+    # when
+    @messenger.stub!(:get).and_return(
+      :command => :eval, :data => {:code => '$stdin', :file => __FILE__, :line => __LINE__})
+    @soldier.listen
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$TESTING=true
+load File.join(File.dirname(__FILE__), '..', 'lib', 'robot-army.rb')
+
+module Spec::Expectations::ObjectExpectations
+  alias_method :must, :should
+  alias_method :must_not, :should_not
+  undef_method :should
+  undef_method :should_not
+end
+
+Spec::Runner.configure do |config|
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure 
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+  
+  alias silence capture
+end

data/spec/task_master_spec.rb

@@ -0,0 +1,272 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Example < RobotArmy::TaskMaster
+  hosts %[www1.example.com www2.example.com]
+end
+
+class Localhost < RobotArmy::TaskMaster
+  host :localhost
+end
+
+describe RobotArmy::TaskMaster, 'host management' do
+  before do
+    @example = Example.new
+  end
+
+  it "allows setting a single host" do
+    Example.host 'example.com'
+    Example.host.must == 'example.com'
+  end
+
+  it "allows accessing multi-hosts when using the single-host interface" do
+    Example.host 'example.com'
+    Example.hosts.must == %w[example.com]
+  end
+
+  it "allows setting multiple hosts on the class" do
+    Example.hosts %w[example.com test.com]
+    Example.hosts.must == %w[example.com test.com]
+  end
+
+  it "denies accessing a single host when using the multi-host interface" do
+    Example.hosts %w[example.com test.com]
+    proc { Example.host }.must raise_error(
+      RobotArmy::HostArityError, "There are 2 hosts, so calling host doesn't make sense")
+  end
+
+  it "instances default to the hosts set on the class" do
+    Example.host 'example.com'
+    @example.host.must == 'example.com'
+
+    Example.hosts %w[example.com test.com]
+    @example.hosts.must == %w[example.com test.com]
+  end
+
+  it "allows setting a single host on an instance" do
+    @example.host = 'example.com'
+    @example.host.must == 'example.com'
+  end
+
+  it "allows accessing multi-hosts when using the single-host interface on instances" do
+    @example.host = 'example.com'
+    @example.hosts.must == %w[example.com]
+  end
+
+  it "allows setting multiple hosts on an instance" do
+    @example.hosts = %w[example.com test.com]
+    @example.hosts.must == %w[example.com test.com]
+  end
+
+  it "denies accessing a single host when using the multi-host interface" do
+    @example.hosts = %w[example.com test.com test2.com]
+    proc { @example.host }.must raise_error(
+      RobotArmy::HostArityError, "There are 3 hosts, so calling host doesn't make sense")
+  end
+end
+
+describe RobotArmy::TaskMaster, 'remote' do
+  before do
+    @localhost = Localhost.new
+    @example   = Example.new
+  end
+
+  it "returns a single item when using the single-host interface" do
+    @localhost.stub!(:remote_eval).and_return(7)
+    @localhost.remote { 3+4 }.must == 7
+  end
+
+  it "returns an array of items when using the multi-host interface" do
+    @example.stub!(:remote_eval).and_return(7)
+    @example.remote { 3+4 }.must == [7, 7]
+  end
+end
+
+describe RobotArmy::TaskMaster do
+  before do
+    @localhost = Localhost.new
+    @example = Example.new
+  end
+
+  it "runs a remote block on each host" do
+    @example.should_receive(:remote_eval).exactly(2).times
+    @example.remote { 3+4 }
+  end
+
+
+  it "can execute a Ruby block and return the result" do
+    @localhost.remote { 3+4 }.must == 7
+  end
+
+  it "executes its block in a different process" do
+    @localhost.remote { Process.pid }.must_not == Process.pid
+  end
+
+  it "preserves local variables" do
+    a = 42
+    @localhost.remote { a }.must == 42
+  end
+
+  it "warns about invalid remote return values" do
+    capture(:stderr) { @localhost.remote { $stdin } }.
+      must =~ /WARNING: ignoring invalid remote return value/
+  end
+
+  it "returns nil if the remote return value is invalid" do
+    silence(:stderr) { @localhost.remote { $stdin }.must be_nil }
+  end
+
+  it "re-raises exceptions thrown remotely" do
+    proc { @localhost.remote { raise ArgumentError, "You fool!" } }.
+      must raise_error(ArgumentError)
+  end
+
+  it "prints the child Ruby's stderr to stderr" do
+    pending('we may not want to do this, even')
+    capture(:stderr) { @localhost.remote { $stderr.print "foo" } }.must == "foo"
+  end
+
+  it "runs multiple remote blocks for the same host in different processes" do
+    @localhost.remote { $a = 1 }
+    @localhost.remote { $a }.must be_nil
+  end
+
+  it "only loads one Officer process on the remote machine" do
+    info = @localhost.connection(@localhost.host).info
+    info[:pid].must_not == Process.pid
+    info[:type].must == 'RobotArmy::Officer'
+    @localhost.connection(@localhost.host).info.must == info
+  end
+
+  it "runs as a normal (non-super) user by default" do
+    @localhost.remote{ Process.uid }.must_not == 0
+  end
+
+  it "loads dependencies" do
+    @localhost.dependency "thor"
+    @localhost.remote { Thor ; 45 }.must == 45 # loading should not bail here
+  end
+
+  it "delegates scp to the scp binary" do
+    @localhost.should_receive(:`).with('scp -q file.tgz example.com:/tmp 2>&1')
+    @localhost.host = 'example.com'
+    @localhost.scp 'file.tgz', '/tmp'
+  end
+
+  it "delegates to scp without a host when host is localhost" do
+    @localhost.should_receive(:`).with('scp -q file.tgz /tmp 2>&1')
+    @localhost.scp 'file.tgz', '/tmp'
+  end
+end
+
+describe RobotArmy::TaskMaster, 'scp' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "raises if scp fails due to a permissions error" do
+    @localhost.stub!(:`).and_return("scp: /tmp/foo: Permission denied\n")
+    $?.stub!(:exitstatus).and_return(1)
+    lambda { @localhost.scp('foo', '/tmp') }.must raise_error(Errno::EACCES)
+  end
+
+  it "raises if scp cannot locate the source file" do
+    lambda { @localhost.scp('i-dont-exist', '/tmp') }.must raise_error(Errno::ENOENT)
+  end
+end
+
+describe RobotArmy::TaskMaster, 'remote (with args)' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "can pass arguments explicitly" do
+    @localhost.remote(:args => [42]) { |a| a }.must == 42
+  end
+
+  it "shadows local variables of the same name" do
+    a = 23
+    @localhost.remote(:args => [42]) { |a| a }.must == 42
+  end
+end
+
+describe RobotArmy::TaskMaster, 'cptemp' do
+  before do
+    @localhost = Localhost.new
+    @path = 'cptemp-spec-file'
+    File.open(@path, 'w') {|f| f << 'testing'}
+  end
+
+  it "safely copies to a new temporary directory" do
+    destination = @localhost.cptemp @path
+    File.read(destination).must == 'testing'
+  end
+
+  it "yields the path to each host if a block is passed" do
+    path, pid = @localhost.cptemp(@path) { |path| [path, Process.pid] }
+    File.basename(path).must == @path
+    pid.must_not be_nil
+    pid.must_not == Process.pid
+  end
+
+  it "deletes the file on exit" do
+    destination = @localhost.cptemp @path
+    RobotArmy::AtExit.shared_instance.do_exit
+    fail "Expected cptemp'ed file to be deleted when exit callbacks were run" if File.exist?(destination)
+  end
+
+  after do
+    FileUtils.rm_f(@path)
+  end
+end
+
+describe RobotArmy::TaskMaster, 'with proxies' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "can allow remote method calls on the local object" do
+    def @localhost.foo; 'bar'; end
+    @localhost.remote { foo }.must == 'bar'
+  end
+
+  it "allows calling methods with arguments" do
+    def @localhost.echo(o) o; end
+    @localhost.remote { echo 42 }.must == 42
+  end
+
+  it "allows passing a block to method calls on proxy objects" do
+    pending('this is insane. should I do this?')
+  end
+
+  it "allows interaction with IOs" do
+    capture(:stdout) {
+      stdout = $stdout
+      @localhost.remote { stdout.puts "hey there" }
+    }.must == "hey there\n"
+  end
+
+  it "returns a proxy if the return value of an upstream call can't be marshaled" do
+    def @localhost.stdout; $stdout; end
+    capture(:stdout) { @localhost.remote { stdout.puts "foo" } }.must == "foo\n"
+  end
+end
+
+describe RobotArmy::TaskMaster, 'sudo' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "runs remote with the root user by default" do
+    @localhost.should_receive(:remote).
+      with(@localhost.hosts, :user => 'root')
+
+    @localhost.sudo { File.read('/etc/passwd') }
+  end
+
+  it "allows specifying a particular user" do
+    @localhost.should_receive(:remote).
+      with(@localhost.hosts, :user => 'www-data')
+
+    @localhost.sudo(:user => 'www-data') { %x{/etc/init.d/apache2 restart} }
+  end
+end