engineyard-serverside 2.6.14 → 2.6.15.alpha1

data/lib/engineyard-serverside/cli_helpers.rb

@@ -1,53 +0,0 @@
-module EY
-  module Serverside
-    module CLIHelpers
-      def account_app_env_options
-        method_option :app,              :type     => :string,
-                                         :required => true,
-                                         :desc     => "Application to deploy",
-                                         :aliases  => %w[-a --app-name]
-        method_option :environment_name, :type     => :string,
-                                         :required => true,
-                                         :desc     => "Environment name"
-        method_option :account_name,     :type     => :string,
-                                         :required => true,
-                                         :desc     => "Account name"
-      end
-
-      def framework_env_option
-        method_option :framework_env,    :type     => :string,
-                                         :required => true,
-                                         :desc     => "Ruby web framework environment",
-                                         :aliases  => ["-e"]
-      end
-
-      def stack_option
-        method_option :stack,            :type     => :string,
-                                         :desc     => "Web stack (so we can restart it correctly)"
-      end
-
-
-      def config_option
-        method_option :config,           :type     => :string,
-                                         :desc     => "Additional configuration"
-      end
-
-      def instances_options
-        method_option :instances,        :type     => :array,
-                                         :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
-        method_option :instance_roles,   :type     => :hash,
-                                         :default  => {},
-                                         :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
-        method_option :instance_names,   :type     => :hash,
-                                         :default  => {},
-                                         :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
-      end
-
-      def verbose_option
-        method_option :verbose,          :type     => :boolean,
-                                         :desc     => "Verbose output",
-                                         :aliases  => ["-v"]
-      end
-    end
-  end
-end

data/spec/archive_deploy_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-class EY::Serverside::Source::Archive
-  def fetch_command
-    "cp #{uri} #{source_cache}"
-  end
-end
-
-describe "Deploying a simple application" do
-
-  before(:all) do
-    adapter = EY::Serverside::Adapter.new do |args|
-      args.account_name = "account"
-      args.app = "application_name"
-      args.stack = "nginx_unicorn"
-      args.environment_name = "environment_name"
-      args.framework_env = "production"
-      args.archive = FIXTURES_DIR.join('retwisj.war')
-      args.verbose = true
-      args.instances = [{ :hostname => "localhost", :roles => ["solo"], :name => "single" }]
-      args.serverside_version = Gem::Version.create(EY::Serverside::VERSION.dup).release
-      args.config = {
-        "deploy_to" => deploy_dir.to_s,
-        "group"            => GROUP
-      }
-    end
-    argv = adapter.deploy.commands.last.to_argv[2..-1]
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI.start(argv)
-      end
-    end
-  end
-
-  it "exploded the war" do
-    %w(META-INF WEB-INF).each {|dir|
-      File.exists?(deploy_dir.join('current', dir))
-    }
-  end
-
-  it "creates a REVISION file" do
-    path = deploy_dir.join('current', 'REVISION')
-    expect(path).to exist
-    checksum = File.read(path).strip
-    expect(checksum).to match(/7400dc058376745c11a98f768b799c6651428857\s+.*retwisj.war$/)
-  end
-
-  it "restarts the app servers" do
-    restart = deploy_dir.join('current', 'restart')
-    expect(restart).to exist
-    expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_application_name deploy|)
-  end
-end

data/spec/basic_deploy_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying a simple application" do
-  before(:all) do
-    deploy_test_application('not_bundled')
-  end
-
-  it "creates a REVISION file" do
-    expect(deploy_dir.join('current', 'REVISION')).to exist
-  end
-
-  it "restarts the app servers" do
-    restart = deploy_dir.join('current', 'restart')
-    expect(restart).to exist
-    expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_rails31 deploy|)
-  end
-
-  it "reuses the same active_release directory if a release_path is specified (such as in integrate)" do
-    path = @config.paths.active_release
-    expect(path.parent.children.size).to eq(1)
-
-    redeploy_test_application('config' => {'release_path' => path.to_s})
-
-    expect(path.parent.children.size).to eq(1)
-  end
-end

data/spec/bundler_deploy_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying an application that uses Bundler" do
-  VERSION_PATTERN = Regexp.quote(::EY::Serverside::DependencyManager::Bundler.default_version)
-
-  context "with a Gemfile.lock" do
-    before(:all) do
-      deploy_test_application('ey_yml')
-      @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
-      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
-    end
-
-    it "runs the right bundler command" do
-      expect(@install_bundler_command).not_to be_nil
-      expect(@install_bundler_command).to match(/install bundler .* -v "#{VERSION_PATTERN}"/)
-    end
-
-    it "runs 'bundle install' with --deployment" do
-      expect(@bundle_install_command).not_to be_nil
-      expect(@bundle_install_command).to include('--deployment')
-    end
-
-    it "removes bundled_gems directory if the ruby or system version changed" do
-      should_run_clear_bundle_cmd = @deployer.commands.grep(/diff/).first
-      expect(should_run_clear_bundle_cmd).not_to be_nil
-      clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
-      expect(clear_bundle_cmd).not_to be_nil
-    end
-
-    it "has the binstubs in the path when migrating" do
-      expect(deploy_dir.join('path-when-migrating').read).to include('ey_bundler_binstubs')
-    end
-
-    it "creates a ruby version file" do
-      expect(deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION')).to exist
-    end
-
-    it "creates a system version file" do
-      expect(deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION')).to exist
-    end
-
-    it "generates bundler binstubs" do
-      pending "doesn't work with mocked bundler"
-      expect(deploy_dir.join('current', 'ey_bundler_binstubs', 'rake')).to exist
-    end
-  end
-
-  context "with clean option" do
-    before(:all) do
-      deploy_test_application('ey_yml', 'clean' => true)
-    end
-
-    it "removes bundled_gems directory if the ruby or system version changed" do
-      should_run_clear_bundle_cmd = @deployer.commands.grep(/diff/).first
-      expect(should_run_clear_bundle_cmd).to be_nil
-      clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
-      expect(clear_bundle_cmd).not_to be_nil
-    end
-
-  end
-
-  context "with bundler disabled in ey.yml" do
-    before(:all) do
-      deploy_test_application('bundler_disabled')
-    end
-
-    it "does not run bundler commands" do
-      expect(@deployer.commands.grep(/gem install bundler/)).to be_empty
-      expect(@deployer.commands.grep(/bundle _.*_ install/)).to be_empty
-    end
-
-    it "still runs the hooks" do
-      expect(deploy_dir.join('current', 'before_bundle.ran' )).to exist
-      expect(deploy_dir.join('current', 'after_bundle.ran' )).to exist
-    end
-  end
-
-  context "without a Gemfile.lock" do
-    before(:all) do
-      deploy_test_application('no_gemfile_lock')
-      @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
-      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
-    end
-
-    it "installs the proper Bundler version" do
-      expect(@install_bundler_command).not_to be_nil
-      expect(@install_bundler_command).to match(/unset RUBYOPT && gem list bundler | grep "bundler " | egrep -q "#{VERSION_PATTERN}[,)]" || gem install bundler -q --no-rdoc --no-ri -v "#{VERSION_PATTERN}"/)
-    end
-
-    it "runs 'bundle install' without --deployment" do
-      expect(@bundle_install_command).not_to be_nil
-      expect(@bundle_install_command).not_to match(/--deployment/)
-    end
-
-    it "exports GIT_SSH for the bundle install" do
-      expect(@bundle_install_command).to match(/export GIT_SSH/)
-    end
-
-    it "puts down RUBY_VERSION and SYSTEM_VERSION" do
-      expect(deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION')).to exist
-      expect(deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION')).to exist
-    end
-
-    it "warns that using a lockfile is idiomatic" do
-      out = read_output
-      expect(out).to match(/WARNING: Gemfile found but Gemfile.lock is missing!/)
-    end
-  end
-
-  context "without a Gemfile.lock and ignoring the warning" do
-    before(:all) do
-      deploy_test_application('no_gemfile_lock', 'config' => {'ignore_gemfile_lock_warning' => true})
-      expect(@config.ignore_gemfile_lock_warning).to be_truthy
-      @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
-      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
-    end
-
-    it "should not warn" do
-      out = read_output
-      expect(out).not_to match(/WARNING/)
-    end
-  end
-
-  context "with a failing Gemfile" do
-    before(:all) do
-      begin
-        deploy_test_application('bundle_fails', 'bundle_install_fails' => true, 'verbose' => false)
-      rescue EY::Serverside::RemoteFailure
-      end
-    end
-
-    it "prints the failure to the log" do
-      out = read_output
-      expect(out).to match(%r|bundle install failure|)
-      expect(deploy_dir.join('current', 'after_bundle.ran' )).not_to exist
-    end
-  end
-end
-

data/spec/configuration_spec.rb

@@ -1,205 +0,0 @@
-require 'spec_helper'
-
-describe EY::Serverside::Deploy::Configuration do
-  describe "default options" do
-    it "has defaults" do
-      @config = EY::Serverside::Deploy::Configuration.new({
-        'app' => 'app_name',
-        'environment_name' => 'env_name',
-        'account_name' => 'acc',
-        'framework_env' => 'production',
-      })
-      expect(@config.app_name).to eq("app_name")
-      expect(@config.environment_name).to eq("env_name")
-      expect(@config.account_name).to eq("acc")
-      expect(@config.migrate).to eq(nil)
-      expect(@config.migrate?).to eq(false)
-      expect(@config.branch).to eq("master")
-      expect(@config.ref).to eq("master")
-      expect(@config.maintenance_on_migrate).to eq(true)
-      expect(@config.maintenance_on_restart).to eq(true)
-      expect(@config.required_downtime_stack?).to eq(true)
-      expect(@config.framework_env).to eq("production")
-      expect(@config.precompile_assets).to eq("detect")
-      expect(@config.precompile_assets_inferred?).to eq(true)
-      expect(@config.skip_precompile_assets?).to eq(false)
-      expect(@config.precompile_assets?).to eq(false)
-      expect(@config.asset_roles).to eq([:app_master, :app, :solo])
-      expect(@config.user).to eq(ENV['USER'])
-      expect(@config.group).to eq(ENV['USER'])
-      expect(@config.verbose).to eq(false)
-      expect(@config.copy_exclude).to eq([])
-      expect(@config.ignore_database_adapter_warning).to eq(false)
-      expect(@config.ignore_gemfile_lock_warning).to eq(false)
-      expect(@config.bundle_without).to eq(%w[test development])
-      expect(@config.extra_bundle_install_options).to eq(%w[--without test development])
-      expect(@config.deployed_by).to eq("Automation (User name not available)")
-      expect(@config.input_ref).to eq(@config.branch)
-      expect(@config.keep_releases).to eq(3)
-      expect(@config.keep_failed_releases).to eq(3)
-    end
-
-    it "raises when required options are not given" do
-      @config = EY::Serverside::Deploy::Configuration.new({})
-      expect { @config.app_name }.to raise_error
-      expect { @config.environment_name }.to raise_error
-      expect { @config.account_name }.to raise_error
-      expect { @config.framework_env }.to raise_error
-    end
-  end
-
-  context "strategies" do
-    let(:options) do
-      { "app" => "serverside" }
-    end
-
-    it "uses strategy if set" do
-      @config = EY::Serverside::Deploy::Configuration.new(
-        options.merge({'strategy' => 'IntegrationSpec', 'git' => 'git@github.com:engineyard/todo.git'})
-      )
-      capture do # deprecation warning
-        expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::IntegrationSpec)
-      end
-      expect(read_output).to include("DEPRECATION WARNING: The configuration key 'strategy' is deprecated in favor of 'source_class'.")
-    end
-
-    it "uses source_class if set" do
-      @config = EY::Serverside::Deploy::Configuration.new(
-        options.merge({'source_class' => 'IntegrationSpec', 'git' => 'git@github.com:engineyard/todo.git'})
-      )
-      expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::IntegrationSpec)
-    end
-
-    it "infers a git source" do
-      @config = EY::Serverside::Deploy::Configuration.new(
-        options.merge({ 'git' => 'git@github.com:engineyard/todo.git' })
-      )
-      expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::Git)
-    end
-
-    it "infers a archive source" do
-      @config = EY::Serverside::Deploy::Configuration.new(
-        options.merge({'archive' => 'https://github.com/engineyard/todo/archive/master.zip'})
-      )
-
-      expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::Archive)
-    end
-  end
-
-  context "command line options" do
-    before do
-      @config = EY::Serverside::Deploy::Configuration.new({
-        'repository_cache' => @tempdir,
-        'app' => 'app_name',
-        'stack' => 'nginx_passenger',
-        'framework_env' => 'development',
-        'environment_name' => 'env_name',
-        'account_name' => 'acc',
-        'branch' => 'branch_from_command_line',
-        'config' => MultiJson.dump({'custom' => 'custom_from_extra_config', 'maintenance_on_migrate' => 'false', 'precompile_assets' => 'false', 'deployed_by' => 'Martin Emde', 'input_ref' => 'input_branch'})
-      })
-    end
-
-    it "underrides options with config (directly supplied options take precedence over 'config' options)" do
-      expect(@config.maintenance_on_migrate).to eq(false)
-      expect(@config.branch).to eq("branch_from_command_line")
-    end
-
-    it "corrects command line supplied precompile_assets string (which relies on having a special not-set value of nil, so can't be a boolean)" do
-      expect(@config.skip_precompile_assets?).to eq(true)
-      expect(@config.precompile_assets?).to eq(false)
-      expect(@config.precompile_assets_inferred?).to eq(false)
-    end
-
-    it "doesn't require downtime on restart for nginx_passenger" do
-      expect(@config.maintenance_on_migrate).to eq(false)
-      expect(@config.maintenance_on_restart).to eq(false)
-    end
-
-    it "doesn't bundle --without the framework_env" do
-      expect(@config.bundle_without).to eq(%w[test])
-    end
-
-    it "gets deployed_by and input_ref correct" do
-      expect(@config.deployed_by).to eq("Martin Emde")
-      expect(@config.input_ref).to eq("input_branch")
-    end
-  end
-
-  describe "ey.yml loading" do
-    before(:each) do
-      @tempdir = `mktemp -d -t ey_yml_spec.XXXXX`.strip
-      @config = EY::Serverside::Deploy::Configuration.new({
-        'repository_cache' => @tempdir,
-        'app' => 'app_name',
-        'environment_name' => 'env_name',
-        'account_name' => 'acc',
-        'migrate' => nil,
-        'branch' => 'branch_from_command_line',
-        'config' => MultiJson.dump({'custom' => 'custom_from_extra_config', 'maintenance_on_migrate' => 'false'})
-      })
-
-      @deploy = FullTestDeploy.new(test_servers, @config, test_shell)
-
-      @yaml_data = {
-        'environments' => {
-          'env_name' => {
-            'copy_exclude' => ['.git'],
-            'migrate' => true,
-            'migration_command' => 'uh oh',
-            'branch' => 'branch_from_ey_yml',
-            'custom' => 'custom_from_ey_yml',
-            'bundle_without' => 'only test',
-            'maintenance_on_migrate' => true,
-          }
-        }
-      }
-    end
-
-    def write_ey_yml(relative_path, data)
-      FileUtils.mkdir_p(File.join(
-        @tempdir,
-        File.dirname(relative_path)))
-
-      File.open(File.join(@tempdir, relative_path), 'w') do |f|
-        f.write data.to_yaml
-      end
-    end
-
-    it "requires 'ey.yml' and adds any defined methods to the deploy" do
-      write_ey_yml 'ey.yml', @yaml_data
-      @deploy.load_ey_yml
-      expect(@deploy.config.copy_exclude).to eq(['.git'])
-    end
-
-    it "falls back to 'config/ey.yml'" do
-      write_ey_yml 'config/ey.yml', @yaml_data
-      @deploy.load_ey_yml
-      expect(@deploy.config.copy_exclude).to eq(['.git'])
-    end
-
-    it "loads at lower priority than command line options" do
-      write_ey_yml 'ey.yml', @yaml_data
-      @deploy.load_ey_yml
-      expect(@deploy.config.migrate?).to eq(false)
-    end
-
-    it "loads at lower priority than json config option" do
-      write_ey_yml 'ey.yml', @yaml_data
-      @deploy.load_ey_yml
-      expect(@deploy.config.branch).to eq('branch_from_command_line')
-    end
-
-    it "loads bundle_without from the config, which overrides the default" do
-      write_ey_yml 'ey.yml', @yaml_data
-      @deploy.load_ey_yml
-      expect(@deploy.config.bundle_without).to eq('only test')
-    end
-
-    it "overrides boolean ey.yml only options with --conifg strings" do
-      write_ey_yml 'ey.yml', @yaml_data
-      @deploy.load_ey_yml
-      expect(@deploy.config).not_to be_maintenance_on_migrate
-    end
-  end
-end