capistrano 2.1.0 → 3.0.0

data/test/upload_test.rb

@@ -1,131 +0,0 @@
-require "#{File.dirname(__FILE__)}/utils"
-require 'capistrano/upload'
-
-class UploadTest < Test::Unit::TestCase
-  def setup
-    @mode = IO::WRONLY | IO::CREAT | IO::TRUNC
-  end
-
-  def test_initialize_should_raise_error_if_data_is_missing
-    assert_raises(ArgumentError) do
-      Capistrano::Upload.new([], "test.txt", :foo => "bar")
-    end
-  end
-
-  def test_initialize_should_get_sftp_for_each_session
-    new_sftp = Proc.new do |state|
-      sftp = mock("sftp", :state => state, :open => nil)
-      sftp.expects(:connect) unless state == :open
-      sftp.stubs(:channel).returns({})
-      sftp
-    end
-
-    sessions = [mock("session", :xserver => server("a"), :sftp => new_sftp[:closed]),
-                mock("session", :xserver => server("b"), :sftp => new_sftp[:closed]),
-                mock("session", :xserver => server("c"), :sftp => new_sftp[:open])]
-    Capistrano::Upload.new(sessions, "test.txt", :data => "data")
-  end
-
-  def test_self_process_should_instantiate_uploader_and_start_process
-    Capistrano::Upload.expects(:new).with([:s1, :s2], "test.txt", :data => "data").returns(mock(:process! => nil))
-    Capistrano::Upload.process([:s1, :s2], "test.txt", :data => "data")
-  end
-
-  def test_process_when_sftp_open_fails_should_raise_error
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status", :code => "bad status", :message => "bad status"), :file_handle)
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    assert_raises(Capistrano::UploadError) { upload.process! }
-    assert_equal 1, upload.failed
-    assert_equal 1, upload.completed
-  end
-
-  def test_process_when_sftp_write_fails_should_raise_error
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
-    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => "bad status", :message => "bad status"))
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    assert_raises(Capistrano::UploadError) { upload.process! }
-    assert_equal 1, upload.failed
-    assert_equal 1, upload.completed
-  end
-  
-  def test_upload_error_should_include_accessor_with_host_array
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
-    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => "bad status", :message => "bad status"))
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    
-    begin
-      upload.process!
-      flunk "expected an exception to be raised"
-    rescue Capistrano::UploadError => e
-      assert e.respond_to?(:hosts)
-      assert_equal %w(capistrano), e.hosts.map { |h| h.to_s }
-    end
-  end
-  
-  def test_process_when_sftp_succeeds_should_raise_nothing
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
-    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => Net::SFTP::Session::FX_OK))
-    sftp.expects(:close_handle).with(:file_handle).yields
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    assert_nothing_raised { upload.process! }
-    assert_equal 0, upload.failed
-    assert_equal 1, upload.completed
-  end
-
-  def test_process_should_loop_while_running
-    con = mock("connection")
-    con.expects(:process).with(true).times(10)
-    channel = {}
-    channel.expects(:connection).returns(con).times(10)
-    sftp = mock("sftp", :state => :open, :open => nil)
-    sftp.stubs(:channel).returns(channel)
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data")
-    upload.expects(:running?).times(11).returns(*([true]*10 + [false]))
-    upload.process!
-  end
-
-  def test_process_should_loop_but_not_process_done_channels
-    new_sftp = Proc.new do |done|
-      channel = {}
-      channel[:needs_done] = done
-
-      if !done
-        con = mock("connection")
-        con.expects(:process).with(true).times(10)
-        channel.expects(:connection).returns(con).times(10)
-      end
-
-      sftp = mock("sftp", :state => :open, :open => nil)
-      sftp.stubs(:channel).returns(channel)
-      sftp
-    end
-
-    sessions = [stub("session", :sftp => new_sftp[true], :xserver => server("capistrano")),
-                stub("session", :sftp => new_sftp[false], :xserver => server("cap2"))]
-    upload = Capistrano::Upload.new(sessions, "test.txt", :data => "data")
-
-    # make sure the sftp channels we wanted to be done, start as done
-    # (Upload.new marks each channel as not-done, so we have to do it here)
-    sessions.each { |s| s.sftp.channel[:done] = true if s.sftp.channel[:needs_done] }
-    upload.expects(:running?).times(11).returns(*([true]*10 + [false]))
-    upload.process!
-  end
-
-  private
-
-    def mock_sftp
-      sftp = mock("sftp", :state => :open)
-      sftp.stubs(:channel).returns(Hash.new)
-      yield sftp if block_given?
-      sftp
-    end
-end

data/test/utils.rb

@@ -1,42 +0,0 @@
-unless defined?(TestExtensions)
-  $:.unshift "#{File.dirname(__FILE__)}/../lib"
-
-  begin
-    require 'rubygems'
-    gem     'mocha'
-  rescue LoadError
-  end
-
-  require 'test/unit'
-  require 'mocha'
-  require 'capistrano/server_definition'
-
-  module TestExtensions
-    def server(host, options={})
-      Capistrano::ServerDefinition.new(host, options)
-    end
-
-    def namespace(fqn=nil)
-      space = stub(:roles => {}, :fully_qualified_name => fqn, :default_task => nil)
-      yield(space) if block_given?
-      space
-    end
-
-    def role(space, name, *args)
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      space.roles[name] ||= []
-      space.roles[name].concat(args.map { |h| Capistrano::ServerDefinition.new(h, opts) })
-    end
-
-    def new_task(name, namespace=@namespace, options={}, &block)
-      block ||= Proc.new {}
-      task = Capistrano::TaskDefinition.new(name, namespace, options, &block)
-      assert_equal block, task.body
-      return task
-    end
-  end
-
-  class Test::Unit::TestCase
-    include TestExtensions
-  end
-end

data/test/version_test.rb

@@ -1,24 +0,0 @@
-require "#{File.dirname(__FILE__)}/utils"
-require 'capistrano/version'
-
-class VersionTest < Test::Unit::TestCase
-  def test_check_should_return_true_for_matching_parameters
-    assert Capistrano::Version.check([2], [2])
-    assert Capistrano::Version.check([2,1], [2,1])
-    assert Capistrano::Version.check([2,1,5], [2,1,5])
-  end
-
-  def test_check_should_return_true_if_first_is_less_than_second
-    assert Capistrano::Version.check([2], [3])
-    assert Capistrano::Version.check([2], [2,1])
-    assert Capistrano::Version.check([2,1], [2,2])
-    assert Capistrano::Version.check([2,1], [2,1,1])
-  end
-
-  def test_check_should_return_false_if_first_is_greater_than_second
-    assert !Capistrano::Version.check([3], [2])
-    assert !Capistrano::Version.check([3,1], [3])
-    assert !Capistrano::Version.check([3,2], [3,1])
-    assert !Capistrano::Version.check([3,2,1], [3,2])
-  end
-end