shipit-engine 0.5.2 → 0.6.0

data/test/models/delivery_test.rb

@@ -1,37 +1,39 @@
 require 'test_helper'
 
-class DeliveryTest < ActiveSupport::TestCase
-  setup do
-    @hook = hooks(:shipit_deploys)
-    @delivery = deliveries(:scheduled_shipit_deploy)
-  end
+module Shipit
+  class DeliveryTest < ActiveSupport::TestCase
+    setup do
+      @hook = shipit_hooks(:shipit_deploys)
+      @delivery = shipit_deliveries(:scheduled_shipit_deploy)
+    end
 
-  test "#schedule! enqueue a DeliverHookJob and update the status to `scheduled`" do
-    delivery = @hook.deliveries.create!(
-      event: 'deploy',
-      url: 'http://example.com',
-      content_type: 'application/json',
-      payload: '{}',
-    )
-    assert_equal 'pending', delivery.status
+    test "#schedule! enqueue a DeliverHookJob and update the status to `scheduled`" do
+      delivery = @hook.deliveries.create!(
+        event: 'deploy',
+        url: 'http://example.com',
+        content_type: 'application/json',
+        payload: '{}',
+      )
+      assert_equal 'pending', delivery.status
 
-    assert_enqueued_with(job: DeliverHookJob, args: [delivery]) do
-      delivery.schedule!
+      assert_enqueued_with(job: DeliverHookJob, args: [delivery]) do
+        delivery.schedule!
+      end
+      assert_equal 'scheduled', delivery.status
     end
-    assert_equal 'scheduled', delivery.status
-  end
 
-  test "#send! post the payload and update the status to `sent`" do
-    headers = {'content-type' => 'text/plain', 'content-length' => '2'}
-    FakeWeb.register_uri(:post, @delivery.url, headers.merge(body: 'OK'))
+    test "#send! post the payload and update the status to `sent`" do
+      headers = {'content-type' => 'text/plain', 'content-length' => '2'}
+      FakeWeb.register_uri(:post, @delivery.url, headers.merge(body: 'OK'))
 
-    assert_equal 'scheduled', @delivery.status
-    @delivery.send!
+      assert_equal 'scheduled', @delivery.status
+      @delivery.send!
 
-    assert_equal 'sent', @delivery.status
-    assert_not_nil @delivery.delivered_at
-    assert_equal 200, @delivery.response_code
-    assert_equal headers, @delivery.response_headers
-    assert_equal 'OK', @delivery.response_body
+      assert_equal 'sent', @delivery.status
+      assert_not_nil @delivery.delivered_at
+      assert_equal 200, @delivery.response_code
+      assert_equal headers, @delivery.response_headers
+      assert_equal 'OK', @delivery.response_body
+    end
   end
 end

data/test/models/deploys_test.rb

@@ -1,392 +1,394 @@
 require 'test_helper'
 
-class DeploysTest < ActiveSupport::TestCase
-  def setup
-    @deploy = deploys(:shipit)
-    @deploy.pid = 42
-    @stack = stacks(:shipit)
-    @user = users(:walrus)
-  end
+module Shipit
+  class DeploysTest < ActiveSupport::TestCase
+    def setup
+      @deploy = shipit_deploys(:shipit)
+      @deploy.pid = 42
+      @stack = shipit_stacks(:shipit)
+      @user = shipit_users(:walrus)
+    end
 
-  test "#rollback? returns false" do
-    refute @deploy.rollback?
-  end
+    test "#rollback? returns false" do
+      refute @deploy.rollback?
+    end
 
-  test "enqueue" do
-    assert_enqueued_with(job: PerformTaskJob, args: [@deploy]) do
-      @deploy.enqueue
+    test "enqueue" do
+      assert_enqueued_with(job: PerformTaskJob, args: [@deploy]) do
+        @deploy.enqueue
+      end
     end
-  end
 
-  test "enqueue when not persisted" do
-    assert_raise(RuntimeError) { Deploy.new.enqueue }
-  end
+    test "enqueue when not persisted" do
+      assert_raise(RuntimeError) { Deploy.new.enqueue }
+    end
 
-  test "working_directory" do
-    assert_equal File.join(@deploy.stack.deploys_path, @deploy.id.to_s), @deploy.working_directory
-  end
+    test "working_directory" do
+      assert_equal File.join(@deploy.stack.deploys_path, @deploy.id.to_s), @deploy.working_directory
+    end
 
-  test "#since_commit_id returns the database value if present" do
-    @deploy.since_commit_id = 1
-    assert_equal 1, @deploy.since_commit_id
-  end
+    test "#since_commit_id returns the database value if present" do
+      @deploy.since_commit_id = 1
+      assert_equal 1, @deploy.since_commit_id
+    end
 
-  test "#since_commit_id returns nil if stack_id isn't set" do
-    deploy = Deploy.new
-    assert_nil deploy.since_commit_id
-  end
+    test "#since_commit_id returns nil if stack_id isn't set" do
+      deploy = Deploy.new
+      assert_nil deploy.since_commit_id
+    end
 
-  test "#since_commit_id returns a default value if stack_id is set" do
-    stack = stacks(:shipit)
-    deploy = stack.deploys.new
-    last = stack.deploys.success.last.until_commit_id
-    assert_equal last, deploy.since_commit_id
-  end
+    test "#since_commit_id returns a default value if stack_id is set" do
+      stack = shipit_stacks(:shipit)
+      deploy = stack.deploys.new
+      last = stack.deploys.success.last.until_commit_id
+      assert_equal last, deploy.since_commit_id
+    end
 
-  test "#commits returns empty array if stack isn't set" do
-    @deploy.expects(:stack).returns(nil)
-    assert_equal [], @deploy.commits
-  end
+    test "#commits returns empty array if stack isn't set" do
+      @deploy.expects(:stack).returns(nil)
+      assert_equal [], @deploy.commits
+    end
 
-  test "additions and deletions are denormalized on before create" do
-    stack = stacks(:shipit)
-    first = commits(:first)
-    third = commits(:third)
+    test "additions and deletions are denormalized on before create" do
+      stack = shipit_stacks(:shipit)
+      first = shipit_commits(:first)
+      third = shipit_commits(:third)
 
-    deploy = stack.deploys.create!(
-      since_commit: first,
-      until_commit: third,
-    )
+      deploy = stack.deploys.create!(
+        since_commit: first,
+        until_commit: third,
+      )
 
-    assert_equal 13, deploy.additions
-    assert_equal 65, deploy.deletions
-  end
+      assert_equal 13, deploy.additions
+      assert_equal 65, deploy.deletions
+    end
 
-  test "#commits returns the commits in the id range" do
-    stack = stacks(:shipit)
-    first = commits(:first)
-    last = commits(:third)
+    test "#commits returns the commits in the id range" do
+      stack = shipit_stacks(:shipit)
+      first = shipit_commits(:first)
+      last = shipit_commits(:third)
 
-    deploy = stack.deploys.new(
-      since_commit: first,
-      until_commit: last,
-    )
+      deploy = stack.deploys.new(
+        since_commit: first,
+        until_commit: last,
+      )
 
-    commits = deploy.commits
+      commits = deploy.commits
 
-    assert_not_empty commits
-    assert_equal last.id, commits.map(&:id).max
-    assert_not_equal first.id, commits.map(&:id).min
-  end
+      assert_not_empty commits
+      assert_equal last.id, commits.map(&:id).max
+      assert_not_equal first.id, commits.map(&:id).min
+    end
 
-  test "#commits returns commits from newer to older" do
-    stack = stacks(:shipit)
-    first = commits(:first)
-    last = commits(:fourth)
+    test "#commits returns commits from newer to older" do
+      stack = shipit_stacks(:shipit)
+      first = shipit_commits(:first)
+      last = shipit_commits(:fourth)
 
-    deploy = stack.deploys.new(
-      since_commit: first,
-      until_commit: last,
-    )
+      deploy = stack.deploys.new(
+        since_commit: first,
+        until_commit: last,
+      )
 
-    assert_equal [4, 3, 2], deploy.commits.pluck(:id)
-  end
+      assert_equal [4, 3, 2], deploy.commits.pluck(:id)
+    end
 
-  test "transitioning to success causes an event to be broadcasted" do
-    deploy = deploys(:shipit_pending)
+    test "transitioning to success causes an event to be broadcasted" do
+      deploy = shipit_deploys(:shipit_pending)
 
-    expect_hook(:deploy, deploy.stack, status: 'success', deploy: deploy, stack: deploy.stack)
-    expect_event(deploy)
-    deploy.status = 'running'
-    deploy.complete!
-  end
+      expect_hook(:deploy, deploy.stack, status: 'success', deploy: deploy, stack: deploy.stack)
+      expect_event(deploy)
+      deploy.status = 'running'
+      deploy.complete!
+    end
 
-  test "transitioning to failed causes an event to be broadcasted" do
-    deploy = deploys(:shipit_pending)
+    test "transitioning to failed causes an event to be broadcasted" do
+      deploy = shipit_deploys(:shipit_pending)
 
-    expect_hook(:deploy, deploy.stack, status: 'failed', deploy: deploy, stack: deploy.stack)
-    expect_event(deploy)
-    deploy.status = 'running'
-    deploy.failure!
-  end
+      expect_hook(:deploy, deploy.stack, status: 'failed', deploy: deploy, stack: deploy.stack)
+      expect_event(deploy)
+      deploy.status = 'running'
+      deploy.failure!
+    end
 
-  test "transitioning to error causes an event to be broadcasted" do
-    deploy = deploys(:shipit_pending)
+    test "transitioning to error causes an event to be broadcasted" do
+      deploy = shipit_deploys(:shipit_pending)
 
-    expect_hook(:deploy, deploy.stack, status: 'error', deploy: deploy, stack: deploy.stack)
-    expect_event(deploy)
-    deploy.status = 'running'
-    deploy.error!
-  end
+      expect_hook(:deploy, deploy.stack, status: 'error', deploy: deploy, stack: deploy.stack)
+      expect_event(deploy)
+      deploy.status = 'running'
+      deploy.error!
+    end
 
-  test "transitioning to running causes an event to be broadcasted" do
-    deploy = deploys(:shipit_pending)
+    test "transitioning to running causes an event to be broadcasted" do
+      deploy = shipit_deploys(:shipit_pending)
 
-    expect_hook(:deploy, deploy.stack, status: 'running', deploy: deploy, stack: deploy.stack)
-    expect_event(deploy)
-    deploy.status = 'pending'
-    deploy.run!
-  end
+      expect_hook(:deploy, deploy.stack, status: 'running', deploy: deploy, stack: deploy.stack)
+      expect_event(deploy)
+      deploy.status = 'pending'
+      deploy.run!
+    end
 
-  test "creating a deploy causes an event to be broadcasted" do
-    shipit = stacks(:shipit)
-    deploy = shipit.deploys.build(
-      since_commit: shipit.commits.first,
-      until_commit: shipit.commits.last,
-    )
+    test "creating a deploy causes an event to be broadcasted" do
+      shipit = shipit_stacks(:shipit)
+      deploy = shipit.deploys.build(
+        since_commit: shipit.commits.first,
+        until_commit: shipit.commits.last,
+      )
 
-    expect_event(deploy)
-    deploy.save!
-  end
+      expect_event(deploy)
+      deploy.save!
+    end
 
-  test "transitioning to success triggers next deploy when stack uses CD" do
-    commits(:fifth).statuses.create!(state: 'success')
+    test "transitioning to success triggers next deploy when stack uses CD" do
+      shipit_commits(:fifth).statuses.create!(state: 'success')
 
-    deploy = deploys(:shipit_running)
-    deploy.stack.update(continuous_deployment: true)
+      deploy = shipit_deploys(:shipit_running)
+      deploy.stack.update(continuous_deployment: true)
 
-    assert_difference "Deploy.count" do
-      deploy.complete!
+      assert_difference "Deploy.count" do
+        deploy.complete!
+      end
     end
-  end
 
-  test "transitioning to success skips CD deploy when stack doesn't use it" do
-    commits(:fifth).statuses.create!(state: 'success')
+    test "transitioning to success skips CD deploy when stack doesn't use it" do
+      shipit_commits(:fifth).statuses.create!(state: 'success')
 
-    deploy = deploys(:shipit_running)
+      deploy = shipit_deploys(:shipit_running)
 
-    assert_no_difference "Deploy.count" do
-      deploy.complete!
+      assert_no_difference "Deploy.count" do
+        deploy.complete!
+      end
     end
-  end
 
-  test "transitioning to success skips CD when no successful commits after until_commit" do
-    deploy = deploys(:shipit_running)
-    deploy.stack.update(continuous_deployment: true)
+    test "transitioning to success skips CD when no successful commits after until_commit" do
+      deploy = shipit_deploys(:shipit_running)
+      deploy.stack.update(continuous_deployment: true)
 
-    assert_no_difference "Deploy.count" do
-      deploy.complete!
+      assert_no_difference "Deploy.count" do
+        deploy.complete!
+      end
     end
-  end
 
-  test "transitioning to success schedule a fetch of the deployed revision" do
-    @deploy = deploys(:shipit_running)
-    assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
-      @deploy.complete!
+    test "transitioning to success schedule a fetch of the deployed revision" do
+      @deploy = shipit_deploys(:shipit_running)
+      assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
+        @deploy.complete!
+      end
     end
-  end
 
-  test "transitioning to failure schedule a fetch of the deployed revision" do
-    @deploy = deploys(:shipit_running)
-    assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
-      @deploy.failure!
+    test "transitioning to failure schedule a fetch of the deployed revision" do
+      @deploy = shipit_deploys(:shipit_running)
+      assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
+        @deploy.failure!
+      end
     end
-  end
 
-  test "transitioning to error schedule a fetch of the deployed revision" do
-    @deploy = deploys(:shipit_running)
-    assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
-      @deploy.error!
+    test "transitioning to error schedule a fetch of the deployed revision" do
+      @deploy = shipit_deploys(:shipit_running)
+      assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
+        @deploy.error!
+      end
     end
-  end
 
-  test "transitioning to aborted schedule a rollback if required" do
-    @deploy = deploys(:shipit_running)
-    @deploy.pid = 42
-    @deploy.abort!(rollback_once_aborted: true)
+    test "transitioning to aborted schedule a rollback if required" do
+      @deploy = shipit_deploys(:shipit_running)
+      @deploy.pid = 42
+      @deploy.abort!(rollback_once_aborted: true)
 
-    assert_difference -> { @stack.rollbacks.count }, 1 do
-      assert_enqueued_with(job: PerformTaskJob) do
-        @deploy.aborted!
+      assert_difference -> { @stack.rollbacks.count }, 1 do
+        assert_enqueued_with(job: PerformTaskJob) do
+          @deploy.aborted!
+        end
       end
     end
-  end
 
-  test "#build_rollback returns an unsaved record" do
-    assert @deploy.build_rollback.new_record?
-  end
-
-  test "#build_rollback returns a rollback" do
-    assert @deploy.build_rollback.rollback?
-  end
+    test "#build_rollback returns an unsaved record" do
+      assert @deploy.build_rollback.new_record?
+    end
 
-  test "#build_rollback set the id of the rollbacked deploy" do
-    rollback = @deploy.build_rollback
-    assert_equal @deploy.id, rollback.parent_id
-  end
+    test "#build_rollback returns a rollback" do
+      assert @deploy.build_rollback.rollback?
+    end
 
-  test "#build_rollback set the last_deployed_commit as the rollback since_commit" do
-    rollback = @deploy.build_rollback
-    assert_equal @stack.last_deployed_commit, rollback.since_commit
-  end
+    test "#build_rollback set the id of the rollbacked deploy" do
+      rollback = @deploy.build_rollback
+      assert_equal @deploy.id, rollback.parent_id
+    end
 
-  test "#trigger_rollback rolls the stack back to this deploy" do
-    assert_equal commits(:fourth), @stack.last_deployed_commit
-    rollback = @deploy.trigger_rollback
-    rollback.run!
-    rollback.complete!
-    assert_equal commits(:second), @stack.last_deployed_commit
-  end
+    test "#build_rollback set the last_deployed_commit as the rollback since_commit" do
+      rollback = @deploy.build_rollback
+      assert_equal @stack.last_deployed_commit, rollback.since_commit
+    end
 
-  test "#trigger_revert rolls the stack back to before this deploy" do
-    assert_equal commits(:fourth), @stack.last_deployed_commit
-    rollback = @deploy.trigger_revert
-    rollback.run!
-    rollback.complete!
-    assert_equal commits(:first), @stack.last_deployed_commit
-  end
+    test "#trigger_rollback rolls the stack back to this deploy" do
+      assert_equal shipit_commits(:fourth), @stack.last_deployed_commit
+      rollback = @deploy.trigger_rollback
+      rollback.run!
+      rollback.complete!
+      assert_equal shipit_commits(:second), @stack.last_deployed_commit
+    end
 
-  test "#trigger_rollback creates a new Rollback" do
-    assert_difference -> { Rollback.count }, 1 do
-      @deploy.trigger_rollback(@user)
+    test "#trigger_revert rolls the stack back to before this deploy" do
+      assert_equal shipit_commits(:fourth), @stack.last_deployed_commit
+      rollback = @deploy.trigger_revert
+      rollback.run!
+      rollback.complete!
+      assert_equal shipit_commits(:first), @stack.last_deployed_commit
     end
-  end
 
-  test "#trigger_rollback schedule the task" do
-    Hook.expects(:emit).at_least_once
-    assert_enqueued_with(job: PerformTaskJob) do
-      @deploy.trigger_rollback(@user)
+    test "#trigger_rollback creates a new Rollback" do
+      assert_difference -> { Rollback.count }, 1 do
+        @deploy.trigger_rollback(@user)
+      end
     end
-  end
 
-  test "#trigger_rollback locks the stack" do
-    refute @stack.locked?
-    @deploy.trigger_rollback(@user)
-    assert @stack.reload.locked?
-    assert_equal @user, @stack.lock_author
-  end
+    test "#trigger_rollback schedule the task" do
+      Hook.expects(:emit).at_least_once
+      assert_enqueued_with(job: PerformTaskJob) do
+        @deploy.trigger_rollback(@user)
+      end
+    end
 
-  test "pid is persisted" do
-    clone = Deploy.find(@deploy.id)
-    assert_equal 42, clone.pid
-  end
+    test "#trigger_rollback locks the stack" do
+      refute @stack.locked?
+      @deploy.trigger_rollback(@user)
+      assert @stack.reload.locked?
+      assert_equal @user, @stack.lock_author
+    end
 
-  test "abort! transition to `aborting`" do
-    @deploy.abort!
-    assert_equal 'aborting', @deploy.status
-  end
+    test "pid is persisted" do
+      clone = Deploy.find(@deploy.id)
+      assert_equal 42, clone.pid
+    end
 
-  test "abort! schedule the rollback if `rollback_once_aborted` is true" do
-    @deploy.abort!(rollback_once_aborted: true)
-    assert @deploy.reload.rollback_once_aborted?
-  end
+    test "abort! transition to `aborting`" do
+      @deploy.abort!
+      assert_equal 'aborting', @deploy.status
+    end
 
-  test "abort! sends a SIGTERM to the recorded PID" do
-    Process.expects(:kill).with('TERM', @deploy.pid)
-    @deploy.abort!
-  end
+    test "abort! schedule the rollback if `rollback_once_aborted` is true" do
+      @deploy.abort!(rollback_once_aborted: true)
+      assert @deploy.reload.rollback_once_aborted?
+    end
 
-  test "abort! still succeeds if the process is already dead" do
-    Process.expects(:kill).with('TERM', @deploy.pid).raises(Errno::ESRCH)
-    assert_nothing_raised do
+    test "abort! sends a SIGTERM to the recorded PID" do
+      Process.expects(:kill).with('TERM', @deploy.pid)
       @deploy.abort!
     end
-  end
 
-  test "abort! transition to `aborted` if the process is already dead" do
-    @deploy = deploys(:shipit_running)
-    @deploy.pid = 42
+    test "abort! still succeeds if the process is already dead" do
+      Process.expects(:kill).with('TERM', @deploy.pid).raises(Errno::ESRCH)
+      assert_nothing_raised do
+        @deploy.abort!
+      end
+    end
 
-    @deploy.abort!
-    assert_equal 'aborting', @deploy.status
+    test "abort! transition to `aborted` if the process is already dead" do
+      @deploy = shipit_deploys(:shipit_running)
+      @deploy.pid = 42
 
-    Process.expects(:kill).with('TERM', @deploy.pid).raises(Errno::ESRCH)
-    @deploy.abort!
-    assert_equal 'aborted', @deploy.status
-  end
+      @deploy.abort!
+      assert_equal 'aborting', @deploy.status
 
-  test "abort! bails out if the PID is nil" do
-    Process.expects(:kill).never
-    @deploy.pid = nil
-    assert_nothing_raised do
+      Process.expects(:kill).with('TERM', @deploy.pid).raises(Errno::ESRCH)
       @deploy.abort!
+      assert_equal 'aborted', @deploy.status
     end
-  end
 
-  test "destroy deletes the related output chunks" do
-    assert_difference -> { @deploy.chunks.count }, -@deploy.chunks.count do
-      @deploy.destroy
+    test "abort! bails out if the PID is nil" do
+      Process.expects(:kill).never
+      @deploy.pid = nil
+      assert_nothing_raised do
+        @deploy.abort!
+      end
     end
-  end
 
-  test "#chunk_output joins all chunk test if logs not rolled up" do
-    assert_equal @deploy.chunks.count, @deploy.chunks.count
-    assert_equal @deploy.chunks.pluck(:text).join, @deploy.chunk_output
-    refute @deploy.rolled_up
-  end
+    test "destroy deletes the related output chunks" do
+      assert_difference -> { @deploy.chunks.count }, -@deploy.chunks.count do
+        @deploy.destroy
+      end
+    end
 
-  test "#chunk_output returns logs from records if rolled up" do
-    expected_output = @deploy.chunks.pluck(:text).join
-    @deploy.rollup_chunks
+    test "#chunk_output joins all chunk test if logs not rolled up" do
+      assert_equal @deploy.chunks.count, @deploy.chunks.count
+      assert_equal @deploy.chunks.pluck(:text).join, @deploy.chunk_output
+      refute @deploy.rolled_up
+    end
+
+    test "#chunk_output returns logs from records if rolled up" do
+      expected_output = @deploy.chunks.pluck(:text).join
+      @deploy.rollup_chunks
 
-    assert_no_queries do
-      assert_equal expected_output, @deploy.chunk_output
-      assert @deploy.rolled_up
+      assert_no_queries do
+        assert_equal expected_output, @deploy.chunk_output
+        assert @deploy.rolled_up
+      end
     end
-  end
 
-  test "#accept! bails out if the deploy is successful already" do
-    assert_predicate @deploy, :success?
+    test "#accept! bails out if the deploy is successful already" do
+      assert_predicate @deploy, :success?
+
+      Deploy::CONFIRMATIONS_REQUIRED.times do
+        @deploy.accept!
+        assert_predicate @deploy, :success?
+      end
+    end
+
+    test "#accept! first transition to flapping then ultimately to success if the deploy was failed" do
+      @deploy = shipit_deploys(:shipit2)
+      assert_predicate @deploy, :failed?
+
+      (Deploy::CONFIRMATIONS_REQUIRED - 1).times do
+        @deploy.accept!
+        assert_predicate @deploy, :flapping?
+      end
 
-    Deploy::CONFIRMATIONS_REQUIRED.times do
       @deploy.accept!
       assert_predicate @deploy, :success?
     end
-  end
 
-  test "#accept! first transition to flapping then ultimately to success if the deploy was failed" do
-    @deploy = deploys(:shipit2)
-    assert_predicate @deploy, :failed?
+    test "#reject! bails out if the deploy is failed already" do
+      @deploy = shipit_deploys(:shipit2)
+      assert_predicate @deploy, :failed?
 
-    (Deploy::CONFIRMATIONS_REQUIRED - 1).times do
-      @deploy.accept!
-      assert_predicate @deploy, :flapping?
+      Deploy::CONFIRMATIONS_REQUIRED.times do
+        @deploy.reject!
+        assert_predicate @deploy, :failed?
+      end
     end
 
-    @deploy.accept!
-    assert_predicate @deploy, :success?
-  end
+    test "#reject! first transition to flapping then ultimately to failed if the deploy was successful" do
+      assert_predicate @deploy, :success?
 
-  test "#reject! bails out if the deploy is failed already" do
-    @deploy = deploys(:shipit2)
-    assert_predicate @deploy, :failed?
+      (Deploy::CONFIRMATIONS_REQUIRED - 1).times do
+        @deploy.reject!
+        assert_predicate @deploy, :flapping?
+      end
 
-    Deploy::CONFIRMATIONS_REQUIRED.times do
       @deploy.reject!
       assert_predicate @deploy, :failed?
     end
-  end
-
-  test "#reject! first transition to flapping then ultimately to failed if the deploy was successful" do
-    assert_predicate @deploy, :success?
 
-    (Deploy::CONFIRMATIONS_REQUIRED - 1).times do
-      @deploy.reject!
+    test "entering flapping state triggers webhooks" do
+      assert_enqueued_with job: EmitEventJob do
+        @deploy.reject!
+      end
       assert_predicate @deploy, :flapping?
     end
 
-    @deploy.reject!
-    assert_predicate @deploy, :failed?
-  end
+    private
 
-  test "entering flapping state triggers webhooks" do
-    assert_enqueued_with job: EmitEventJob do
-      @deploy.reject!
+    def expect_event(deploy)
+      Pubsubstub::RedisPubSub.expects(:publish).at_least_once
+      Pubsubstub::RedisPubSub.expects(:publish).with do |channel, event|
+        data = JSON.load(event.data)
+        channel == "stack.#{deploy.stack.id}" && data['url'] == "/#{deploy.stack.to_param}"
+      end
     end
-    assert_predicate @deploy, :flapping?
-  end
 
-  private
-
-  def expect_event(deploy)
-    Pubsubstub::RedisPubSub.expects(:publish).at_least_once
-    Pubsubstub::RedisPubSub.expects(:publish).with do |channel, event|
-      data = JSON.load(event.data)
-      channel == "stack.#{deploy.stack.id}" && data['url'] == "/#{deploy.stack.to_param}"
+    def expect_hook(event, stack, payload)
+      Hook.expects(:emit).with(event, stack, payload)
     end
   end
-
-  def expect_hook(event, stack, payload)
-    Hook.expects(:emit).with(event, stack, payload)
-  end
 end