sunshine 1.0.0.pre

data/test/unit/test_healthcheck.rb

@@ -0,0 +1,70 @@
+require 'test/test_helper'
+
+class TestHealthcheck < Test::Unit::TestCase
+
+  def setup
+    @remote_shell = mock_remote_shell
+    @health = Sunshine::Healthcheck.new "somepath", @remote_shell
+
+    @test_disabled = "test -f #{@health.disabled_file}"
+    @test_enabled  = "test -f #{@health.enabled_file}"
+  end
+
+
+  def test_initialize
+    assert_equal @remote_shell, @health.shell
+    assert_equal "somepath/health.enabled", @health.enabled_file
+    assert_equal "somepath/health.disabled", @health.disabled_file
+  end
+
+
+  def test_disable
+    @health.disable
+
+    cmd = "touch #{@health.disabled_file} && rm -f #{@health.enabled_file}"
+    assert_ssh_call cmd
+  end
+
+
+  def test_enable
+    @health.enable
+
+    cmd = "rm -f #{@health.disabled_file} && touch #{@health.enabled_file}"
+    assert_ssh_call cmd
+  end
+
+
+  def test_remove
+    @health.remove
+
+    cmd = "rm -f #{@health.disabled_file} #{@health.enabled_file}"
+    assert_ssh_call cmd
+  end
+
+
+  def test_status_down
+    @remote_shell.set_mock_response 1,
+      @test_disabled => [:err, ""],
+      @test_enabled  => [:err, ""]
+
+    assert_equal(:down, @health.status)
+
+    assert_ssh_call @test_disabled
+    assert_ssh_call @test_enabled
+  end
+
+
+  def test_status_ok
+    @remote_shell.set_mock_response 1, @test_disabled => [:err, ""]
+    @remote_shell.set_mock_response 0, @test_enabled  => [:out, ""]
+
+    assert_equal(:enabled, @health.status)
+  end
+
+
+  def test_status_disabled
+    @remote_shell.set_mock_response 0, @test_disabled => [:out, ""]
+
+    assert_equal(:disabled, @health.status)
+  end
+end

data/test/unit/test_nginx.rb

@@ -0,0 +1,107 @@
+require 'test/test_helper'
+
+class TestNginx < Test::Unit::TestCase
+
+  def setup
+    @app = Sunshine::App.new TEST_APP_CONFIG_FILE
+    @app.server_apps.first.extend MockOpen4
+    @app.server_apps.first.shell.extend MockOpen4
+    use_remote_shell @app.server_apps.first.shell
+
+    @passenger = Sunshine::Nginx.new @app
+    @nginx = Sunshine::Nginx.new @app, :port => 5000, :point_to => @passenger
+    @gemout = <<-STR
+
+*** LOCAL GEMS ***
+
+passenger (2.2.4)
+    Author: Phusion - http://www.phusion.nl/
+    Rubyforge: http://rubyforge.org/projects/passenger
+    Homepage: http://www.modrails.com/
+    Installed at: /Library/Ruby/Gems/1.8
+
+    Apache module for Ruby on Rails support.
+    STR
+  end
+
+
+  def test_cmd
+    ds = @nginx.app.server_apps.first.shell
+    ds.set_mock_response 0, "gem list passenger -d" => [:out, @gemout]
+
+    @nginx.start
+    @nginx.stop
+
+    assert_ssh_call start_cmd(@passenger)
+    assert_ssh_call stop_cmd(@passenger)
+  end
+
+
+  def test_custom_sudo_cmd
+    ds = @nginx.app.server_apps.first.shell
+    ds.set_mock_response 0, "gem list passenger -d" => [:out, @gemout]
+
+    @nginx.sudo = "someuser"
+
+    @nginx.start
+    @nginx.stop
+
+    assert_ssh_call start_cmd(@passenger), ds, :sudo => @nginx.sudo
+    assert_ssh_call stop_cmd(@passenger), ds, :sudo => @nginx.sudo
+  end
+
+
+  def test_sudo_cmd
+    ds = @passenger.app.server_apps.first.shell
+    ds.set_mock_response 0, "gem list passenger -d" => [:out, @gemout]
+
+    @passenger.start
+    @passenger.stop
+
+    assert_equal true, @passenger.sudo
+    assert_ssh_call start_cmd(@passenger), ds, :sudo => true
+    assert_ssh_call stop_cmd(@passenger), ds, :sudo => true
+  end
+
+
+  def test_setup_passenger
+    ds = @passenger.app.server_apps.first.shell
+    ds.set_mock_response 0, "gem list passenger -d" => [:out, @gemout]
+
+    @passenger.setup do |ds, binder|
+      assert binder.sudo
+      assert binder.use_passenger?
+      assert_equal "/Library/Ruby/Gems/1.8/gems/passenger-2.2.4",
+        binder.passenger_root
+    end
+  end
+
+
+  def test_setup
+    ds = @nginx.app.server_apps.first.shell
+    ds.set_mock_response 0, "gem list passenger -d" => [:out, @gemout]
+
+    @nginx.setup do |ds, binder|
+      assert !binder.sudo
+      assert !binder.use_passenger?
+      assert_equal "/Library/Ruby/Gems/1.8/gems/passenger-2.2.4",
+        binder.passenger_root
+    end
+  end
+
+
+  ## Helper methods
+
+  def start_cmd svr, sudo=false
+    sudo = sudo ? "sudo " : ""
+    "#{sudo}#{svr.bin} -c #{svr.config_file_path}"
+  end
+
+
+  def stop_cmd svr, sudo=false
+    sudo = sudo ? "sudo " : ""
+    cmd = "#{sudo }test -f #{svr.pid} && kill -QUIT $(cat #{svr.pid})"+
+      " || echo 'No #{svr.name} process to stop for #{svr.app.name}';"
+    cmd << "sleep 2 ; rm -f #{svr.pid};"
+  end
+end

data/test/unit/test_rainbows.rb

@@ -0,0 +1,26 @@
+require 'test/test_helper'
+require 'test/unit/test_unicorn'
+
+class TestRainbows < TestUnicorn
+
+  def setup
+    super
+    @app.each{|sa| sa.shell.extend MockOpen4}
+    @server = Sunshine::Rainbows.new @app
+  end
+
+
+  def test_setup
+    @server.use_concurrency :model => :TreadSpawn, :timeout => 1
+    @server.setup do |ds, binder|
+      assert_equal @server.concurrency, binder.concurrency
+    end
+  end
+
+
+  def test_use_concurrency
+    concurrency = {:model => :ModelName, :timeout => 1, :connections => 500}
+    @server.use_concurrency concurrency
+    assert_equal concurrency, @server.concurrency
+  end
+end

data/test/unit/test_remote_shell.rb

@@ -0,0 +1,102 @@
+require 'test/test_helper'
+
+class TestRemoteShell < Test::Unit::TestCase
+
+  def setup
+    mock_remote_shell_popen4
+
+    @app = Sunshine::App.new TEST_APP_CONFIG_FILE
+
+    @host = "user@some_server.com"
+
+    @remote_shell = mock_remote_shell @host
+  end
+
+  def teardown
+    @remote_shell.disconnect
+  end
+
+  def test_connect
+    assert_ssh_call \
+      "echo connected; echo ready; for (( ; ; )); do sleep 10; done"
+    assert @remote_shell.connected?
+  end
+
+  def test_disconnect
+    @remote_shell.disconnect
+    assert !@remote_shell.connected?
+  end
+
+  def test_call
+    @remote_shell.call "echo 'line1'; echo 'line2'"
+    assert_ssh_call "echo 'line1'; echo 'line2'"
+
+    @remote_shell.sudo = "sudouser"
+    @remote_shell.call "sudocall"
+    assert_ssh_call "sudocall", @remote_shell, :sudo => "sudouser"
+  end
+
+  def test_call_with_stderr
+    @remote_shell.set_mock_response 1, :err => 'this is an error'
+    cmd = "echo 'this is an error'"
+    @remote_shell.call cmd
+    raise "Didn't raise CmdError on stderr"
+  rescue Sunshine::CmdError => e
+    ssh_cmd = @remote_shell.send(:ssh_cmd, cmd).join(" ")
+    assert_equal "Execution failed with status 1: #{ssh_cmd}", e.message
+  end
+
+  def test_upload
+    @remote_shell.upload "test/fixtures/sunshine_test", "sunshine_test"
+    assert_rsync "test/fixtures/sunshine_test",
+      "#{@remote_shell.host}:sunshine_test"
+
+    @remote_shell.sudo = "blah"
+    @remote_shell.upload "test/fixtures/sunshine_test", "sunshine_test"
+    assert_rsync "test/fixtures/sunshine_test",
+      "#{@remote_shell.host}:sunshine_test", @remote_shell, "blah"
+  end
+
+  def test_download
+    @remote_shell.download "sunshine_test", "."
+    assert_rsync "#{@remote_shell.host}:sunshine_test", "."
+
+    @remote_shell.download "sunshine_test", ".", :sudo => "sudouser"
+    assert_rsync "#{@remote_shell.host}:sunshine_test", ".",
+      @remote_shell, "sudouser"
+  end
+
+  def test_make_file
+    @remote_shell.make_file("some_dir/sunshine_test_file", "test data")
+    tmp_file = "#{Sunshine::TMP_DIR}/sunshine_test_file"
+    tmp_file = Regexp.escape tmp_file
+    assert_rsync(/^#{tmp_file}_[0-9]+/,
+      "#{@remote_shell.host}:some_dir/sunshine_test_file")
+  end
+
+  def test_os_name
+    @remote_shell.os_name
+    assert_ssh_call "uname -s"
+  end
+
+  def test_equality
+    ds_equal = Sunshine::RemoteShell.new @host
+    ds_diff1 = Sunshine::RemoteShell.new @host, :user => "blarg"
+    ds_diff2 = Sunshine::RemoteShell.new "some_other_host"
+
+    assert_equal ds_equal, @remote_shell
+    assert_equal ds_diff1, @remote_shell
+    assert ds_diff2 != @remote_shell
+  end
+
+  def test_file?
+    @remote_shell.file? "some/file/path"
+    assert_ssh_call "test -f some/file/path"
+  end
+
+  def test_symlink
+    @remote_shell.symlink "target_file", "sym_name"
+    assert_ssh_call "ln -sfT target_file sym_name"
+  end
+
+end

data/test/unit/test_repo.rb

@@ -0,0 +1,42 @@
+require 'test/test_helper'
+
+class TestRepo < Test::Unit::TestCase
+
+  def setup
+    @svn_url = "https://svnurl/to/repo/tag"
+    @repo = Sunshine::Repo.new_of_type(:svn, @svn_url)
+    @repo.extend MockObject
+  end
+
+  def test_new_of_type
+    repo = Sunshine::Repo.new_of_type :svn, @svn_url
+    assert_equal Sunshine::SvnRepo, repo.class
+    assert_equal @svn_url, repo.url
+
+    repo = Sunshine::Repo.new_of_type "", @svn_url
+    assert_equal Sunshine::Repo, repo.class
+  end
+
+
+  def test_get_repo_info
+    ds = mock_remote_shell
+    begin
+      Sunshine::Repo.new(@svn_url).get_repo_info ds, "path/to/repo"
+      raise "Didn't raise RepoError when it should have"
+    rescue Sunshine::RepoError => e
+      msg = "The 'get_info' method must be implemented by child classes"
+      assert_equal msg, e.message
+    end
+  end
+
+
+  def test_checkout_to
+    begin
+      Sunshine::Repo.new(@svn_url).checkout_to "somepath", mock_remote_shell
+      raise "Didn't raise RepoError on checkout_cmd"
+    rescue Sunshine::RepoError => e
+      msg = "The 'do_checkout' method must be implemented by child classes"
+      assert_equal msg, e.message
+    end
+  end
+end

data/test/unit/test_server.rb

@@ -0,0 +1,324 @@
+require 'test/test_helper'
+
+class TestServer < Test::Unit::TestCase
+
+  class Server < Sunshine::Server
+    def start_cmd
+      "test start cmd"
+    end
+
+    def stop_cmd
+      "test stop cmd"
+    end
+  end
+
+
+  def setup
+    mock_remote_shell_popen4
+    @app    = Sunshine::App.new(TEST_APP_CONFIG_FILE).extend MockObject
+    @server_app = @app.server_apps.first.extend MockObject
+    @app.server_apps.first.shell.extend MockObject
+
+    @server = Server.new @app
+
+    @rainbows = Sunshine::Rainbows.new(@app).extend MockObject
+    use_remote_shell @server_app.shell
+  end
+
+
+  def test_initialize
+    assert_server_init
+
+    config = {
+      :point_to => @server,
+      :pid      => "path/to/pid",
+      :bin      => "path/to/bin",
+      :port     => 1234,
+      :processes => 10,
+      :server_name => "serv1.com",
+      :server_apps => ["remote_shell_test"],
+      :config_template => "template.erb",
+      :config_path => "path/to/config",
+      :config_file => "conf_filename.conf",
+      :log_path => "path/to/logs",
+      :sudo     => "sudouser"
+    }
+
+    svr = Server.new @app, config
+
+    config[:target] = config[:point_to]
+    config[:stderr] = "#{config[:log_path]}/server_stderr.log"
+    config[:stdout] = "#{config[:log_path]}/server_stdout.log"
+
+    assert_server_init svr, config
+  end
+
+
+  def test_setup
+    server = @rainbows
+
+    server.setup do |sa, binder|
+      assert_equal @server_app, sa
+
+      assert_equal sa.shell,      binder.shell
+      assert_equal sa.shell.host, binder.server_name
+      assert_equal @rainbows.send(:pick_sudo, sa.shell), binder.sudo
+    end
+
+    args = ["rainbows"]
+    server.each_server_app do |sa|
+      assert sa.method_called?(:install_deps, :args => args)
+    end
+
+    assert server.method_called?(:upload_config_files)
+
+    assert_ssh_call "mkdir -p #{server.send(:remote_dirs).join(" ")}"
+
+    assert_rsync(/rainbows\.conf/, "some_server.com:"+
+      "/usr/local/my_user/other_app/current/daemons/rainbows/rainbows.conf")
+
+    assert server.has_setup?
+  end
+
+
+  def test_has_setup?
+    server = @rainbows
+    assert_equal nil, server.instance_variable_get("@setup_successful")
+
+    @server_app.shell.mock :file?, :args => [server.config_file_path],
+                                   :return => false
+
+    assert_equal false, server.has_setup?
+
+    @server_app.shell.mock :file?, :args => [server.config_file_path],
+                                   :return => true
+
+    assert_equal false, server.has_setup?
+    assert_equal true,  server.has_setup?(true)
+  end
+
+
+  def test_start
+    server = @rainbows
+    @server_app.shell.mock :file?, :args => [server.config_file_path],
+                                   :return => false
+
+    server.start do |ds|
+      assert_equal @server_app, ds
+    end
+
+    assert server.method_called?(:setup)
+
+    assert_ssh_call server.start_cmd
+  end
+
+
+  def test_start_missing_setup
+    server = @rainbows
+    @server_app.shell.mock :file?, :args => [server.config_file_path],
+                                   :return => true
+
+    server.start
+
+    assert !server.method_called?(:setup)
+
+    assert_ssh_call server.start_cmd
+  end
+
+
+  def test_stop
+    server = @rainbows
+
+    server.stop do |ds|
+      assert_equal @server_app, ds
+    end
+
+    assert_ssh_call server.stop_cmd
+  end
+
+
+  def test_restart
+    server = @rainbows
+
+    server.restart
+
+    assert_ssh_call server.restart_cmd
+  end
+
+
+  def test_restart_missing_setup
+    server = @rainbows
+    @server_app.shell.mock :file?, :args => [server.config_file_path],
+                                   :return => true
+
+    server.restart
+
+    assert !server.method_called?(:setup)
+
+    assert_ssh_call server.restart_cmd
+  end
+
+
+  def test_restart_with_cmd
+    server = @rainbows
+    server.instance_variable_set("@restart_cmd", "RESTART!!1!")
+
+    @server_app.shell.mock :file?, :args => [server.config_file_path],
+                                   :return => false
+
+    server.restart
+
+    assert server.method_called?(:setup)
+    assert_ssh_call server.restart_cmd
+  end
+
+
+  def test_missing_start_stop_cmd
+    server = Sunshine::Server.new @app
+
+    begin
+      server.start_cmd
+      raise "Should have thrown CriticalDeployError but didn't :("
+    rescue Sunshine::CriticalDeployError => e
+      assert_equal "@start_cmd undefined. Can't start server", e.message
+    end
+
+    begin
+      server.stop_cmd
+      raise "Should have thrown CriticalDeployError but didn't :("
+    rescue Sunshine::CriticalDeployError => e
+      assert_equal "@stop_cmd undefined. Can't stop server", e.message
+    end
+  end
+
+
+  def test_log_files
+    @server.log_files :test_log => "/path/test_log.log",
+                      :another_test => "/path/another_test.log"
+
+    assert_equal "/path/test_log.log", @server.log_file(:test_log)
+    assert_equal "/path/another_test.log", @server.log_file(:another_test)
+  end
+
+
+  def test_upload_config_files
+    server = @rainbows
+
+    server.mock :config_template_files,
+      :return => ["rainbows.conf.erb", "test/non_erb.conf"]
+
+    @app.mock :build_erb, :return => "test_config"
+
+    server.upload_config_files @server_app.shell
+
+    args = ["#{server.config_path}/rainbows.conf", "test_config"]
+    assert @server_app.shell.method_called?(:make_file, :args => args)
+
+    args = ["test/non_erb.conf", "#{server.config_path}/non_erb.conf"]
+    assert @server_app.shell.method_called?(:upload, :args => args)
+  end
+
+
+  def test_config_template_files
+    files =
+      Dir["#{Sunshine::ROOT}/templates/rainbows/*"].select{|f| File.file?(f)}
+    assert_equal files, @rainbows.config_template_files
+  end
+
+
+  def test_remote_dirs
+    server = @rainbows
+
+    dirs = server.send :remote_dirs
+
+    assert_dir_in dirs, server.pid
+    assert_dir_in dirs, server.config_file_path
+    assert_dir_in dirs, server.log_file(:stderr)
+    assert_dir_in dirs, server.log_file(:stdout)
+  end
+
+
+  def test_register_after_user_script
+    server = @rainbows
+
+    assert @app.method_called?(:after_user_script) # called on Server#init
+
+    @app.run_post_user_lambdas
+
+    server.each_server_app do |sa|
+
+      assert sa.scripts[:start].include?(server.start_cmd)
+      assert sa.scripts[:stop].include?(server.stop_cmd)
+      assert sa.scripts[:status].include?(server.status_cmd)
+      assert sa.scripts[:restart].include?(server.restart_cmd)
+
+      assert_equal server.port, sa.info[:ports][server.pid]
+    end
+  end
+
+
+  def test_pick_sudo
+    ds = @rainbows.app.server_apps.first.shell
+    assert_equal nil, @rainbows.send(:pick_sudo, ds)
+
+    @rainbows.sudo = true
+    assert_equal true, @rainbows.send(:pick_sudo, ds)
+
+    ds.sudo = true
+    @rainbows.sudo = false
+    assert_equal true, @rainbows.send(:pick_sudo, ds)
+
+    ds.sudo = "blah"
+    @rainbows.sudo = true
+    assert_equal "blah", @rainbows.send(:pick_sudo, ds)
+
+    @rainbows.sudo = "local"
+    assert_equal "local", @rainbows.send(:pick_sudo, ds)
+  end
+
+  ##
+  # Helper methods
+
+  def assert_dir_in arr, file
+    assert arr.include?(File.dirname(file))
+  end
+
+
+  def assert_server_init server=@server, user_config={}
+    config = {
+      :app => @app,
+      :target => @app,
+      :name => "server",
+      :pid => "#{@app.shared_path}/pids/server.pid",
+      :bin => "server",
+      :port => 80,
+      :processes => 1,
+      :server_name => nil,
+      :config_file => "server.conf",
+      :config_path => "#{@app.current_path}/daemons/server",
+      :config_template => "#{Sunshine::ROOT}/templates/server/*",
+      :stderr => "#{@app.log_path}/server_stderr.log",
+      :stdout => "#{@app.log_path}/server_stdout.log"
+    }.merge(user_config)
+
+    assert_equal config[:app],         server.app
+    assert_equal config[:bin],         server.bin
+    assert_equal config[:pid],         server.pid
+    assert_equal config[:port],        server.port
+    assert_equal config[:name],        server.name
+    assert_equal config[:target],      server.target
+    assert_equal config[:processes],   server.processes
+    assert_equal config[:server_name], server.server_name
+
+    assert_equal config[:config_path],     server.config_path
+    assert_equal config[:config_file],     server.config_file
+    assert_equal config[:config_template], server.config_template
+
+
+    assert_equal config[:stderr], server.log_file(:stderr)
+    assert_equal config[:stdout], server.log_file(:stdout)
+
+    config_file_path = "#{config[:config_path]}/#{config[:config_file]}"
+    assert_equal config_file_path, server.config_file_path
+  end
+end