net-ssh-multi 1.0.0

data/test/channel_test.rb

@@ -0,0 +1,152 @@
+require 'common'
+require 'net/ssh/multi/channel'
+
+class ChannelTest < Test::Unit::TestCase
+  def test_each_should_iterate_over_each_component_channel
+    channels = [c1 = mock('channel'), c2 = mock('channel'), c3 = mock('channel')]
+    channel = Net::SSH::Multi::Channel.new(mock('session'), channels)
+    result = []
+    channel.each { |c| result << c }
+    assert_equal channels, result
+  end
+
+  def test_property_accessors
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [])
+    channel[:foo] = "hello"
+    assert_equal "hello", channel[:foo]
+    channel['bar'] = "goodbye"
+    assert_equal "goodbye", channel['bar']
+    assert_nil channel[:bar]
+    assert_nil channel['foo']
+  end
+
+  def test_exec_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:exec).with('ls -l').yields(c1)
+    c2.expects(:exec).with('ls -l').yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.exec('ls -l') { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_request_pty_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:request_pty).with(:foo => 5).yields(c1)
+    c2.expects(:request_pty).with(:foo => 5).yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.request_pty(:foo => 5) { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_send_data_should_delegate_to_component_channels
+    c1, c2 = mock('channel'), mock('channel')
+    c1.expects(:send_data).with("hello\n")
+    c2.expects(:send_data).with("hello\n")
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.send_data("hello\n")
+  end
+
+  def test_active_should_be_true_if_all_component_channels_are_active
+    c1, c2, c3 = stub('channel', :active? => true), stub('channel', :active? => true), stub('channel', :active? => true)
+    channel = Net::SSH::Multi::Channel.new(stub('session'), [c1, c2, c3])
+    assert channel.active?
+  end
+
+  def test_active_should_be_true_if_any_component_channels_are_active
+    c1, c2, c3 = stub('channel', :active? => true), stub('channel', :active? => false), stub('channel', :active? => false)
+    channel = Net::SSH::Multi::Channel.new(stub('session'), [c1, c2, c3])
+    assert channel.active?
+  end
+
+  def test_active_should_be_false_if_no_component_channels_are_active
+    c1, c2, c3 = stub('channel', :active? => false), stub('channel', :active? => false), stub('channel', :active? => false)
+    channel = Net::SSH::Multi::Channel.new(stub('session'), [c1, c2, c3])
+    assert !channel.active?
+  end
+
+  def test_wait_should_block_until_active_is_false
+    channel = Net::SSH::Multi::Channel.new(MockSession.new, [])
+    channel.expects(:active?).times(4).returns(true,true,true,false)
+    assert_equal channel, channel.wait
+  end
+
+  def test_close_should_delegate_to_component_channels
+    c1, c2 = mock('channel'), mock('channel')
+    c1.expects(:close)
+    c2.expects(:close)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.close
+  end
+
+  def test_eof_bang_should_delegate_to_component_channels
+    c1, c2 = mock('channel'), mock('channel')
+    c1.expects(:eof!)
+    c2.expects(:eof!)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.eof!
+  end
+
+  def test_on_data_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:on_data).yields(c1)
+    c2.expects(:on_data).yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.on_data { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_on_extended_data_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:on_extended_data).yields(c1)
+    c2.expects(:on_extended_data).yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.on_extended_data { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_on_process_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:on_process).yields(c1)
+    c2.expects(:on_process).yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.on_process { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_on_close_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:on_close).yields(c1)
+    c2.expects(:on_close).yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.on_close { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_on_eof_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:on_eof).yields(c1)
+    c2.expects(:on_eof).yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.on_eof { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  def test_on_request_should_delegate_to_component_channels
+    c1, c2, results = mock('channel'), mock('channel'), []
+    c1.expects(:on_request).with("exit-status").yields(c1)
+    c2.expects(:on_request).with("exit-status").yields(c2)
+    channel = Net::SSH::Multi::Channel.new(mock('session'), [c1, c2])
+    assert_equal channel, channel.on_request("exit-status") { |c| results << c }
+    assert_equal [c1, c2], results
+  end
+
+  private
+
+    class MockSession
+      def loop
+        while true do
+          return if !yield(self)
+        end
+      end
+    end
+end

data/test/common.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'mocha'

data/test/multi_test.rb

@@ -0,0 +1,20 @@
+require 'common'
+require 'net/ssh/multi'
+
+class MultiTest < Test::Unit::TestCase
+  def test_start_with_block_should_yield_session_and_then_close
+    Net::SSH::Multi::Session.any_instance.expects(:loop)
+    Net::SSH::Multi::Session.any_instance.expects(:close)
+    yielded = false
+    Net::SSH::Multi.start do |session|
+      yielded = true
+      assert_instance_of Net::SSH::Multi::Session, session
+    end
+  end
+
+  def test_start_without_block_should_return_open_session
+    Net::SSH::Multi::Session.any_instance.expects(:loop).never
+    Net::SSH::Multi::Session.any_instance.expects(:close).never
+    assert_instance_of Net::SSH::Multi::Session, Net::SSH::Multi.start
+  end
+end

data/test/server_test.rb

@@ -0,0 +1,256 @@
+require 'common'
+require 'net/ssh/multi/server'
+
+class ServerTest < Test::Unit::TestCase
+  def setup
+    @master = stub('multi-session', :default_user => "bob")
+  end
+
+  def test_accessor_without_properties_should_access_empty_hash
+    assert_nil server('host')[:foo]
+  end
+
+  def test_accessor_with_properties_should_access_properties
+    assert_equal "hello", server('host', :properties => { :foo => "hello" })[:foo]
+  end
+
+  def test_port_should_return_22_by_default
+    assert_equal 22, server('host').port
+  end
+
+  def test_port_should_return_given_port_when_present
+    assert_equal 1234, server('host', :port => 1234).port
+  end
+
+  def test_port_should_return_parsed_port_when_present
+    assert_equal 1234, server('host:1234', :port => 1235).port
+  end
+
+  def test_user_should_return_default_user_by_default
+    assert_equal "bob", server('host').user
+  end
+
+  def test_user_should_return_given_user_when_present
+    assert_equal "jim", server('host', :user => "jim").user
+  end
+
+  def test_user_should_return_parsed_user_when_present
+    assert_equal "jim", server('jim@host', :user => "john").user
+  end
+
+  def test_equivalence_when_host_and_user_and_port_match
+    s1 = server('user@host:1234')
+    s2 = server('user@host:1234')
+    assert s1.eql?(s2)
+    assert_equal s1.hash, s2.hash
+    assert s1 == s2
+  end
+
+  def test_equivalence_when_host_mismatch
+    s1 = server('user@host1:1234')
+    s2 = server('user@host2:1234')
+    assert !s1.eql?(s2)
+    assert_not_equal s1.hash, s2.hash
+    assert s1 != s2
+  end
+
+  def test_equivalence_when_port_mismatch
+    s1 = server('user@host:1234')
+    s2 = server('user@host:1235')
+    assert !s1.eql?(s2)
+    assert_not_equal s1.hash, s2.hash
+    assert s1 != s2
+  end
+
+  def test_equivalence_when_user_mismatch
+    s1 = server('user1@host:1234')
+    s2 = server('user2@host:1234')
+    assert !s1.eql?(s2)
+    assert_not_equal s1.hash, s2.hash
+    assert s1 != s2
+  end
+
+  def test_to_s_should_include_user_and_host
+    assert_equal "user@host", server('user@host').to_s
+  end
+
+  def test_to_s_should_include_user_and_host_and_port_when_port_is_given
+    assert_equal "user@host:1234", server('user@host:1234').to_s
+  end
+
+  def test_gateway_should_be_nil_by_default
+    assert_nil server('host').gateway
+  end
+
+  def test_gateway_should_be_set_with_the_via_value
+    gateway = mock('gateway')
+    assert_equal gateway, server('host', :via => gateway).gateway
+  end
+
+  def test_session_with_default_argument_should_not_instantiate_session
+    assert_nil server('host').session
+  end
+
+  def test_session_with_true_argument_should_instantiate_and_cache_session
+    srv = server('host')
+    session = expect_connection_to(srv)
+    assert_equal session, srv.session(true)
+    assert_equal session, srv.session(true)
+    assert_equal session, srv.session
+  end
+
+  def test_session_that_cannot_authenticate_adds_host_to_exception_message
+    srv = server('host')
+    Net::SSH.expects(:start).with('host', 'bob', {}).raises(Net::SSH::AuthenticationFailed.new('bob'))
+
+    begin
+      srv.new_session
+      flunk
+    rescue Net::SSH::AuthenticationFailed => e
+      assert_equal "bob@host", e.message
+    end
+  end
+
+  def test_close_channels_when_session_is_not_open_should_not_do_anything
+    assert_nothing_raised { server('host').close_channels }
+  end
+
+  def test_close_channels_when_session_is_open_should_iterate_over_open_channels_and_close_them
+    srv = server('host')
+    session = expect_connection_to(srv)
+    c1 = mock('channel', :close => nil)
+    c2 = mock('channel', :close => nil)
+    c3 = mock('channel', :close => nil)
+    session.expects(:channels).returns(1 => c1, 2 => c2, 3 => c3)
+    assert_equal session, srv.session(true)
+    srv.close_channels
+  end
+
+  def test_close_when_session_is_not_open_should_not_do_anything
+    assert_nothing_raised { server('host').close }
+  end
+
+  def test_close_when_session_is_open_should_close_session
+    srv = server('host')
+    session = expect_connection_to(srv)
+    session.expects(:close)
+    @master.expects(:server_closed).with(srv)
+    assert_equal session, srv.session(true)
+    srv.close
+  end
+
+  def test_busy_should_be_false_when_session_is_not_open
+    assert !server('host').busy?
+  end
+
+  def test_busy_should_be_false_when_session_is_not_busy
+    srv = server('host')
+    session = expect_connection_to(srv)
+    session.expects(:busy?).returns(false)
+    srv.session(true)
+    assert !srv.busy?
+  end
+
+  def test_busy_should_be_true_when_session_is_busy
+    srv = server('host')
+    session = expect_connection_to(srv)
+    session.expects(:busy?).returns(true)
+    srv.session(true)
+    assert srv.busy?
+  end
+
+  def test_preprocess_should_be_nil_when_session_is_not_open
+    assert_nil server('host').preprocess
+  end
+
+  def test_preprocess_should_return_result_of_session_preprocess
+    srv = server('host')
+    session = expect_connection_to(srv)
+    session.expects(:preprocess).returns(:result)
+    srv.session(true)
+    assert_equal :result, srv.preprocess
+  end
+
+  def test_readers_should_return_empty_array_when_session_is_not_open
+    assert_equal [], server('host').readers
+  end
+
+  def test_readers_should_return_all_listeners_when_session_is_open
+    srv = server('host')
+    session = expect_connection_to(srv)
+    io1, io2, io3, io4 = Reader.new, Reader.new, Reader.new, Reader.new
+    session.expects(:listeners).returns(io1 => 2, io2 => 4, io3 => 6, io4 => 8)
+    srv.session(true)
+    assert_equal [io1, io2, io3, io4], srv.readers.sort
+  end
+
+  def test_writers_should_return_empty_array_when_session_is_not_open
+    assert_equal [], server('host').writers
+  end
+
+  def test_writers_should_return_all_listeners_that_are_pending_writes_when_session_is_open
+    srv = server('host')
+    session = expect_connection_to(srv)
+    listeners = { Reader.new(true) => 1, MockIO.new => 2,
+      MockIO.new => 3, Reader.new => 4, Reader.new(true) => 5 }
+    session.expects(:listeners).returns(listeners)
+    srv.session(true)
+    assert_equal 2, srv.writers.length
+  end
+
+  def test_postprocess_should_return_true_when_session_is_not_open
+    assert_equal true, server('host').postprocess([], [])
+  end
+
+  def test_postprocess_should_call_session_postprocess_with_ios_belonging_to_session
+    srv = server('host')
+    session = expect_connection_to(srv)
+    session.expects(:listeners).returns(1 => 2, 3 => 4, 5 => 6, 7 => 8)
+    session.expects(:postprocess).with([1,3], [7]).returns(:result)
+    srv.session(true)
+    assert_equal :result, srv.postprocess([1,11,3], [18,14,7,12])
+  end
+
+  private
+
+    class MockIO
+      include Comparable
+
+      @@identifier = 0
+
+      attr_reader :id
+
+      def initialize
+        @id = (@@identifier += 1)
+      end
+
+      def <=>(io)
+        @id <=> io.id
+      end
+
+      def closed?
+        false
+      end
+    end
+
+    class Reader < MockIO
+      def initialize(ready=false)
+        super()
+        @ready = ready
+      end
+
+      def pending_write?
+        @ready
+      end
+    end
+
+    def server(host, options={})
+      Net::SSH::Multi::Server.new(@master, host, options)
+    end
+
+    def expect_connection_to(server)
+      session = {}
+      @master.expects(:next_session).with(server).returns(session)
+      return session
+    end
+end

data/test/session_actions_test.rb

@@ -0,0 +1,128 @@
+require 'common'
+require 'net/ssh/multi/server'
+require 'net/ssh/multi/session_actions'
+
+class SessionActionsTest < Test::Unit::TestCase
+  class SessionActionsContainer
+    include Net::SSH::Multi::SessionActions
+
+    attr_reader :servers
+
+    def initialize
+      @servers = []
+    end
+
+    def default_user
+      "user"
+    end
+
+    def use(h, o={})
+      server = Net::SSH::Multi::Server.new(self, h, o)
+      servers << server
+      server
+    end
+  end
+
+  def setup
+    @session = SessionActionsContainer.new
+  end
+
+  def test_busy_should_be_true_if_any_server_is_busy
+    srv1, srv2, srv3 = @session.use('h1'), @session.use('h2'), @session.use('h3')
+    srv1.stubs(:busy?).returns(false)
+    srv2.stubs(:busy?).returns(false)
+    srv3.stubs(:busy?).returns(true)
+    assert @session.busy?
+  end
+
+  def test_busy_should_be_false_if_all_servers_are_not_busy
+    srv1, srv2, srv3 = @session.use('h1'), @session.use('h2'), @session.use('h3')
+    srv1.stubs(:busy?).returns(false)
+    srv2.stubs(:busy?).returns(false)
+    srv3.stubs(:busy?).returns(false)
+    assert !@session.busy?
+  end
+
+  def test_send_global_request_should_delegate_to_sessions
+    s1 = mock('ssh')
+    s2 = mock('ssh')
+    s1.expects(:send_global_request).with("a", "b", "c").yields
+    s2.expects(:send_global_request).with("a", "b", "c").yields
+    @session.expects(:sessions).returns([s1, s2])
+    calls = 0
+    @session.send_global_request("a", "b", "c") { calls += 1 }
+    assert_equal 2, calls
+  end
+
+  def test_open_channel_should_delegate_to_sessions_and_set_accessors_on_each_channel_and_return_multi_channel
+    srv1 = @session.use('h1')
+    srv2 = @session.use('h2')
+    s1 = { :server => srv1 }
+    s2 = { :server => srv2 }
+    c1 = { :stub => :value }
+    c2 = {}
+    c1.stubs(:connection).returns(s1)
+    c2.stubs(:connection).returns(s2)
+    @session.expects(:sessions).returns([s1, s2])
+    s1.expects(:open_channel).with("session").yields(c1).returns(c1)
+    s2.expects(:open_channel).with("session").yields(c2).returns(c2)
+    results = []
+    channel = @session.open_channel do |c|
+      results << c
+    end
+    assert_equal [c1, c2], results
+    assert_equal "h1", c1[:host]
+    assert_equal "h2", c2[:host]
+    assert_equal srv1, c1[:server]
+    assert_equal srv2, c2[:server]
+    assert_instance_of Net::SSH::Multi::Channel, channel
+    assert_equal [c1, c2], channel.channels
+  end
+
+  def test_exec_should_raise_exception_if_channel_cannot_exec_command
+    c = { :host => "host" }
+    @session.expects(:open_channel).yields(c).returns(c)
+    c.expects(:exec).with('something').yields(c, false)
+    assert_raises(RuntimeError) { @session.exec("something") }
+  end
+
+  def test_exec_with_block_should_pass_data_and_extended_data_to_block
+    c = { :host => "host" }
+    @session.expects(:open_channel).yields(c).returns(c)
+    c.expects(:exec).with('something').yields(c, true)
+    c.expects(:on_data).yields(c, "stdout")
+    c.expects(:on_extended_data).yields(c, 1, "stderr")
+    c.expects(:on_request)
+    results = {}
+    @session.exec("something") do |c, stream, data|
+      results[stream] = data
+    end
+    assert_equal({:stdout => "stdout", :stderr => "stderr"}, results)
+  end
+
+  def test_exec_without_block_should_write_data_and_extended_data_lines_to_stdout_and_stderr
+    c = { :host => "host" }
+    @session.expects(:open_channel).yields(c).returns(c)
+    c.expects(:exec).with('something').yields(c, true)
+    c.expects(:on_data).yields(c, "stdout 1\nstdout 2\n")
+    c.expects(:on_extended_data).yields(c, 1, "stderr 1\nstderr 2\n")
+    c.expects(:on_request)
+    $stdout.expects(:puts).with("[host] stdout 1\n")
+    $stdout.expects(:puts).with("[host] stdout 2")
+    $stderr.expects(:puts).with("[host] stderr 1\n")
+    $stderr.expects(:puts).with("[host] stderr 2")
+    @session.exec("something")
+  end
+
+  def test_exec_should_capture_exit_status_of_process
+    c = { :host => "host" }
+    @session.expects(:open_channel).yields(c).returns(c)
+    c.expects(:exec).with('something').yields(c, true)
+    c.expects(:on_data)
+    c.expects(:on_extended_data)
+    c.expects(:on_request).with("exit-status").yields(c, Net::SSH::Buffer.from(:long, 127))
+    @session.exec("something")
+    assert_equal 127, c[:exit_status]
+  end
+
+end