sunshine 1.0.0.pre

data/test/unit/test_server_app.rb

@@ -0,0 +1,425 @@
+require 'test_helper'
+
+class TestServerApp < Test::Unit::TestCase
+
+  def setup
+    mock_svn_response
+
+    @app = mock_app
+    @app.repo.extend MockObject
+
+    @sa = Sunshine::ServerApp.new @app, mock_remote_shell
+    @sa.extend MockObject
+
+    use_remote_shell @sa.shell
+  end
+
+
+  def test_init
+    default_info = {:ports => {}}
+    assert_equal default_info, @sa.info
+
+    assert_equal @app, @sa.app
+    assert_equal Hash.new, @sa.scripts
+    assert_equal [:all], @sa.roles
+  end
+
+
+  def test_init_roles
+    sa = Sunshine::ServerApp.new @app, "host", :roles => "role1 role2"
+    assert_equal [:role1, :role2], sa.roles
+
+    sa = Sunshine::ServerApp.new @app, "host", :roles => %w{role3 role4}
+    assert_equal [:role3, :role4], sa.roles
+  end
+
+
+  def test_add_shell_paths
+    @sa.add_shell_paths "test/path1", "test/path2"
+    assert_equal "test/path1:test/path2:$PATH", @sa.shell_env['PATH']
+
+    @sa.add_shell_paths "test/path3", "test/path4"
+    assert_equal "test/path3:test/path4:test/path1:test/path2:$PATH",
+      @sa.shell_env['PATH']
+  end
+
+
+  def test_app_attr
+    sa_root_path   = "local/server_app/path"
+    sa_deploy_name = "local_deploy_name"
+
+    @sa = Sunshine::ServerApp.new "test", "host",
+      :root_path => sa_root_path, :deploy_name => sa_deploy_name
+
+    assert_equal sa_root_path,   @sa.root_path
+    assert_equal sa_deploy_name, @sa.deploy_name
+    assert_equal "test",         @sa.name
+
+    @sa.app = @app
+
+    assert_not_equal sa_root_path,   @sa.root_path
+    assert_not_equal sa_deploy_name, @sa.deploy_name
+    assert_not_equal "test",         @sa.name
+
+    assert_equal @app.root_path,   @sa.root_path
+    assert_equal @app.deploy_name, @sa.deploy_name
+    assert_equal @app.name,        @sa.name
+  end
+
+
+  def test_build_control_scripts
+    @sa.scripts[:start] << "start"
+    @sa.scripts[:stop]  << "stop"
+    @sa.scripts[:custom] << "custom"
+
+    @sa.build_control_scripts
+
+    [:start, :stop, :custom].each do |script|
+      content = @sa.make_bash_script script, @sa.scripts[script]
+      assert @sa.method_called?(:write_script, :args => [script, content])
+    end
+
+    content = @sa.make_env_bash_script
+    assert @sa.method_called?(:write_script, :args => ["env", content])
+
+    content = @sa.make_bash_script :restart,
+      ["#{@sa.app.root_path}/stop", "#{@sa.app.root_path}/start"]
+    assert @sa.method_called?(:write_script, :args => [:restart, content])
+  end
+
+
+  def test_build_deploy_info_file
+    args = ["#{@app.checkout_path}/info", @sa.get_deploy_info.to_yaml]
+
+    @sa.build_deploy_info_file
+
+    assert @sa.shell.method_called?(:make_file, :args => args)
+
+    args = ["#{@app.current_path}/info", "#{@app.root_path}/info"]
+
+    assert @sa.shell.method_called?(:symlink, :args => args)
+  end
+
+
+  def test_checkout_repo
+    @sa.checkout_repo @app.repo
+    repo = @sa.app.repo
+    args = [@app.checkout_path, @sa.shell]
+
+    assert repo.method_called?(:checkout_to, :args => args)
+
+    info = @app.repo.checkout_to @app.checkout_path, @sa.shell
+    assert_equal info, @sa.info[:scm]
+  end
+
+
+  def test_deploy_details
+    deploy_details = {:item => "thing"}
+    other_details  = {:key  => "value"}
+
+    @sa.shell.mock :call, :args   => ["cat #{@sa.current_path}/info"],
+                          :return => other_details.to_yaml
+
+    @sa.instance_variable_set "@deploy_details", deploy_details
+
+    assert_equal deploy_details, @sa.deploy_details
+    assert_equal other_details,  @sa.deploy_details(true)
+  end
+
+
+  def test_not_deployed?
+    @sa.mock :deploy_details, :args   => [true],
+                              :return => nil
+
+    assert_equal false, @sa.deployed?
+  end
+
+
+  def test_server_checked_deployed?
+    @sa.mock :deploy_details, :args   => [true],
+                              :return => {:deploy_name => @sa.deploy_name}
+
+    assert_equal true, @sa.deployed?
+  end
+
+
+  def test_cached_details_deployed?
+    @sa.instance_variable_set "@deploy_details", :deploy_name => @sa.deploy_name
+
+    assert_equal true, @sa.deployed?
+  end
+
+
+  def test_get_deploy_info
+    test_info = {
+      :deployed_at => Time.now.to_s,
+      :deployed_as => @sa.shell.call("whoami"),
+      :deployed_by => Sunshine.shell.user,
+      :deploy_name => File.basename(@app.checkout_path),
+      :roles       => @sa.roles,
+      :path        => @app.root_path
+    }.merge @sa.info
+
+    deploy_info = @sa.get_deploy_info
+
+    deploy_info.each do |key, val|
+      next if key == :deployed_at
+      assert_equal test_info[key], val
+    end
+  end
+
+
+  def test_install_deps
+    nginx_dep = Sunshine.dependencies.get 'nginx', :prefer => @sa.pkg_manager
+
+    @sa.install_deps "ruby", nginx_dep
+
+    assert_dep_install 'ruby'
+    assert_dep_install 'nginx'
+  end
+
+
+  def test_install_deps_bad_type
+    nginx_dep = Sunshine.dependencies.get 'nginx'
+
+    @sa.install_deps nginx_dep, :type => Sunshine::Gem
+    raise "Didn't raise missing dependency when it should have."
+
+  rescue Sunshine::DependencyLib::MissingDependency => e
+    assert_equal "No dependency 'nginx' [Sunshine::Gem]", e.message
+  end
+
+
+  def test_make_app_directories
+    @sa.make_app_directories
+
+    assert_server_call "mkdir -p #{@sa.directories.join(" ")}"
+  end
+
+
+  def test_make_bash_script
+    app_script = @sa.make_bash_script "blah", [1,2,3,4]
+
+    assert_bash_script "blah", [1,2,3,4], app_script
+  end
+
+
+  def test_make_env_bash_script
+    @sa.shell.env = {"BLAH" => "blarg", "HOME" => "/home/blah"}
+
+    test_script = "#!/bin/bash\nenv BLAH=blarg HOME=/home/blah \"$@\""
+
+    assert_equal test_script, @sa.make_env_bash_script
+  end
+
+
+  def test_rake
+    @sa.rake "db:migrate"
+
+    assert_dep_install 'rake'
+    assert_server_call "cd #{@app.checkout_path} && rake db:migrate"
+  end
+
+
+  def test_register_as_deployed
+    Sunshine::AddCommand.extend MockObject unless
+      MockObject === Sunshine::AddCommand
+
+    @sa.register_as_deployed
+
+    args = [@app.root_path, {'servers' => [@sa.shell]}]
+    assert Sunshine::AddCommand.method_called?(:exec, :args => args)
+  end
+
+
+  def test_remove_old_deploys
+    Sunshine.setup 'max_deploy_versions' => 3
+
+    deploys = %w{ploy1 ploy2 ploy3 ploy4 ploy5}
+
+    @sa.shell.mock :call,
+      :args   => ["ls -1 #{@app.deploys_path}"],
+      :return => "#{deploys.join("\n")}\n"
+
+    removed = deploys[0..1].map{|d| "#{@app.deploys_path}/#{d}"}
+
+    @sa.remove_old_deploys
+
+    assert_server_call "rm -rf #{removed.join(" ")}"
+  end
+
+
+  def test_remove_old_deploys_unnecessary
+    Sunshine.setup 'max_deploy_versions' => 5
+
+    deploys = %w{ploy1 ploy2 ploy3 ploy4 ploy5}
+
+    @sa.mock :call,
+      :args   => ["ls -1 #{@app.deploys_path}"],
+      :return => "#{deploys.join("\n")}\n"
+
+    removed = deploys[0..1].map{|d| "#{@app.deploys_path}/#{d}"}
+
+    @sa.remove_old_deploys
+
+    assert_not_called "rm -rf #{removed.join(" ")}"
+  end
+
+
+  def test_revert!
+    deploys = %w{ploy1 ploy2 ploy3 ploy4 ploy5}
+
+    @sa.shell.mock :call,
+      :args    => ["ls -rc1 #{@app.deploys_path}"],
+      :return => "#{deploys.join("\n")}\n"
+
+    @sa.revert!
+
+    assert_server_call "rm -rf #{@app.checkout_path}"
+    assert_server_call "ls -rc1 #{@app.deploys_path}"
+
+    last_deploy = "#{@app.deploys_path}/ploy5"
+    assert_server_call "ln -sfT #{last_deploy} #{@app.current_path}"
+
+    assert @sa.method_called?(:start, :args =>[:force => true])
+  end
+
+
+  def test_no_previous_revert!
+    @sa.shell.mock :call,
+      :args    => ["ls -rc1 #{@app.deploys_path}"],
+      :return => "\n"
+
+    @sa.revert!
+
+    assert_server_call "rm -rf #{@app.checkout_path}"
+    assert_server_call "ls -rc1 #{@app.deploys_path}"
+  end
+
+
+  def test_run_bundler
+    @sa.run_bundler
+
+    assert_dep_install 'bundler'
+    assert_server_call "cd #{@app.checkout_path} && gem bundle"
+  end
+
+
+  def test_run_geminstaller
+    @sa.run_geminstaller
+
+    assert_dep_install 'geminstaller'
+    assert_server_call "cd #{@app.checkout_path} && geminstaller -e"
+  end
+
+
+  def test_sass
+    sass_files = %w{file1 file2 file3}
+
+    @sa.sass(*sass_files)
+
+    assert_dep_install 'haml'
+
+    sass_files.each do |file|
+      sass_file = "public/stylesheets/sass/#{file}.sass"
+      css_file  = "public/stylesheets/#{file}.css"
+
+      assert_server_call \
+        "cd #{@app.checkout_path} && sass #{sass_file} #{css_file}"
+    end
+  end
+
+
+  def test_shell_env
+    assert_equal @sa.shell.env, @sa.shell_env
+  end
+
+
+  def test_symlink_current_dir
+    @sa.symlink_current_dir
+
+    assert_server_call "ln -sfT #{@app.checkout_path} #{@app.current_path}"
+  end
+
+
+  def test_upload_tasks
+    files = %w{task1 task2}
+
+    @sa.upload_tasks(*files)
+
+    assert_server_call "mkdir -p #{@app.checkout_path}/lib/tasks"
+
+    files.each do |f|
+      args = ["#{Sunshine::ROOT}/templates/tasks/#{f}.rake",
+              "#{@app.checkout_path}/lib/tasks/#{f}.rake"]
+
+      assert @sa.shell.method_called?(:upload, :args => args)
+    end
+  end
+
+
+  def test_upload_tasks_with_remote_path
+    files = %w{task1 task2}
+    path  = "/path/to/remote/tasks"
+
+    @sa.upload_tasks files[0], files[1], :remote_path => path
+
+    assert_server_call "mkdir -p #{path}"
+
+    files.each do |f|
+      args = ["#{Sunshine::ROOT}/templates/tasks/#{f}.rake",
+              "#{path}/#{f}.rake"]
+
+      assert @sa.shell.method_called?(:upload, :args => args)
+    end
+  end
+
+
+  def test_upload_tasks_with_local_path
+    files = %w{task1 task2}
+    path  = "/path/to/local/tasks"
+    args  = files.dup << {:local_path => path}
+
+    @sa.upload_tasks(*args)
+
+    assert_server_call "mkdir -p #{@sa.checkout_path}/lib/tasks"
+
+    files.each do |f|
+      args = ["#{path}/#{f}.rake",
+              "#{@sa.checkout_path}/lib/tasks/#{f}.rake"]
+
+      assert @sa.shell.method_called?(:upload, :args => args)
+    end
+  end
+
+
+  def test_upload_tasks_all
+    files = Dir.glob("templates/tasks/*").map{|f| File.basename(f, ".rake")}
+
+    @sa.upload_tasks
+
+    assert_server_call "mkdir -p #{@app.checkout_path}/lib/tasks"
+
+    files.each do |f|
+      args = ["#{Sunshine::ROOT}/templates/tasks/#{f}.rake",
+              "#{@app.checkout_path}/lib/tasks/#{f}.rake"]
+
+      assert @sa.shell.method_called?(:upload, :args => args)
+    end
+  end
+
+
+  def test_write_script
+    @sa.write_script "script_name", "script contents"
+
+    args = ["#{@app.checkout_path}/script_name",
+            "script contents", {:flags => "--chmod=ugo=rwx"}]
+
+    assert @sa.shell.method_called?(:make_file, :args => args)
+
+    args = ["#{@app.current_path}/script_name",
+            "#{@app.root_path}/script_name"]
+
+    assert @sa.shell.method_called?(:symlink, :args => args)
+  end
+end

data/test/unit/test_shell.rb

@@ -0,0 +1,97 @@
+require 'test/test_helper'
+
+class TestShell < Test::Unit::TestCase
+
+  def setup
+    @output = StringIO.new
+    @output.extend MockObject
+
+    @shell = Sunshine::Shell.new @output
+    @shell.extend MockOpen4
+
+    @shell.input.extend MockObject
+    @shell.input.mock :ask, :return => "someinput"
+  end
+
+
+  def test_initialize
+    assert_equal @output, @shell.output
+    assert_equal HighLine, @shell.input.class
+    assert_equal `whoami`.chomp, @shell.user
+    assert_equal `hostname`.chomp, @shell.host
+  end
+
+
+  def test_ask
+    @shell.ask "input something!"
+    assert 1, @shell.input.method_call_count(:ask)
+  end
+
+
+  def test_close
+    @shell.close
+    assert 1, @shell.output.method_call_count(:close)
+  end
+
+
+  def test_write
+    @shell.write "blah"
+    assert @output.method_called?(:write, :args => "blah")
+  end
+
+
+  def test_prompt_for_password
+    @shell.prompt_for_password
+
+    args = "#{@shell.user}@#{@shell.host} Password:"
+    assert @shell.input.method_called?(:ask, :args => args)
+    assert_equal "someinput", @shell.password
+  end
+
+
+  def test_execute
+    @shell.set_mock_response 0, "say hi"   => [:out, "hi\n"]
+
+    response = @shell.execute("say hi") do |stream, data|
+      assert_equal :out, stream
+      assert_equal "hi\n", data
+    end
+    assert_equal "hi", response
+  end
+
+
+  def test_execute_errorstatus
+    @shell.set_mock_response 1, "error me" => [:err, "ERROR'D!"]
+
+    begin
+      @shell.execute("error me") do |stream, data|
+        assert_equal :err, stream
+        assert_equal "ERROR'D!", data
+      end
+      raise "Didn't call CmdError when it should have"
+    rescue Sunshine::CmdError => e
+      msg = "Execution failed with status 1: error me"
+      assert_equal msg, e.message
+    end
+  end
+
+
+  def test_execute_stderronly
+    @shell.set_mock_response 0, "stderr"   => [:err, "fake error"]
+
+    response = @shell.execute("stderr") do |stream, data|
+      assert_equal :err, stream
+      assert_equal "fake error", data
+    end
+    assert_equal "", response
+  end
+
+
+  def test_execute_password_prompt
+    @shell.set_mock_response 0, "do that thing" => [:err, "Password:"]
+    @shell.input.mock :ask, :return => "new_password"
+
+    @shell.execute("do that thing")
+    assert_equal "new_password", @shell.password
+  end
+end

data/test/unit/test_sunshine.rb

@@ -0,0 +1,157 @@
+require 'test/test_helper'
+
+class TestSunshine < Test::Unit::TestCase
+
+  def setup
+  end
+
+
+  def test_default_config
+    config = Sunshine::DEFAULT_CONFIG
+    Sunshine.setup config
+
+    assert Sunshine::Shell === Sunshine.shell
+
+    assert_equal config['deploy_env'].to_s, Sunshine.deploy_env
+
+    assert_equal !config['auto'], Sunshine.interactive?
+
+    assert Sunshine::Output === Sunshine.logger
+    assert_equal Logger::INFO, Sunshine.logger.level
+
+    assert_equal config['max_deploy_versions'], Sunshine.max_deploy_versions
+
+    assert_equal config['trace'], Sunshine.trace?
+  end
+
+
+  def test_find_command
+    assert !Sunshine.find_command('st')
+    assert_equal 'start', Sunshine.find_command('sta')
+    assert_equal 'stop', Sunshine.find_command('sto')
+    assert_equal 'add', Sunshine.find_command('a')
+
+    Sunshine::COMMANDS.each do |cmd|
+      assert_equal cmd, Sunshine.find_command(cmd)
+    end
+  end
+
+
+  def test_exec_run_command
+    mock_sunshine_exit
+    mock_sunshine_command Sunshine::RunCommand
+
+    Sunshine.run %w{run somefile.rb -l debug -e prod --no-trace}
+
+    assert_command Sunshine::RunCommand, [['somefile.rb'], Sunshine.setup]
+  end
+
+
+  def test_exec_control_commands
+    mock_sunshine_exit
+
+    %w{add list restart rm start stop}.each do |name|
+      cmd = Sunshine.const_get("#{name.capitalize}Command")
+
+      mock_sunshine_command cmd
+
+      Sunshine.run %w{thing1 thing2 -r remoteserver.com}.unshift(name)
+
+      servers = [Sunshine::RemoteShell.new("remoteserver.com")]
+
+      args = [%w{thing1 thing2}, Sunshine.setup]
+      assert_command cmd, args
+
+      assert_equal servers, Sunshine.setup['servers']
+
+
+      Sunshine.run %w{thing1 thing2 -v}.unshift(name)
+      servers = [Sunshine.shell]
+
+      assert_command cmd, args
+
+      assert_equal servers, Sunshine.setup['servers']
+      assert Sunshine.setup['verbose']
+    end
+  end
+
+
+  def test_exec_local_cmd
+    mock_sunshine_exit
+    mock_sunshine_command Sunshine::RmCommand
+
+    Sunshine.run %w{rm app1 app2}
+
+    dsd = [Sunshine.shell]
+
+    args = [['app1', 'app2'], Sunshine.setup]
+    assert_command Sunshine::RmCommand, args
+
+    assert_equal dsd, Sunshine.setup['servers']
+  end
+
+
+  def test_exit
+    assert_sunshine_exit_status [true], 0
+    assert_sunshine_exit_status [false], 1
+    assert_sunshine_exit_status [0, "success!"], 0, "success!"
+    assert_sunshine_exit_status [2, "failed!"], 2, "failed!"
+  end
+
+
+  def assert_sunshine_exit_status args, expected_status, msg=""
+    args.map!{|a| a.inspect.gsub("\"", "\\\"")}
+    args = args.join(",")
+    cmd = "ruby -Ilib -e \"require 'sunshine'; Sunshine.exit(#{args})\""
+
+    pid, inn, out, err = Open4.popen4(*cmd)
+
+    status = Process.waitpid2(pid).last
+
+    out_data = out.read
+    err_data = err.read
+
+    out.close
+    err.close
+    inn.close
+
+    assert_equal expected_status, status.exitstatus
+    if expected_status == 0
+      assert_equal msg, out_data.strip
+    else
+      assert_equal msg, err_data.strip
+    end
+  end
+
+
+  def assert_command cmd, args
+    assert cmd.call_log.include?([:exec, args])
+  end
+
+
+  def mock_sunshine_command cmd
+    cmd.instance_eval do
+      undef exec
+      undef call_log if defined?(call_log)
+
+      def call_log
+        @call_log ||= []
+      end
+
+      def exec *args
+        call_log << [:exec, args]
+        true
+      end
+    end
+  end
+
+  def mock_sunshine_exit
+    Sunshine.instance_eval do
+      undef exit
+
+      def exit *args
+      end
+    end
+  end
+
+end