man_eb_deployer 0.8.0

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

data/test/multi_components_deploy_test.rb

@@ -0,0 +1,164 @@
+require 'deploy_test'
+
+class MultiComponentsDeployTest < DeployTest
+  def test_deploy_with_components
+    do_deploy
+    assert @eb.environment_exists?('simple', t('prod-web', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-bg', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-api', 'simple'))
+    assert !@eb.environment_exists?('simple', t('prod', 'simple'))
+  end
+
+  def test_deploy_with_components_with_blue_green
+    do_bg_deploy
+    assert @eb.environment_exists?('simple', t('prod-web-a', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-bg-a', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-api-a', 'simple'))
+    do_bg_deploy
+    assert @eb.environment_exists?('simple', t('prod-web-b', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-bg-b', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-api-b', 'simple'))
+  end
+
+  def test_cname_include_component_name
+    do_deploy
+    assert_equal 'simple-prod-web', @eb.environment_cname_prefix('simple', t('prod-web', 'simple'))
+    assert_equal 'simple-prod-api', @eb.environment_cname_prefix('simple', t('prod-api', 'simple'))
+  end
+
+  def test_cname_include_component_name_in_blue_green
+    do_bg_deploy
+    assert_equal 'simple-prod-web', @eb.environment_cname_prefix('simple', t('prod-web-a', 'simple'))
+
+    do_bg_deploy
+    assert_equal 'simple-prod-web', @eb.environment_cname_prefix('simple', t('prod-web-b', 'simple'))
+    assert_equal 'simple-prod-web-inactive', @eb.environment_cname_prefix('simple', t('prod-web-a', 'simple'))
+  end
+
+  def test_components_inheritate_creation_options_from_environment
+    do_deploy
+    assert_equal 'WebServer', @eb.environment_tier('simple', t('prod-web', 'simple'))
+  end
+
+  def test_components_can_override_creation_opts
+    do_deploy(:tier => 'WebServer',
+              :components => [{'name' => 'web'}, {'name' => 'bg', 'tier' => "Worker"}])
+    assert_equal 'WebServer', @eb.environment_tier('simple', t('prod-web', 'simple'))
+    assert_equal 'Worker', @eb.environment_tier('simple', t('prod-bg', 'simple'))
+  end
+
+  def test_components_specific_eb_settings_will_override_env_eb_settings
+    minsize_3 = {:namespace => 'aws:autoscaling:launchconfiguration',
+      :option_name => 'MinSize',
+      :value => '3' }
+    minsize_2 = {:namespace => 'aws:autoscaling:launchconfiguration',
+      :option_name => 'MinSize',
+      :value => '2' }
+
+    do_deploy(:option_settings => [minsize_3],
+              :components => [{'name' => 'web'},
+                              {'name' => 'api',
+                                'option_settings' => [minsize_2]}])
+    assert_equal [minsize_3], @eb.environment_settings('simple', t('prod-web', 'simple'))
+    assert_equal [minsize_3, minsize_2], @eb.environment_settings('simple', t('prod-api', 'simple'))
+  end
+
+  def test_override_deployment_strategy
+    do_deploy(:components => [{'name' => 'web',
+                                'strategy' => 'blue-green' },
+                              {'name' => 'bg',
+                                'strategy' => 'inplace-update'}])
+
+    assert @eb.environment_exists?('simple', t('prod-web-a', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-bg', 'simple'))
+  end
+
+  def test_can_deploy_single_component
+    do_deploy(:component => "bg")
+    assert !@eb.environment_exists?('simple', t('prod-web', 'simple'))
+    assert !@eb.environment_exists?('simple', t('prod-api', 'simple'))
+    assert @eb.environment_exists?('simple', t('prod-bg', 'simple'))
+  end
+
+  def test_should_raise_exception_when_try_to_deploy_a_none_exists_component
+    assert_raises(RuntimeError) do
+      do_deploy(:component => "foo")
+    end
+  end
+
+
+  def test_can_have_inactive_settings_which_will_be_applied_to_inactive_env
+    settings = {:inactive_settings =>
+      [{:namespace => 'aws:autoscaling:launchconfiguration',
+         :option_name => 'MinSize',
+         :value => 1}],
+      :components =>
+      [{:name => 'web',
+         :option_settings =>
+         [{:namespace => 'aws:autoscaling:launchconfiguration',
+            :option_name => 'MinSize',
+            :value => 10}]}]}
+
+    do_bg_deploy(settings)
+    assert_equal 10, @eb.environment_settings('simple', t('prod-web-a', 'simple')).last[:value]
+
+    do_bg_deploy(settings)
+    assert_equal 1, @eb.environment_settings('simple', t('prod-web-a', 'simple')).last[:value]
+    assert_equal 10, @eb.environment_settings('simple', t('prod-web-b', 'simple')).last[:value]
+
+    do_bg_deploy(settings)
+    assert_equal 10, @eb.environment_settings('simple', t('prod-web-a', 'simple')).last[:value]
+    assert_equal 1, @eb.environment_settings('simple', t('prod-web-b', 'simple')).last[:value]
+  end
+
+  def test_can_provide_inactive_settings_at_component_level
+    settings = {:option_settings =>
+      [{:namespace => 'aws:autoscaling:launchconfiguration',
+         :option_name => 'MinSize',
+         :value => 10}],
+      :components =>
+      [{:name => 'web',
+         :inactive_settings =>
+         [{:namespace => 'aws:autoscaling:launchconfiguration',
+            :option_name => 'MinSize',
+            :value => 2}]},
+       {:name => 'api',
+         :inactive_settings =>
+         [{:namespace => 'aws:autoscaling:launchconfiguration',
+            :option_name => 'MinSize',
+            :value => 1}]}]}
+
+    do_bg_deploy(settings)
+    assert_equal 10, @eb.environment_settings('simple', t('prod-web-a', 'simple')).last[:value]
+    assert_equal 10, @eb.environment_settings('simple', t('prod-api-a', 'simple')).last[:value]
+
+    do_bg_deploy(settings)
+    assert_equal 2, @eb.environment_settings('simple', t('prod-web-a', 'simple')).last[:value]
+    assert_equal 1, @eb.environment_settings('simple', t('prod-api-a', 'simple')).last[:value]
+  end
+
+  def test_should_raise_error_when_deploy_work_tier_component_with_blue_green
+    assert_raises(RuntimeError) do
+      deploy(:application => 'simple',
+             :environment => 'prod',
+             :strategy => 'blue-green',
+             :components => [{ 'name' => 'web' },
+                             { 'name' => 'bg', 'tier' => 'worker' }])
+    end
+  end
+
+  private
+  def do_deploy(options={})
+    deploy({:application => 'simple',
+             :environment => 'prod',
+             :components => [{ 'name' => 'web' },
+                             { 'name' => 'bg' },
+                             { 'name' => 'api' }]
+           }.merge(options))
+  end
+
+  def do_bg_deploy(options={})
+    do_deploy(options.merge(:strategy => 'blue-green'))
+  end
+
+end

data/test/rails_generators_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'rails'
+require 'shellwords'
+require 'generators/eb_deployer/install/install_generator'
+
+class RailsGenratorsTest < Rails::Generators::TestCase
+  tests EbDeployer::Generators::InstallGenerator
+  destination File.expand_path('../../tmp', __FILE__)
+  setup :prepare_destination
+
+  setup do
+    mkdir_p path('config')
+    touch path('config/database.yml')
+    touch path('Gemfile')
+  end
+
+  test "install" do
+    run_generator
+
+    assert_file 'config/eb_deployer.yml'
+    assert_file 'lib/tasks/eb_deployer.rake'
+
+    assert_file 'config/rds.json'
+    assert_file '.ebextensions/01_postgres_packages.config'
+    assert_file 'config/database.yml', /database: <%= ENV\['DATABASE_NAME'\]/m, /host: <%= ENV\['DATABASE_HOST'\]/m
+    assert_file 'Gemfile', /gem "pg"/
+  end
+
+  test "should comment production configuration in database.yml" do
+    File.open(path('config/database.yml'), 'w') do |f|
+      f.write(<<-YAML)
+development:
+  host: localhost
+
+production:
+  host: localhost
+
+test:
+  host: localhost
+YAML
+    end
+    run_generator
+    assert_file 'config/database.yml', <<-YAML
+development:
+  host: localhost
+
+# production:
+#   host: localhost
+
+test:
+  host: localhost
+
+production:
+  adapter: postgresql
+  database: <%= ENV['DATABASE_NAME'] || 'tmp_production' %>
+  host: <%= ENV['DATABASE_HOST'] || 'localhost' %>
+  port: <%= ENV['DATABASE_PORT'] || 5432 %>
+  username: <%= ENV['DATABASE_USERNAME'] || #{ENV['USER'].inspect} %>
+  password: <%= ENV['DATABASE_PASSWORD'] %>
+  min_messages: ERROR
+YAML
+  end
+
+  def path(*f)
+    File.join(destination_root, *f)
+  end
+end

data/test/resources_deploy_test.rb

@@ -0,0 +1,191 @@
+require 'deploy_test'
+
+class ResourcesDeployTest < DeployTest
+
+  def test_deploy_with_resources_declared_will_create_a_cf_stack_for_env
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template
+           })
+    assert @cf_driver.stack_exists?('simple-production')
+    assert_equal({},  @cf_driver.stack_config('simple-production')[:parameters])
+    assert_equal([],  @cf_driver.stack_config('simple-production')[:capabilities])
+    assert_nil(@cf_driver.stack_config('simple-production')[:stack_policy_body])
+  end
+
+  def test_deploy_with_resources_declared_will_create_a_cf_stack_for_env_with_policy
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    cf_policy = sample_file("sample_policy.json", JSON.dump({'Policy' => {'P1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+               :template => cf_template,
+               :policy => cf_policy
+           })
+    assert @cf_driver.stack_exists?('simple-production')
+    assert_equal({},  @cf_driver.stack_config('simple-production')[:parameters])
+    assert_equal([],  @cf_driver.stack_config('simple-production')[:capabilities])
+    assert_equal("{\"Policy\":{\"P1\":{}}}", @cf_driver.stack_config('simple-production')[:stack_policy_body])
+  end
+
+  def test_deploy_with_resources_declared_will_update_a_cf_stack_for_env_with_policy
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    cf_policy = sample_file("sample_policy.json", JSON.dump({'Policy' => {'P1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+               :template => cf_template,
+               :policy => cf_policy
+           })
+    assert @cf_driver.stack_exists?('simple-production')
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+               :template => cf_template,
+               :policy => cf_policy,
+               :override_policy => false
+           })
+    assert_equal({},  @cf_driver.stack_config('simple-production')[:parameters])
+    assert_equal([],  @cf_driver.stack_config('simple-production')[:capabilities])
+    assert_equal("{\"Policy\":{\"P1\":{}}}", @cf_driver.stack_config('simple-production')[:stack_policy_body])
+  end
+
+  def test_deploy_with_resources_declared_will_update_a_cf_stack_for_env_with_temp_policy
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    cf_policy = sample_file("sample_policy.json", JSON.dump({'Policy' => {'P1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+               :template => cf_template,
+               :policy => cf_policy
+           })
+    assert @cf_driver.stack_exists?('simple-production')
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+               :template => cf_template,
+               :policy => cf_policy,
+               :override_policy => true
+           })
+    assert_equal({},  @cf_driver.stack_config('simple-production')[:parameters])
+    assert_equal([],  @cf_driver.stack_config('simple-production')[:capabilities])
+    assert_equal("{\"Policy\":{\"P1\":{}}}", @cf_driver.stack_config('simple-production')[:stack_policy_during_update_body])
+  end
+
+  def test_provision_resources_with_capacities
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template,
+             :capabilities => ['CAPABILITY_IAM']
+           })
+    assert_equal ['CAPABILITY_IAM'],  @cf_driver.stack_config('simple-production')[:capabilities]
+  end
+
+  def test_provision_resources_with_parameters
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template,
+             :parameters => {'a' => 1}
+           })
+    assert_equal({'a' => 1 },  @cf_driver.stack_config('simple-production')[:parameters])
+  end
+
+  def test_skip_resource_update
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template,
+             :parameters => {'a' => 1 }
+           })
+    assert_equal(1, @cf_driver.stack_config('simple-production')[:parameters]['a'])
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template,
+             :parameters => {'a' => 2 }
+           })
+    assert_equal(2, @cf_driver.stack_config('simple-production')[:parameters]['a'])
+    deploy(:application => 'simple',
+           :environment => "production",
+           :skip_resource_stack_update => true,
+           :resources => {
+             :template => cf_template,
+             :parameters => {'a' => 3 }
+           })
+    assert_equal(2, @cf_driver.stack_config('simple-production')[:parameters]['a'])
+  end
+
+  def test_should_still_query_output_to_set_eb_options_even_skip_resources_update_is_specified
+    cf_template = temp_file(JSON.dump({'Resources' => {'R1' => {}},
+                                      'Outputs' => {'O1' => {}, 'O2' => {}}}))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template
+           })
+
+    deploy(:application => 'simple', :environment => "production",
+           :skip_resource_stack_update => true,
+           :resources => {
+             :template => cf_template,
+             :transforms => {
+               'O2' => lambda { |v| {:namespace => 'aws.foo', :option_name => 'o2', :value => "transformed " + v} }
+             }
+           })
+
+    assert @eb.environment_settings('simple', t('production', 'simple')).
+      include?({:namespace => 'aws.foo', :option_name => 'o2', :value => 'transformed value of O2'})
+  end
+
+
+  def test_transforms_resource_provsion_output_to_elastic_beanstalk_settings
+    cf_template = temp_file(JSON.dump({
+                                        'Resources' => {'R1' => {}},
+                                        'Outputs' => {'O1' => {}, 'O2' => {}}
+                                      }))
+    deploy(:application => 'simple', :environment => "production",
+           :resources => {
+             :template => cf_template,
+             :transforms => {
+               'O1' => lambda { |v| {:namespace => 'aws.foo', :option_name => 'o1', :value => v} }
+             }
+           })
+    assert @eb.environment_settings('simple', t('production', 'simple')).
+      include?({:namespace => 'aws.foo', :option_name => 'o1', :value => 'value of O1'})
+  end
+
+  def test_can_query_resource_stack_output_after_deploy
+    cf_template = temp_file(JSON.dump({
+                                        'Resources' => {'R1' => {}},
+                                        'Outputs' => {'O1' => {}, 'O2' => {}}
+                                      }))
+    deploy(:application => 'simple',
+           :environment => "production",
+           :resources => { :template => cf_template })
+    assert_equal 'value of O1', query_resource_output('O1',
+                                                      :application => 'simple',
+                                                      :environment => "production")
+    assert_equal 'value of O2', query_resource_output('O2',
+                                                      :application => 'simple',
+                                                      :environment => "production")
+
+  end
+
+  def test_should_raise_error_if_query_resources_that_have_not_been_provisioned_yet
+    assert_raises(EbDeployer::ResourceNotInReadyState) do
+      query_resource_output('O1',
+                            :application => 'simple',
+                            :environment => "production")
+    end
+  end
+
+  def test_custom_stack_name
+    cf_template = temp_file(JSON.dump({
+                                        'Resources' => {'R1' => {}},
+                                        'Outputs' => {'O1' => {}, 'O2' => {}}
+                                      }))
+    deploy(:application => 'simple',
+           :environment => "production",
+           :resources => { :template => cf_template },
+           :stack_name => 'my-lovely-stack')
+
+    assert !@cf_driver.stack_exists?('simple-production')
+    assert @cf_driver.stack_exists?('my-lovely-stack')
+  end
+end

data/test/smoke_test_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class SmokeTestTest < Test::Unit::TestCase
+  def test_call_proc_type_smoke_tests
+    host_name_in_proc = nil
+    EbDeployer::SmokeTest.new(lambda {|v| host_name_in_proc = v }).run("foo")
+
+    assert_equal 'foo', host_name_in_proc
+  end
+
+  def test_eval_string_type_smoke_test
+    $host_name_in_proc = nil
+    EbDeployer::SmokeTest.new("$host_name_in_proc=host_name").run("foo")
+    assert_equal 'foo', $host_name_in_proc
+  end
+
+  def test_should_raise_if_test_body_raise
+    assert_raises(RuntimeError) do
+      EbDeployer::SmokeTest.new("raise host_name").run("foo")
+    end
+  end
+
+end

data/test/template_deploy_test.rb

@@ -0,0 +1,13 @@
+require 'deploy_test'
+
+class TemplateDeployTest < DeployTest
+  def test_default_no_template
+    deploy(:application => 'simple', :environment => "production")
+    assert_equal nil, @eb.template_name('simple', t('production', 'simple'))
+  end
+
+  def test_can_set_a_template
+    deploy(:application => 'simple', :environment => "production", :template_name => 'SomeTemplate')
+    assert_equal 'SomeTemplate', @eb.template_name('simple', t('production', 'simple'))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,68 @@
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'tempfile'
+require 'eb_deployer'
+require 'aws_driver_stubs'
+require 'test/unit'
+
+def silence_warnings(&block)
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end
+
+silence_warnings { EbDeployer::Utils::BACKOFF_INITIAL_SLEEP = 0 }
+silence_warnings { EbDeployer::EventPoller::POLL_INTERVAL = 0 }
+
+class ErrorRaisingWrapper < SimpleDelegator
+  def initialize(stub)
+    @errors = {}
+    super(stub)
+  end
+
+  def set_error(method, error)
+    set_error_generator(method) do
+      error
+    end
+  end
+
+  def set_error_generator(method, &error_gen)
+    define_delegate_method(method)
+    @errors[method] = Proc.new(&error_gen)
+  end
+
+  private
+  def define_delegate_method(method)
+    method = method.to_s
+    original_method_name = "__#{method}_without_error"
+    raise "method #{method} not defined" unless self.respond_to?(method)
+    return if self.respond_to?(original_method_name)
+
+    self.instance_eval <<-CODE
+      def #{original_method_name}(*args, &block)
+        self.__get_obj__.send(:#{method}, *args, &block)
+      end
+
+      def #{method}(*args, &block)
+        if error_gen = @errors[:#{method}]
+          error = error_gen.call
+          raise error if error
+        end
+        super
+      end
+    CODE
+  end
+end
+
+class Test::Unit::TestCase
+  def sample_file(file_name, content='s' * 100)
+    path = File.join('/tmp', file_name)
+    File.open(path, 'w') { |f| f << content }
+    path
+  end
+
+  def t(env, app_name)
+    EbDeployer::EbEnvironment.unique_ebenv_name(env, app_name)
+  end
+end

data/test/tier_setting_deploy_test.rb

@@ -0,0 +1,24 @@
+require 'deploy_test'
+
+class TierSettingDeployTest < DeployTest
+  def test_sets_default_tier_as_webserver
+    deploy(:application => 'simple', :environment => "production")
+    assert_equal 'WebServer', @eb.environment_tier('simple', t('production', 'simple'))
+  end
+
+  def test_can_change_tier
+    deploy(:application => 'simple', :environment => "production", :tier => 'Worker')
+    assert_equal 'Worker', @eb.environment_tier('simple', t('production', 'simple'))
+  end
+
+  def test_should_worker_tier_should_not_have_cname_prefix
+    deploy(:application => 'simple', :environment => "production", :tier => 'Worker')
+    assert_nil @eb.environment_cname_prefix('simple', t('production', 'simple'))
+  end
+
+  def test_should_raise_error_when_deploy_worker_tier_with_blue_green
+    assert_raises(RuntimeError) do
+      deploy(:application => 'simple', :environment => "production", :tier => 'Worker', :strategy => 'blue-green')
+    end
+  end
+end