capistrano 1.4.2 → 2.0.0

data/test/configuration_test.rb

@@ -1,233 +1,81 @@
-$:.unshift File.dirname(__FILE__) + "/../lib"
-
-require 'test/unit'
+require "#{File.dirname(__FILE__)}/utils"
 require 'capistrano/configuration'
-require 'flexmock'
 
-class ConfigurationTest < Test::Unit::TestCase
-  class MockActor
-    attr_reader :tasks
-
-    def initialize(config)
-    end
-
-    def define_task(*args, &block)
-      (@tasks ||= []).push [args, block].flatten
-    end
-  end
-
-  class MockSCM
-    attr_reader   :configuration
-
-    def initialize(config)
-      @configuration = config
-    end
-  end
+# These tests are only for testing the integration of the various components
+# of the Configuration class. To test specific features, please look at the
+# tests under test/configuration.
 
+class ConfigurationTest < Test::Unit::TestCase
   def setup
-    @config = Capistrano::Configuration.new(MockActor)
-    @config.set :scm, MockSCM
-  end
-
-  def test_version_dir_default
-    assert "releases", @config.version_dir
-  end
-
-  def test_current_dir_default
-    assert "current", @config.current_dir
-  end
-
-  def test_shared_dir_default
-    assert "shared", @config.shared_dir
-  end
-
-  def test_set_repository
-    @config.set :repository, "/foo/bar/baz"
-    assert_equal "/foo/bar/baz", @config.repository
-  end
-
-  def test_set_user
-    @config.set :user, "flippy"
-    assert_equal "flippy", @config.user
-  end
-
-  def test_define_single_role
-    @config.role :app, "somewhere.example.com"
-    assert_equal 1, @config.roles[:app].length
-    assert_equal "somewhere.example.com", @config.roles[:app].first.host
-    assert_equal Hash.new, @config.roles[:app].first.options
-  end
-
-  def test_define_single_role_with_options
-    @config.role :app, "somewhere.example.com", :primary => true
-    assert_equal 1, @config.roles[:app].length
-    assert_equal "somewhere.example.com", @config.roles[:app].first.host
-    assert_equal({:primary => true}, @config.roles[:app].first.options)
-  end
-
-  def test_define_multi_role
-    @config.role :app, "somewhere.example.com", "else.example.com"
-    assert_equal 2, @config.roles[:app].length
-    assert_equal "somewhere.example.com", @config.roles[:app].first.host
-    assert_equal "else.example.com", @config.roles[:app].last.host
-    assert_equal({}, @config.roles[:app].first.options)
-    assert_equal({}, @config.roles[:app].last.options)
-  end
-
-  def test_define_multi_role_with_options
-    @config.role :app, "somewhere.example.com", "else.example.com", :primary => true
-    assert_equal 2, @config.roles[:app].length
-    assert_equal "somewhere.example.com", @config.roles[:app].first.host
-    assert_equal "else.example.com", @config.roles[:app].last.host
-    assert_equal({:primary => true}, @config.roles[:app].first.options)
-    assert_equal({:primary => true}, @config.roles[:app].last.options)
-  end
-
-  def test_load_string_unnamed
-    @config.load :string => "set :repository, __FILE__"
-    assert_equal "<eval>", @config.repository
-  end
-
-  def test_load_string_named
-    @config.load :string => "set :repository, __FILE__", :name => "test.rb"
-    assert_equal "test.rb", @config.repository
+    @config = Capistrano::Configuration.new
   end
 
-  def test_load
-    file = File.dirname(__FILE__) + "/fixtures/config.rb"
-    @config.load file
-    assert_equal "1/2/foo", @config.repository
-    assert_equal "./#{file}.example.com", @config.gateway
-    assert_equal 1, @config.roles[:web].length
-  end
-
-  def test_load_explicit_name
-    file = File.dirname(__FILE__) + "/fixtures/config.rb"
-    @config.load file, :name => "config"
-    assert_equal "1/2/foo", @config.repository
-    assert_equal "config.example.com", @config.gateway
-    assert_equal 1, @config.roles[:web].length
-  end
-
-  def test_load_file_implied_name
-    file = File.dirname(__FILE__) + "/fixtures/config.rb"
-    @config.load :file => file
-    assert_equal "1/2/foo", @config.repository
-    assert_equal "./#{file}.example.com", @config.gateway
-    assert_equal 1, @config.roles[:web].length
-  end
-
-  def test_load_file_explicit_name
-    file = File.dirname(__FILE__) + "/fixtures/config.rb"
-    @config.load :file => file, :name => "config"
-    assert_equal "1/2/foo", @config.repository
-    assert_equal "config.example.com", @config.gateway
-    assert_equal 1, @config.roles[:web].length
-  end
-
-  def test_load_proc_explicit
-    @config.load :proc => Proc.new { set :gateway, "nifty.zoo.test" }
-    assert_equal "nifty.zoo.test", @config.gateway
-  end
-
-  def test_load_proc_implicit
-    @config.load { set :gateway, "nifty.zoo.test" }
-    assert_equal "nifty.zoo.test", @config.gateway
-  end
-
-  def test_task_without_options
-    block = Proc.new { }
-    @config.task :hello, &block
-    assert_equal 1, @config.actor.tasks.length
-    assert_equal :hello, @config.actor.tasks[0][0]
-    assert_equal({}, @config.actor.tasks[0][1])
-    assert_equal block, @config.actor.tasks[0][2]
-  end
-
-  def test_task_with_options
-    block = Proc.new { }
-    @config.task :hello, :roles => :app, &block
-    assert_equal 1, @config.actor.tasks.length
-    assert_equal :hello, @config.actor.tasks[0][0]
-    assert_equal({:roles => :app}, @config.actor.tasks[0][1])
-    assert_equal block, @config.actor.tasks[0][2]
-  end
-
-  def test_source
-    @config.set :repository, "/foo/bar/baz"
-    assert_equal "/foo/bar/baz", @config.source.configuration.repository
-  end
+  def test_connections_execution_loading_namespaces_roles_and_variables_modules_should_integrate_correctly
+    Capistrano::SSH.expects(:connect).with { |s,c| s.host == "www.capistrano.test" && c == @config }.returns(:session)
+    Capistrano::Command.expects(:process).with("echo 'hello world'", [:session], :logger => @config.logger)
 
-  def test_releases_path_default
-    @config.set :deploy_to, "/start/of/path"
-    assert_equal "/start/of/path/releases", @config.releases_path
-  end
-
-  def test_releases_path_custom
-    @config.set :deploy_to, "/start/of/path"
-    @config.set :version_dir, "right/here"
-    assert_equal "/start/of/path/right/here", @config.releases_path
-  end
-
-  def test_current_path_default
-    @config.set :deploy_to, "/start/of/path"
-    assert_equal "/start/of/path/current", @config.current_path
-  end
-
-  def test_current_path_custom
-    @config.set :deploy_to, "/start/of/path"
-    @config.set :current_dir, "right/here"
-    assert_equal "/start/of/path/right/here", @config.current_path
-  end
-
-  def test_shared_path_default
-    @config.set :deploy_to, "/start/of/path"
-    assert_equal "/start/of/path/shared", @config.shared_path
-  end
+    @config.load do
+      role :test, "www.capistrano.test"
+      set  :message, "hello world"
+      namespace :testing do
+        task :example, :roles => :test do
+          run "echo '#{message}'"
+        end
+      end
+    end
 
-  def test_shared_path_custom
-    @config.set :deploy_to, "/start/of/path"
-    @config.set :shared_dir, "right/here"
-    assert_equal "/start/of/path/right/here", @config.shared_path
+    @config.testing.example
   end
 
-  def test_release_path_implicit
-    @config.set :deploy_to, "/start/of/path"
-    assert_equal "/start/of/path/releases/#{@config.now.strftime("%Y%m%d%H%M%S")}", @config.release_path
-  end
+  def test_tasks_in_nested_namespace_should_be_able_to_call_tasks_in_same_namespace
+    @config.namespace(:outer) do
+      task(:first) { set :called_first, true }
+      namespace(:inner) do
+        task(:first) { set :called_inner_first, true }
+        task(:second) { first }
+      end
+    end
 
-  def test_release_path_explicit
-    @config.set :deploy_to, "/start/of/path"
-    assert_equal "/start/of/path/releases/silly", @config.release_path("silly")
+    @config.outer.inner.second
+    assert !@config[:called_first]
+    assert @config[:called_inner_first]
   end
 
-  def test_task_description
-    block = Proc.new { }
-    @config.desc "A sample task"
-    @config.task :hello, &block
-    assert_equal "A sample task", @config.actor.tasks[0][1][:desc]
-  end
+  def test_tasks_in_nested_namespace_should_be_able_to_call_tasks_in_parent_namespace
+    @config.namespace(:outer) do
+      task(:first) { set :called_first, true }
+      namespace(:inner) do
+        task(:second) { first }
+      end
+    end
 
-  def test_set_scm_to_darcs
-    @config.set :scm, :darcs
-    assert_equal "Capistrano::SCM::Darcs", @config.source.class.name
+    @config.outer.inner.second
+    assert @config[:called_first]
   end
 
-  def test_set_scm_to_subversion
-    @config.set :scm, :subversion
-    assert_equal "Capistrano::SCM::Subversion", @config.source.class.name
-  end
+  def test_tasks_in_nested_namespace_should_be_able_to_call_shadowed_tasks_in_parent_namespace
+    @config.namespace(:outer) do
+      task(:first) { set :called_first, true }
+      namespace(:inner) do
+        task(:first) { set :called_inner_first, true }
+        task(:second) { parent.first }
+      end
+    end
 
-  def test_get_proc_variable_sets_original_value_hash
-    @config.set(:proc) { "foo" }
-    assert_nil @config[:original_value][:proc]
-    assert_equal "foo", @config[:proc]
-    assert_not_nil @config[:original_value][:proc]
-    assert @config[:original_value][:proc].respond_to?(:call)
+    @config.outer.inner.second
+    assert @config[:called_first]
+    assert !@config[:called_inner_first]
   end
 
-  def test_require
-    @config.require "#{File.dirname(__FILE__)}/fixtures/custom"
-    assert_equal "foo", @config.gateway
+  def test_hooks_for_default_task_should_be_found_if_named_after_the_namespace
+    @config.namespace(:outer) do
+      task(:default) { set :called_default, true }
+      task(:before_outer) { set :called_before_outer, true }
+      task(:after_outer) { set :called_after_outer, true }
+    end
+    @config.outer.default
+    assert @config[:called_before_outer]
+    assert @config[:called_default]
+    assert @config[:called_after_outer]
   end
 end

data/test/deploy/scm/base_test.rb

@@ -0,0 +1,55 @@
+require "#{File.dirname(__FILE__)}/../../utils"
+require 'capistrano/recipes/deploy/scm/base'
+
+class DeploySCMBaseTest < Test::Unit::TestCase
+  class TestSCM < Capistrano::Deploy::SCM::Base
+    default_command "floopy"
+  end
+
+  def setup
+    @config = { }
+    def @config.exists?(name); key?(name); end
+
+    @source = TestSCM.new(@config)
+  end
+
+  def test_command_should_default_to_default_command
+    assert_equal "floopy", @source.command
+    @source.local { assert_equal "floopy", @source.command }
+  end
+
+  def test_command_should_use_scm_command_if_available
+    @config[:scm_command] = "/opt/local/bin/floopy"
+    assert_equal "/opt/local/bin/floopy", @source.command
+  end
+
+  def test_command_should_use_scm_command_in_local_mode_if_local_scm_command_not_set
+    @config[:scm_command] = "/opt/local/bin/floopy"
+    @source.local { assert_equal "/opt/local/bin/floopy", @source.command }
+  end
+
+  def test_command_should_use_local_scm_command_in_local_mode_if_local_scm_command_is_set
+    @config[:scm_command] = "/opt/local/bin/floopy"
+    @config[:local_scm_command] = "/usr/local/bin/floopy"
+    assert_equal "/opt/local/bin/floopy", @source.command
+    @source.local { assert_equal "/usr/local/bin/floopy", @source.command }
+  end
+
+  def test_command_should_use_default_if_scm_command_is_default
+    @config[:scm_command] = :default
+    assert_equal "floopy", @source.command
+  end
+
+  def test_command_should_use_default_in_local_mode_if_local_scm_command_is_default
+    @config[:scm_command] = "/foo/bar/floopy"
+    @config[:local_scm_command] = :default
+    @source.local { assert_equal "floopy", @source.command }
+  end
+
+  def test_local_mode_proxy_should_treat_messages_as_being_in_local_mode
+    @config[:scm_command] = "/foo/bar/floopy"
+    @config[:local_scm_command] = :default
+    assert_equal "floopy", @source.local.command
+    assert_equal "/foo/bar/floopy", @source.command
+  end
+end

data/test/deploy/strategy/copy_test.rb

@@ -0,0 +1,146 @@
+require "#{File.dirname(__FILE__)}/../../utils"
+require 'capistrano/logger'
+require 'capistrano/recipes/deploy/strategy/copy'
+
+class DeployStrategyCopyTest < Test::Unit::TestCase
+  def setup
+    @config = { :logger => Capistrano::Logger.new(:output => StringIO.new),
+                :releases_path => "/u/apps/test/releases",
+                :release_path => "/u/apps/test/releases/1234567890",
+                :real_revision => "154" }
+    @source = mock("source")
+    @config.stubs(:source).returns(@source)
+    @strategy = Capistrano::Deploy::Strategy::Copy.new(@config)
+  end
+
+  def test_deploy_with_defaults_should_use_tar_gz_and_checkout
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    Dir.expects(:chdir).with("/temp/dir").yields
+    @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
+
+    @strategy.expects(:system).with(:local_checkout)
+    @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
+    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.gz")
+    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /tmp/1234567890.tar.gz && rm /tmp/1234567890.tar.gz")
+
+    mock_file = mock("file")
+    mock_file.expects(:puts).with("154")
+    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
+    File.expects(:read).with("/temp/dir/1234567890.tar.gz").returns(:mock_file_contents)
+
+    FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.gz")
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+
+    @strategy.deploy!
+  end
+
+  def test_deploy_with_export_should_use_tar_gz_and_export
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    Dir.expects(:chdir).with("/temp/dir").yields
+    @config[:copy_strategy] = :export
+    @source.expects(:export).with("154", "/temp/dir/1234567890").returns(:local_export)
+
+    @strategy.expects(:system).with(:local_export)
+    @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
+    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.gz")
+    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /tmp/1234567890.tar.gz && rm /tmp/1234567890.tar.gz")
+
+    mock_file = mock("file")
+    mock_file.expects(:puts).with("154")
+    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
+    File.expects(:read).with("/temp/dir/1234567890.tar.gz").returns(:mock_file_contents)
+
+    FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.gz")
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+
+    @strategy.deploy!
+  end
+
+  def test_deploy_with_zip_should_use_zip_and_checkout
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    Dir.expects(:chdir).with("/temp/dir").yields
+    @config[:copy_compression] = :zip
+    @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
+
+    @strategy.expects(:system).with(:local_checkout)
+    @strategy.expects(:system).with("zip -qr 1234567890.zip 1234567890")
+    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.zip")
+    @strategy.expects(:run).with("cd /u/apps/test/releases && unzip -q /tmp/1234567890.zip && rm /tmp/1234567890.zip")
+
+    mock_file = mock("file")
+    mock_file.expects(:puts).with("154")
+    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
+    File.expects(:read).with("/temp/dir/1234567890.zip").returns(:mock_file_contents)
+
+    FileUtils.expects(:rm).with("/temp/dir/1234567890.zip")
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+
+    @strategy.deploy!
+  end
+
+  def test_deploy_with_bzip2_should_use_zip_and_checkout
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    Dir.expects(:chdir).with("/temp/dir").yields
+    @config[:copy_compression] = :bzip2
+    @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
+
+    @strategy.expects(:system).with(:local_checkout)
+    @strategy.expects(:system).with("tar cjf 1234567890.tar.bz2 1234567890")
+    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.bz2")
+    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xjf /tmp/1234567890.tar.bz2 && rm /tmp/1234567890.tar.bz2")
+
+    mock_file = mock("file")
+    mock_file.expects(:puts).with("154")
+    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
+    File.expects(:read).with("/temp/dir/1234567890.tar.bz2").returns(:mock_file_contents)
+
+    FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.bz2")
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+
+    @strategy.deploy!
+  end
+
+  def test_deploy_with_custom_copy_dir_should_use_that_as_tmpdir
+    Dir.expects(:tmpdir).never
+    Dir.expects(:chdir).with("/other/path").yields
+    @config[:copy_dir] = "/other/path"
+    @source.expects(:checkout).with("154", "/other/path/1234567890").returns(:local_checkout)
+
+    @strategy.expects(:system).with(:local_checkout)
+    @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
+    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.gz")
+    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /tmp/1234567890.tar.gz && rm /tmp/1234567890.tar.gz")
+
+    mock_file = mock("file")
+    mock_file.expects(:puts).with("154")
+    File.expects(:open).with("/other/path/1234567890/REVISION", "w").yields(mock_file)
+    File.expects(:read).with("/other/path/1234567890.tar.gz").returns(:mock_file_contents)
+
+    FileUtils.expects(:rm).with("/other/path/1234567890.tar.gz")
+    FileUtils.expects(:rm_rf).with("/other/path/1234567890")
+
+    @strategy.deploy!
+  end
+
+  def test_deploy_with_copy_remote_dir_should_copy_to_that_dir
+    @config[:copy_remote_dir] = "/somewhere/else"
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    Dir.expects(:chdir).yields
+    @source.expects(:checkout).returns(:local_checkout)
+
+    @strategy.expects(:system).with(:local_checkout)
+    @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
+    @strategy.expects(:put).with(:mock_file_contents, "/somewhere/else/1234567890.tar.gz")
+    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /somewhere/else/1234567890.tar.gz && rm /somewhere/else/1234567890.tar.gz")
+
+    mock_file = mock("file")
+    mock_file.expects(:puts).with("154")
+    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
+    File.expects(:read).with("/temp/dir/1234567890.tar.gz").returns(:mock_file_contents)
+
+    FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.gz")
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+
+    @strategy.deploy!
+  end
+end