man_eb_deployer 0.8.0

data/test/blue_green_deploy_test.rb

@@ -0,0 +1,114 @@
+require 'deploy_test'
+
+class BlueGreenDeployTest < DeployTest
+  def test_blue_green_deployment_strategy_should_create_blue_env_on_first_deployment
+    do_deploy(42)
+    assert @eb.environment_exists?('simple', t('production-a', 'simple'))
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-a', 'simple'))
+  end
+
+
+  def test_blue_green_deployment_should_create_green_env_if_blue_exists
+    do_deploy(42)
+    do_deploy(43)
+    assert @eb.environment_exists?('simple', t('production-a', 'simple'))
+    assert @eb.environment_exists?('simple', t('production-b', 'simple'))
+  end
+
+
+  def test_blue_green_deployment_should_swap_cname_to_make_active_most_recent_updated_env
+    do_deploy(42)
+    do_deploy(43)
+    assert_match(/simple-production-inactive/,  @eb.environment_cname_prefix('simple', t('production-a', 'simple')))
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-b', 'simple'))
+    do_deploy(44)
+    assert_match(/simple-production-inactive/,  @eb.environment_cname_prefix('simple', t('production-b', 'simple')))
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-a', 'simple'))
+  end
+
+
+  def test_blue_green_deploy_should_run_smoke_test_before_cname_switch
+    smoked_host = []
+    smoke_test = lambda { |host| smoked_host << host }
+    [42, 43, 44].each do |version_label|
+      do_deploy(version_label, :smoke_test => smoke_test)
+    end
+
+    assert_equal ['simple-production.us-west-1.elasticbeanstalk.com',
+                  'simple-production-inactive.us-west-1.elasticbeanstalk.com',
+                  'simple-production-inactive.us-west-1.elasticbeanstalk.com'], smoked_host
+  end
+
+  def test_blue_green_deploy_should_blue_green_terminate_inactive_env_if_blue_green_terminate_inactive_is_enabled
+    do_deploy(42, :blue_green_terminate_inactive => true, :blue_green_terminate_inactive_wait => 1, :blue_green_terminate_inactive_sleep => 1)
+    do_deploy(43, :blue_green_terminate_inactive => true, :blue_green_terminate_inactive_wait => 0, :blue_green_terminate_inactive_sleep => 0)
+
+    inactive_env = t('production-a', 'simple')
+    assert_equal [inactive_env], @eb.environments_been_deleted('simple')
+  end
+
+  def test_blue_green_deployment_should_delete_and_recreate_inactive_env_if_phoenix_mode_is_enabled
+    do_deploy(42, :phoenix_mode => true)
+    do_deploy(43, :phoenix_mode => true)
+    assert_equal [],  @eb.environments_been_deleted('simple')
+
+    inactive_env = t('production-a', 'simple')
+    assert_match(/inactive/,  @eb.environment_cname_prefix('simple', inactive_env))
+
+    do_deploy(44, :phoenix_mode => true)
+    assert_equal [inactive_env], @eb.environments_been_deleted('simple')
+
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', inactive_env)
+  end
+
+  def test_destroy_should_clean_up_env
+    [42, 44].each do |version|
+      do_deploy(version)
+    end
+
+    destroy(:application => 'simple', :environment => 'production')
+    assert !@eb.environment_exists?('simple', t('production-a', 'simple'))
+    assert !@eb.environment_exists?('simple', t('production-b', 'simple'))
+  end
+
+  def test_can_have_inactive_settings_which_will_be_applied_to_inactive_env
+    settings = {:option_settings =>
+      [{:namespace => 'aws:autoscaling:launchconfiguration',
+         :option_name => 'MinSize',
+         :value => 10}],
+      :inactive_settings =>
+      [{:namespace => 'aws:autoscaling:launchconfiguration',
+         :option_name => 'MinSize',
+         :value => 1}]}
+
+    do_deploy(42, settings)
+    assert_equal 10, @eb.environment_settings('simple', t('production-a', 'simple')).last[:value]
+    assert_equal '42', @eb.environment_verion_label('simple', t('production-a', 'simple'))
+
+    do_deploy(43, settings)
+    assert_equal 1, @eb.environment_settings('simple', t('production-a', 'simple')).last[:value]
+    assert_equal '42', @eb.environment_verion_label('simple', t('production-a', 'simple'))
+
+    assert_equal 10, @eb.environment_settings('simple', t('production-b', 'simple')).last[:value]
+    assert_equal '43', @eb.environment_verion_label('simple', t('production-b', 'simple'))
+
+
+    do_deploy(44, settings)
+    assert_equal 10, @eb.environment_settings('simple', t('production-a', 'simple')).last[:value]
+    assert_equal '44', @eb.environment_verion_label('simple', t('production-a', 'simple'))
+
+    assert_equal 1, @eb.environment_settings('simple', t('production-b', 'simple')).last[:value]
+    assert_equal '43', @eb.environment_verion_label('simple', t('production-b', 'simple'))
+
+  end
+
+  private
+
+  def do_deploy(version_label, options={})
+    deploy( {:application => 'simple',
+              :environment => "production",
+              :strategy => 'blue-green',
+            }.merge(options).merge(:version_label => version_label))
+  end
+
+end

data/test/blue_only_deploy_test.rb

@@ -0,0 +1,78 @@
+require 'deploy_test'
+
+class BlueOnlyDeployTest < DeployTest
+  def test_blue_only_deployment_strategy_should_create_blue_env_on_first_deployment
+    do_deploy(42)
+    assert @eb.environment_exists?('simple', t('production-a', 'simple'))
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-a', 'simple'))
+  end
+
+
+  def test_blue_only_deployment_should_create_green_env_if_blue_exists
+    do_deploy(42)
+    do_deploy(43)
+    assert @eb.environment_exists?('simple', t('production-a', 'simple'))
+    assert @eb.environment_exists?('simple', t('production-b', 'simple'))
+  end
+
+
+  def test_blue_only_deployment_should_not_swap_cname_to_make_active_most_recent_updated_env
+    do_deploy(42)
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-a', 'simple'))
+    assert_nil(@eb.environment_cname_prefix('simple', t('production-b', 'simple')))
+    do_deploy(43)
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-a', 'simple'))
+    assert_match(/simple-production-inactive/,  @eb.environment_cname_prefix('simple', t('production-b', 'simple')))
+    do_deploy(44)
+    assert_equal 'simple-production',  @eb.environment_cname_prefix('simple', t('production-a', 'simple'))
+    assert_match(/simple-production-inactive/,  @eb.environment_cname_prefix('simple', t('production-b', 'simple')))
+  end
+
+
+  def test_blue_only_deploy_should_run_smoke_test_before_cname_switch
+    smoked_host = []
+    smoke_test = lambda { |host| smoked_host << host }
+    [42, 43, 44].each do |version_label|
+      do_deploy(version_label, :smoke_test => smoke_test)
+    end
+
+    assert_equal ['simple-production.us-west-1.elasticbeanstalk.com',
+                  'simple-production-inactive.us-west-1.elasticbeanstalk.com',
+                  'simple-production-inactive.us-west-1.elasticbeanstalk.com'], smoked_host
+  end
+
+
+  def test_blue_only_deployment_should_delete_and_recreate_inactive_env_if_phoenix_mode_is_enabled
+    do_deploy(42, :phoenix_mode => true)
+    do_deploy(43, :phoenix_mode => true)
+    assert_equal [],  @eb.environments_been_deleted('simple')
+
+    inactive_env = t('production-b', 'simple')
+    assert_match(/inactive/,  @eb.environment_cname_prefix('simple', inactive_env))
+
+    do_deploy(44, :phoenix_mode => true)
+    assert_equal [inactive_env], @eb.environments_been_deleted('simple')
+
+    assert_match(/inactive/,  @eb.environment_cname_prefix('simple', inactive_env))
+  end
+
+  def test_destroy_should_clean_up_env
+    [42, 44].each do |version|
+      do_deploy(version)
+    end
+
+    destroy(:application => 'simple', :environment => 'production')
+    assert !@eb.environment_exists?('simple', t('production-a', 'simple'))
+    assert !@eb.environment_exists?('simple', t('production-b', 'simple'))
+  end
+
+  private
+
+  def do_deploy(version_label, options={})
+    deploy( {:application => 'simple',
+              :environment => "production",
+              :strategy => 'blue-only',
+            }.merge(options).merge(:version_label => version_label))
+  end
+
+end

data/test/cf_event_poller_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class CfEventPollerTest < Test::Unit::TestCase
+  def setup
+    @cf = CFStub.new
+    @poller = EbDeployer::EventPoller.new(EbDeployer::CfEventSource.new("mystack", @cf))
+  end
+
+  def test_run_handle_block_through_all_events_when_there_is_no_from_anchor
+    messages_handled = []
+    @cf.set_events('mystack', ['a', 'b', nil])
+    @poller.poll(nil) do |event|
+      break if event.resource_status.nil?
+      messages_handled << event.resource_status
+    end
+
+    assert_equal ['a', 'b'], messages_handled
+  end
+
+
+  def test_can_poll_all_events_after_an_anchor
+    @cf.set_events('mystack', ['a', 'b'], ['c', 'd', nil])
+    anchor = @poller.get_anchor
+    messages_handled = []
+    @poller.poll(anchor) do |event|
+      break if event.resource_status.nil?
+      messages_handled << event.resource_status
+    end
+
+    assert_equal ['c', 'd'], messages_handled
+  end
+end

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