eb_deployer_updated 0.8.0

data/test/cloud_formation_provisioner_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class CloudFormationProvisionerTest < Test::Unit::TestCase
+  def setup
+    @cf = CFStub.new
+    @provisioner = EbDeployer::CloudFormationProvisioner.new("myresources", @cf)
+    @template = sample_file("sample_template.json")
+  end
+
+
+  def test_convert_inputs_as_params_to_cf
+    resources = { 'template' => @template, 'inputs' => { 'Foo' => 'Bar' } }
+    @provisioner.provision(resources, [])
+
+    assert_equal({ 'Foo' => 'Bar' }, @cf.stack_config("myresources")[:parameters])
+  end
+
+  def test_transform_to_eb_settings
+    resources = { 'template' => @template,
+      'outputs' => {
+        'S' => {
+          'namespace' => "foo",
+          "option_name" => "bar"
+        }
+      }}
+
+    @provisioner.provision(resources, [])
+    settings = @provisioner.transform_outputs(resources)
+    assert_equal [{'namespace' => 'foo', 'option_name' => 'bar', 'value' => 'value of S'}], settings
+  end
+
+  def test_stack_is_tagged
+    resources = { 'template' => @template }
+
+    @provisioner.provision(resources, [{key: 'Tag1', value: 'Value1'}])
+
+    assert_equal([{key: 'Tag1', value: 'Value1'}], @cf.stack_config("myresources")[:tags])
+  end
+
+  def test_stack_is_not_tagged_when_no_tags_specified
+    resources = { 'template' => @template }
+
+    @provisioner.provision(resources, [])
+
+    assert_equal([], @cf.stack_config("myresources")[:tags])
+  end
+end

data/test/config_loader_test.rb

@@ -0,0 +1,205 @@
+require 'test_helper'
+
+class ConfigLoaderTest < Test::Unit::TestCase
+  def setup
+    @loader = EbDeployer::ConfigLoader.new
+    @sample_package = sample_file('app-package.war')
+  end
+
+  def test_all_default_cases
+    config = @loader.load(generate_input(<<-YAML))
+application: myapp
+common:
+  option_settings:
+  resources:
+environments:
+  dev:
+  production:
+YAML
+    assert_equal('myapp', config[:application])
+    assert_equal(@sample_package, config[:package])
+    assert_equal('dev', config[:environment])
+    assert_equal(md5_digest(@sample_package), config[:version_label])
+    assert_equal([], config[:option_settings])
+    assert_equal(nil, config[:resources])
+    assert_equal(nil, config[:common])
+  end
+
+  def test_use_package_as_version_label_when_using_s3_obj_as_package
+    config = @loader.load(generate_input(<<-YAML, :package => 'bucket:obj'))
+application: myapp
+common:
+  strategy: inplace-update
+environments:
+  dev:
+YAML
+    assert_equal('myapp', config[:application])
+    assert_equal('bucket:obj', config[:package])
+    assert_equal('bucket:obj', config[:version_label])
+  end
+
+  def test_common_settings_get_merge_into_the_config
+    config = @loader.load(generate_input(<<-YAML))
+application: myapp
+common:
+  strategy: inplace-update
+  package_bucket: thoughtworks
+  phoenix_mode: true
+  option_settings:
+    - namespace: aws:autoscaling:launchconfiguration
+      option_name: InstanceType
+      value: m1.small
+  resources:
+environments:
+  dev:
+  production:
+YAML
+    assert_equal('inplace-update', config[:strategy])
+    assert_equal('thoughtworks', config[:package_bucket])
+    assert_equal([{'namespace' => 'aws:autoscaling:launchconfiguration',
+                    'option_name' => 'InstanceType',
+                    'value' => 'm1.small'}], config[:option_settings])
+  end
+
+  def test_eval_random_hash
+    yaml = <<-YAML
+application: myapp
+common:
+  resources:
+    template: config/my_rds.json
+    inputs:
+      DBPassword: <%= random_hash %>
+environments:
+  dev:
+  production:
+YAML
+    first_time = @loader.load(generate_input(yaml))[:resources]['inputs']['DBPassword']
+    second_time = @loader.load(generate_input(yaml))[:resources]['inputs']['DBPassword']
+    assert first_time &&  second_time
+    assert first_time != second_time
+  end
+
+  def test_environment_specific_setting_will_override_common_settings
+    yaml = <<-YAML
+application: myapp
+common:
+  phoenix_mode: true
+environments:
+  dev:
+    phoenix_mode: false
+  production:
+YAML
+
+    assert !@loader.load(generate_input(yaml, :environment => 'dev'))[:phoenix_mode]
+    assert  @loader.load(generate_input(yaml, :environment => 'production'))[:phoenix_mode]
+  end
+
+  def test_env_specific_option_settings_will_merge_with_commons
+    config = @loader.load(generate_input(<<-YAML, :environment => 'production'))
+application: myapp
+common:
+  strategy: inplace-update
+  phoenix_mode: true
+  option_settings:
+    - namespace: aws:autoscaling:launchconfiguration
+      option_name: InstanceType
+      value: m1.small
+  resources:
+environments:
+  dev:
+  production:
+    option_settings:
+      - namespace: aws:autoscaling:asg
+        option_name: MinSize
+        value: "2"
+YAML
+    assert_equal([{'namespace' => 'aws:autoscaling:launchconfiguration',
+                    'option_name' => 'InstanceType',
+                    'value' => 'm1.small'},
+                  {'namespace' => 'aws:autoscaling:asg',
+                    'option_name' => 'MinSize',
+                    'value' => "2"}], config[:option_settings])
+  end
+
+  def test_env_is_required
+   error = assert_raises(RuntimeError) {
+      @loader.load(generate_input(<<-YAML, :environment => 'non_existant'))
+application: myapp
+common:
+  strategy: inplace-update
+environments:
+  dev:
+YAML
+    }
+
+    assert_match(/non_existant/, error.message)
+  end
+
+  def test_set_inactive_settings_at_common_level
+    config = @loader.load(generate_input(<<-YAML, :environment => 'production'))
+application: myapp
+common:
+  inactive_settings:
+    - namespace: aws:autoscaling:asg
+      option_name: MinSize
+      value: "1"
+environments:
+  dev:
+  production:
+YAML
+    assert_equal([{'namespace' => 'aws:autoscaling:asg',
+                    'option_name' => 'MinSize',
+                    'value' => '1'}], config[:inactive_settings])
+  end
+
+  def test_set_inactive_settings_at_env_level
+    config = @loader.load(generate_input(<<-YAML, :environment => 'dev'))
+application: myapp
+common:
+  inactive_settings:
+    - namespace: aws:autoscaling:asg
+      option_name: MinSize
+      value: "1"
+environments:
+  dev:
+    inactive_settings:
+      - namespace: aws:autoscaling:asg
+        option_name: MinSize
+        value: "0"
+  production:
+YAML
+    assert_equal([{'namespace' => 'aws:autoscaling:asg',
+                    'option_name' => 'MinSize',
+                    'value' => '0'}], config[:inactive_settings])
+  end
+
+  def test_access_environment_name_in_config_yml_file
+    config = @loader.load(generate_input(<<-YAML, :environment => 'dev'))
+application: myapp
+common:
+  resources:
+    inputs:
+      env: <%= environment %>
+environments:
+  dev:
+  production:
+YAML
+    assert_equal('dev', config[:resources]['inputs']['env'])
+  end
+
+  private
+
+  def md5_digest(file)
+    Digest::MD5.file(file).hexdigest
+  end
+
+  def generate_input(config_file_content, overriding={})
+    { :environment => 'dev',
+      :package => @sample_package,
+      :config_file => generate_config(config_file_content)}.merge(overriding)
+  end
+
+  def generate_config(content)
+    sample_file('eb_deployer.yml', content)
+  end
+end

data/test/deploy_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class DeployTest < Test::Unit::TestCase
+  def setup
+    @eb = ErrorRaisingWrapper.new(EBStub.new)
+    @s3_driver = S3Stub.new
+    @cf_driver = CFStub.new
+    @sample_package = sample_file('app-package.war')
+  end
+
+  protected
+
+  def temp_file(content)
+    f = Tempfile.new("foo")
+    f.write(content)
+    f
+  end
+
+  def query_resource_output(key, opts)
+    EbDeployer.query_resource_output(key, {:bs_driver => @eb,
+                                       :s3_driver => @s3_driver,
+                                       :cf_driver => @cf_driver}.merge(opts))
+  end
+
+  def deploy(opts)
+    @eb.mark_all_envs_ready
+    EbDeployer.deploy({:package => @sample_package,
+                        :strategy => :'inplace-update',
+                        :version_label => 1}.merge(opts).merge(stubs))
+  end
+
+  def destroy(opts)
+    EbDeployer.destroy(opts.merge(stubs))
+  end
+
+  def stubs
+    { :bs_driver => @eb,
+      :s3_driver => @s3_driver,
+      :cf_driver => @cf_driver
+    }
+  end
+end

data/test/eb_environment_test.rb

@@ -0,0 +1,120 @@
+require 'test_helper'
+
+class EbEnvironmentTest < Test::Unit::TestCase
+  def setup
+    @eb_driver = EBStub.new
+    @eb_driver.create_application("myapp")
+  end
+
+  def test_deploy_should_create_corresponding_eb_env
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    env.deploy("version1")
+    assert @eb_driver.environment_exists?('myapp', t('production', 'myapp'))
+  end
+
+  def test_deploy_again_should_update_environment
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    env.deploy("version1")
+    env.deploy("version2")
+    assert @eb_driver.environment_exists?('myapp', t('production', 'myapp'))
+    assert_equal 'version2', @eb_driver.environment_verion_label('myapp', t('production', 'myapp'))
+  end
+
+  def test_option_setttings_get_set_on_eb_env
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    env.deploy("version1", {s1: 'v1'})
+    assert_equal({s1: 'v1' },  @eb_driver.environment_settings('myapp', t('production', 'myapp')))
+  end
+
+  def test_deploy_should_include_tags
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production', :tags => {:my_tag => 'my_value', :tag2 => 'value2'})
+    env.deploy("version1")
+    assert_equal [{:key => :my_tag, :value => 'my_value'}, {:key => :tag2, :value => 'value2'}], @eb_driver.environment_tags('myapp', t('production', 'myapp'))
+  end
+
+  def test_should_run_smoke_test_after_deploy
+    smoked_host = nil
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :smoke_test => Proc.new { |host| smoked_host = host }, :cname_prefix => 'myapp-production')
+    env.deploy("version1")
+
+    assert !smoked_host.nil?
+    assert_match( /myapp.*\.elasticbeanstalk\.com/, smoked_host)
+  end
+
+  def test_should_raise_runtime_error_when_deploy_failed
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    @eb_driver.set_events("myapp", t("production", 'myapp'),
+                          [],
+                          ["start deploying", "Failed to deploy application"])
+    assert_raises(RuntimeError) { env.deploy("version 1") }
+  end
+
+  def test_should_raise_runtime_error_when_eb_extension_execution_failed
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    @eb_driver.set_events("myapp", t("production", 'myapp'),
+                          [],
+                          ["start deploying",
+                           "create environment",
+                           "Command failed on instance. Return code: 1 Output: Error occurred during build: Command hooks failed",
+                           "Successfully launched environment"])
+
+    assert_raises(RuntimeError) { env.deploy("version 1") }
+  end
+
+  def test_should_raise_runtime_error_when_issues_during_environment_update
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    @eb_driver.set_events("myapp", t("production", 'myapp'),
+                          [],
+                          ["start deploying",
+                           "create environment",
+                           "Update environment operation is complete, but with errors. For more information, see troubleshooting documentation."])
+
+    assert_raises(RuntimeError) { env.deploy("version 1") }
+  end
+
+  def test_should_raise_runtime_error_when_issues_during_launch
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    @eb_driver.set_events("myapp", t("production", 'myapp'),
+                          [],
+                          ["start deploying",
+                           "create environment",
+                           "Launched environment: dev-a-1234567. However, there were issues during launch. See event log for details."])
+
+    assert_raises(RuntimeError) { env.deploy("version 1") }
+  end
+
+  def test_terminate_should_delete_environment
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :cname_prefix => 'myapp-production')
+    env.deploy("version1")
+    env.terminate
+    assert !@eb_driver.environment_exists?('myapp', t('production', 'myapp'))
+  end
+
+  def test_should_raise_runtime_error_when_solution_stack_is_not_valid
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, {
+                                          :cname_prefix => 'myapp-production',
+                                          :solution_stack => "python"
+                                        })
+    @eb_driver.set_solution_stacks(["java", "ruby"])
+    assert_raises(RuntimeError) { env.deploy("version 1") }
+  end
+
+  def test_should_no_set_cname_prefix_for_create_unless_for_web_tier
+    env = EbDeployer::EbEnvironment.new("myapp",
+                                        "production",
+                                        @eb_driver,
+                                        :tier => "Worker",
+                                        :cname_prefix => 'myapp-production')
+    env.deploy("version1")
+    assert @eb_driver.environment_exists?('myapp', t('production', 'myapp'))
+    assert_nil @eb_driver.environment_cname_prefix('myapp', t('production', 'myapp'))
+  end
+
+  def test_should_be_possible_to_accept_yellow_health_state
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :accepted_healthy_states => ["Green", "Yellow"])
+    @eb_driver.mark_env_health_state_as("myapp", env.name, "Yellow")
+    env.deploy("version1")
+    assert @eb_driver.environment_exists?('myapp', t('production', 'myapp'))
+  end
+
+end

data/test/eb_event_poller_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class EbEventPollerTest < Test::Unit::TestCase
+  def setup
+    @eb = EBStub.new
+    @poller = EbDeployer::EventPoller.new(EbDeployer::EbEventSource.new("myapp", "test", @eb))
+  end
+
+  def test_run_handle_block_through_all_events_when_there_is_no_from_anchor
+    messages_handled = []
+    @eb.set_events('myapp', 'test', ['a', 'b', nil])
+    @poller.poll(nil) do |event|
+      break if event[:message].nil?
+      messages_handled << event[:message]
+    end
+
+    assert_equal ['a', 'b'], messages_handled
+  end
+
+
+  def test_can_poll_all_events_after_an_anchor
+    @eb.set_events('myapp', 'test', ['a', 'b'], ['c', 'd', nil])
+    anchor = @poller.get_anchor
+    messages_handled = []
+    @poller.poll(anchor) do |event|
+      break if event[:message].nil?
+      messages_handled << event[:message]
+    end
+
+    assert_equal ['c', 'd'], messages_handled
+  end
+end

data/test/inplace_update_deploy_test.rb

@@ -0,0 +1,110 @@
+require 'deploy_test'
+
+class InplaceUpdateDeployTest < DeployTest
+  def test_first_deployment_create_eb_application
+    assert !@eb.application_exists?('simple')
+    deploy(:application => 'simple', :environment => "production")
+    assert @eb.application_exists?('simple')
+  end
+
+  def test_set_option_settings_on_deployment
+    redudant = [{:namespace => 'aws:autoscaling:launchconfiguration',
+                  :option_name => 'MinSize',
+                  :value => '2' }]
+    deploy(:application => 'simple', :environment => "production",
+           :option_settings => [redudant])
+
+    assert_equal [redudant], @eb.environment_settings('simple', t('production', 'simple'))
+
+  end
+
+  def test_first_deployment_create_environment
+    assert !@eb.environment_exists?('simple', t('production', 'simple'))
+    deploy(:application => 'simple', :environment => "production")
+    assert @eb.environment_exists?('simple', t('production', 'simple'))
+  end
+
+  def test_support_very_very_long_app_name
+    deploy(:application => 'ver-very-simple-application', :environment => "production")
+    assert @eb.environment_exists?('ver-very-simple-application', t('production', 'ver-very-simple-application'))
+  end
+
+  def test_should_raise_error_when_env_name_is_too_long
+    assert_raises(RuntimeError) { deploy(:application => 'simple', :environment => "p" * 24) }
+  end
+
+  def test_update_environment_with_new_version_should_change_version_that_deployed
+    deploy(:application => 'simple',
+           :environment => "production",
+           :version_label => 1)
+    assert_equal '1', @eb.environment_verion_label('simple', t('production', 'simple'))
+
+    deploy(:application => 'simple',
+           :environment => "production",
+           :version_label => 2)
+
+    assert_equal '2', @eb.environment_verion_label('simple', t('production', 'simple'))
+  end
+
+  def test_smoke_test_should_be_run_after_env_created_or_update
+    host_for_smoke_test = nil
+    deploy(:application => 'simple',
+           :environment => "production",
+           :cname_prefix => 'foobar',
+           :smoke_test => lambda { |host| host_for_smoke_test = host },
+           :version_label => 42)
+    assert_equal 'foobar.us-west-1.elasticbeanstalk.com', host_for_smoke_test
+
+    host_for_smoke_test = nil
+    deploy(:application => 'simple',
+           :environment => "production",
+           :cname_prefix => 'foobar',
+           :smoke_test => lambda { |host| host_for_smoke_test = host },
+           :version_label => 43)
+
+    assert_equal 'foobar.us-west-1.elasticbeanstalk.com', host_for_smoke_test
+  end
+
+  def test_should_terminate_old_environment_if_phoenix_mode_is_enabled
+    deploy(:application => 'simple', :environment => "production", :phoenix_mode => true)
+    assert @eb.environment_exists?('simple', t('production', 'simple'))
+    deploy(:application => 'simple', :environment => "production", :phoenix_mode => true)
+    assert @eb.environments_been_deleted('simple').include?(t('production', 'simple'))
+    assert @eb.environment_exists?('simple', t('production', 'simple'))
+  end
+
+  def test_destroy_should_clean_up_env
+    deploy(:application => 'simple', :environment => "production")
+    destroy(:application => 'simple', :environment => 'production')
+    assert !@eb.environment_exists?('simple', t('production', 'simple'))
+  end
+
+  def test_deploy_should_raise_error_when_constantly_hitting_throttling_error
+    throttling_error = Aws::ElasticBeanstalk::Errors::Throttling.new(nil, "bang!")
+    @eb.set_error(:fetch_events, throttling_error)
+    assert_raises(Aws::ElasticBeanstalk::Errors::Throttling) do
+      deploy(:application => 'simple', :environment => "production")
+    end
+  end
+
+  def test_deploy_should_retry_on_temporary_throttling_error_from_fetch_events
+    throttling_error = Aws::ElasticBeanstalk::Errors::Throttling.new(nil, "bang!")
+    error_seq = [throttling_error] * 5
+    @eb.set_error_generator(:fetch_events) do
+      error_seq.pop
+    end
+    deploy(:application => 'simple', :environment => "production")
+    assert @eb.environment_exists?('simple', t('production', 'simple'))
+  end
+
+  def test_deploy_should_retry_on_temporary_throttling_error_from_create_env
+    throttling_error = Aws::ElasticBeanstalk::Errors::Throttling.new(nil, "bang!")
+    error_seq = [throttling_error] * 5
+    @eb.set_error_generator(:create_environment) do
+      error_seq.pop
+    end
+    deploy(:application => 'simple', :environment => "production")
+    assert @eb.environment_exists?('simple', t('production', 'simple'))
+  end
+
+end