engineyard-serverside 2.8.0.pre → 2.8.0.pre2

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::App.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,160 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying an application that uses Bundler" do
-  VERSION_PATTERN = Regexp.quote(::EY::Serverside::DependencyManager::Bundler.default_version)
-  PARALLEL_JOBS = ::EY::Serverside::DependencyManager::Bundler.jobs_number
-
-  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 "runs 'bundle install' with --jobs #{PARALLEL_JOBS}" do
-      expect(@bundle_install_command).not_to be_nil
-      expect(@bundle_install_command).to include("--jobs #{PARALLEL_JOBS}")
-    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 "runs 'bundle install' with --jobs #{PARALLEL_JOBS}" do
-      expect(@bundle_install_command).not_to be_nil
-      expect(@bundle_install_command).to include("--jobs #{PARALLEL_JOBS}")
-    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
-
-  context "with outdated bundler" do
-    before :all do
-      deploy_test_application( "bundler_old" )
-      @bundle_install_command = @deployer.commands.grep( /bundle _1.3.6_ install/ ).first
-    end
-
-    it "doesn't run 'bundle install' with --jobs" do
-      expect( @bundle_install_command ).to_not include "--jobs"
-    end
-  end
-end

data/spec/configuration_spec.rb

@@ -1,206 +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_ey_config_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

data/spec/custom_deploy_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-describe "the EY::Serverside::Deploy API" do
-  it "calls tasks in the right order" do
-    class TestDeploy < FullTestDeploy
-      attr_reader :call_order
-      def initialize(*a)
-        super
-        @call_order = []
-      end
-
-      def push_code()                @call_order << 'push_code'               ; super end
-      def copy_repository_cache()    @call_order << 'copy_repository_cache'   ; super end
-      def create_revision_file()     @call_order << 'create_revision_file'    ; super end
-      def bundle()                   @call_order << 'bundle'                  ; super end
-      def setup_services()           @call_order << 'setup_services'          ; super end
-      def symlink_configs()          @call_order << 'symlink_configs'         ; super end
-      def migrate()                  @call_order << 'migrate'                 ; super end
-      def compile_assets()           @call_order << 'compile_assets'          ; super end
-      def symlink()                  @call_order << 'symlink'                 ; super end
-      def restart()                  @call_order << 'restart'                 ; super end
-      def cleanup_old_releases()     @call_order << 'cleanup_old_releases'    ; super end
-      def enable_maintenance_page()  @call_order << 'enable_maintenance_page' ; super end
-      def disable_maintenance_page() @call_order << 'disable_maintenance_page'; super end
-      def gc_repository_cache()      @call_order << 'gc_repository_cache'     ; super end
-    end
-
-    config = EY::Serverside::Deploy::Configuration.new(default_configuration)
-
-    td = TestDeploy.realnew(test_servers, config, test_shell)
-    mock_bundler
-    with_mocked_commands do
-      capture do
-        td.deploy
-      end
-    end
-
-    ############################# IMPORTANT ####################################
-    #
-    # Call order is referenced in the engineyard gem eydeploy.rb documentation.
-    #
-    # https://support.cloud.engineyard.com/entries/20996661-customize-your-deployment
-    #
-    # Changing call order or removing methods may adversely affect customers
-    # that are using eydeploy.rb and relying on this documentation.
-    #
-    ############################################################################
-    expect(td.call_order).to eq(%w(
-      push_code
-      copy_repository_cache
-      create_revision_file
-      bundle
-      setup_services
-      symlink_configs
-      compile_assets
-      enable_maintenance_page
-      migrate
-      symlink
-      restart
-      disable_maintenance_page
-      cleanup_old_releases
-      gc_repository_cache))
-  end
-
-  describe "task overrides" do
-    before(:each) do
-      @tempdir = Pathname.new(`mktemp -d -t custom_deploy_spec.XXXXX`.strip)
-    end
-
-    def write_eydeploy(relative_path, contents = "def got_new_methods() 'from the file on disk' end")
-      path = @tempdir.join(relative_path)
-      path.dirname.mkpath
-      path.open('w') { |f| f << contents }
-    end
-
-    describe "eydeploy_rb disabled" do
-      before do
-        @config = EY::Serverside::Deploy::Configuration.new('app' => 'app_name', 'repository_cache' => @tempdir.to_s, 'eydeploy_rb' => 'false')
-        @deploy = FullTestDeploy.realnew(test_servers, @config, test_shell)
-      end
-
-      it "doesn't load eydeploy_rb file" do
-        write_eydeploy 'eydeploy.rb'
-        @deploy.require_custom_tasks
-        expect(@deploy).not_to respond_to(:got_new_methods)
-      end
-    end
-
-    describe "eydeploy_rb detect or enabled" do
-      before do
-        @config = EY::Serverside::Deploy::Configuration.new('app' => 'app_name', 'repository_cache' => @tempdir.to_s, 'eydeploy_rb' => 'true')
-        @deploy = FullTestDeploy.realnew(test_servers, @config, test_shell)
-      end
-
-      it "requires 'eydeploy.rb' and adds any defined methods to the deploy" do
-        write_eydeploy 'eydeploy.rb'
-        @deploy.require_custom_tasks
-        expect(@deploy.got_new_methods).to eq('from the file on disk')
-      end
-
-      it "falls back to 'config/eydeploy.rb'" do
-        write_eydeploy 'config/eydeploy.rb'
-        @deploy.require_custom_tasks
-        expect(@deploy.got_new_methods).to eq('from the file on disk')
-      end
-
-      it "lets you super up from any defined methods" do
-        write_eydeploy 'eydeploy.rb', "def value() super << ' + derived' end"
-
-        class TestDeploySuper < FullTestDeploy
-          def value() 'base' end
-        end
-
-        deploy = TestDeploySuper.realnew(test_servers, @config, test_shell)
-        deploy.require_custom_tasks
-        expect(deploy.value).to eq("base + derived")
-      end
-
-      it "records exceptions raised from the instance eval in the log" do
-        write_eydeploy 'eydeploy.rb', "raise 'Imma blow up'"
-        expect { @deploy.require_custom_tasks }.to raise_error
-        log = @log_path.read
-        expect(log).to match(/Exception while loading .*eydeploy\.rb/)
-        expect(log).to include('Imma blow up')
-      end
-    end
-  end
-end