shipit-engine 0.5.2 → 0.6.0

data/test/models/github_hook_test.rb

@@ -1,54 +1,56 @@
 require 'test_helper'
 
-class GithubHookTest < ActiveSupport::TestCase
-  def setup
-    @stack = stacks(:shipit)
-    @hook = github_hooks(:shipit_push)
-  end
+module Shipit
+  class GithubHookTest < ActiveSupport::TestCase
+    def setup
+      @stack = shipit_stacks(:shipit)
+      @hook = shipit_github_hooks(:shipit_push)
+    end
 
-  test "#verify_signature is true if the signature matches" do
-    assert @hook.verify_signature('sha1=9fb52fecc2b97b7a912aca27685149d2ce571900', 'hello shipit')
-  end
+    test "#verify_signature is true if the signature matches" do
+      assert @hook.verify_signature('sha1=9fb52fecc2b97b7a912aca27685149d2ce571900', 'hello shipit')
+    end
 
-  test "#verify_signature is false if the signature doesn't match" do
-    refute @hook.verify_signature('sha1=9fb52fecc2b97b7a912aca27685149d2ce571900', 'hello toto')
-  end
+    test "#verify_signature is false if the signature doesn't match" do
+      refute @hook.verify_signature('sha1=9fb52fecc2b97b7a912aca27685149d2ce571900', 'hello toto')
+    end
 
-  test "#setup! create the hook on Github side" do
-    @hook = github_hooks(:cyclimse_push)
+    test "#setup! create the hook on Github side" do
+      @hook = shipit_github_hooks(:cyclimse_push)
 
-    response = mock(id: 44, rels: {self: mock(href: 'https://api.github.com/somestuff')})
-    Shipit.github_api.expects(:create_hook).with(
-      @hook.github_repo_name,
-      'web',
-      includes(:url, :content_type, :secret),
-      includes(:events, :active),
-    ).returns(response)
-    @hook.setup!
-    @hook.reload
-    assert_equal 44, @hook.github_id
-    assert_equal 'https://api.github.com/somestuff', @hook.api_url
-  end
+      response = mock(id: 44, rels: {self: mock(href: 'https://api.github.com/somestuff')})
+      Shipit.github_api.expects(:create_hook).with(
+        @hook.github_repo_name,
+        'web',
+        includes(:url, :content_type, :secret),
+        includes(:events, :active),
+      ).returns(response)
+      @hook.setup!
+      @hook.reload
+      assert_equal 44, @hook.github_id
+      assert_equal 'https://api.github.com/somestuff', @hook.api_url
+    end
 
-  test "#setup! update the hook it it already exist" do
-    response = mock(id: 44, rels: {self: mock(href: 'https://api.github.com/somestuff')})
-    Shipit.github_api.expects(:edit_hook).with(
-      @hook.github_repo_name,
-      @hook.github_id,
-      'web',
-      includes(:url, :content_type, :secret),
-      includes(:events, :active),
-    ).returns(response)
-    @hook.setup!
-    @hook.reload
-    assert_equal 44, @hook.github_id
-    assert_equal 'https://api.github.com/somestuff', @hook.api_url
-  end
+    test "#setup! update the hook it it already exist" do
+      response = mock(id: 44, rels: {self: mock(href: 'https://api.github.com/somestuff')})
+      Shipit.github_api.expects(:edit_hook).with(
+        @hook.github_repo_name,
+        @hook.github_id,
+        'web',
+        includes(:url, :content_type, :secret),
+        includes(:events, :active),
+      ).returns(response)
+      @hook.setup!
+      @hook.reload
+      assert_equal 44, @hook.github_id
+      assert_equal 'https://api.github.com/somestuff', @hook.api_url
+    end
 
-  test "#destroy starts by removing the hook" do
-    Shipit.github_api.expects(:remove_hook).with(@hook.github_repo_name, @hook.github_id)
-    assert_difference -> { GithubHook.count }, -1 do
-      @hook.destroy!
+    test "#destroy starts by removing the hook" do
+      Shipit.github_api.expects(:remove_hook).with(@hook.github_repo_name, @hook.github_id)
+      assert_difference -> { GithubHook.count }, -1 do
+        @hook.destroy!
+      end
     end
   end
 end

data/test/models/hook_test.rb

@@ -1,57 +1,59 @@
 require 'test_helper'
 
-class HookTest < ActiveSupport::TestCase
-  setup do
-    @stack = stacks(:shipit)
-    @hook = hooks(:shipit_deploys)
-  end
-
-  test "#url must be valid" do
-    @hook.url = 'file:/ad"fa/adfa'
-    refute @hook.valid?
-    assert_equal ['Url is not a valid URL'], @hook.errors.full_messages
-  end
+module Shipit
+  class HookTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @hook = shipit_hooks(:shipit_deploys)
+    end
 
-  test "#url must not be localhost" do
-    @hook.url = 'file:///etc/passwd'
-    refute @hook.valid?
-    assert_equal ['Url is not a valid URL'], @hook.errors.full_messages
-  end
+    test "#url must be valid" do
+      @hook.url = 'file:/ad"fa/adfa'
+      refute @hook.valid?
+      assert_equal ['Url is not a valid URL'], @hook.errors.full_messages
+    end
 
-  test "#events is accessible as an array" do
-    assert_equal %w(deploy rollback), @hook.events
-  end
+    test "#url must not be localhost" do
+      @hook.url = 'file:///etc/passwd'
+      refute @hook.valid?
+      assert_equal ['Url is not a valid URL'], @hook.errors.full_messages
+    end
 
-  test "#events can only contain a defined set of values" do
-    @hook.events = %w(foo)
-    refute @hook.valid?
-    assert_equal ["Events is not a strict subset of #{Hook::EVENTS.inspect}"], @hook.errors.full_messages
-  end
+    test "#events is accessible as an array" do
+      assert_equal %w(deploy rollback), @hook.events
+    end
 
-  test ".emit enqueues an EmitEventJob with the proper payload" do
-    assert_enqueued_with(job: EmitEventJob) do
-      Hook.emit(:deploy, @stack, foo: 42)
+    test "#events can only contain a defined set of values" do
+      @hook.events = %w(foo)
+      refute @hook.valid?
+      assert_equal ["Events is not a strict subset of #{Hook::EVENTS.inspect}"], @hook.errors.full_messages
     end
-  end
 
-  test ".deliver schedules a delivery for each matching hook" do
-    assert_difference -> { Delivery.count }, 2 do
-      Hook.deliver(:deploy, @stack, 'foo' => 42)
+    test ".emit enqueues an EmitEventJob with the proper payload" do
+      assert_enqueued_with(job: EmitEventJob) do
+        Hook.emit(:deploy, @stack, foo: 42)
+      end
     end
 
-    delivery = Delivery.last
+    test ".deliver schedules a delivery for each matching hook" do
+      assert_difference -> { Delivery.count }, 2 do
+        Hook.deliver(:deploy, @stack, 'foo' => 42)
+      end
 
-    assert_equal @hook.url, delivery.url
-    assert_equal 'application/x-www-form-urlencoded', delivery.content_type
-    assert_equal 'foo=42', delivery.payload
-    assert_equal 'scheduled', delivery.status
-  end
+      delivery = Delivery.last
 
-  test ".scoped? returns true if the hook has a stack_id" do
-    @hook.stack_id = nil
-    refute @hook.scoped?
+      assert_equal @hook.url, delivery.url
+      assert_equal 'application/x-www-form-urlencoded', delivery.content_type
+      assert_equal 'foo=42', delivery.payload
+      assert_equal 'scheduled', delivery.status
+    end
+
+    test ".scoped? returns true if the hook has a stack_id" do
+      @hook.stack_id = nil
+      refute @hook.scoped?
 
-    @hook.stack_id = 42
-    assert @hook.scoped?
+      @hook.stack_id = 42
+      assert @hook.scoped?
+    end
   end
 end

data/test/models/membership_test.rb

@@ -1,12 +1,14 @@
 require 'test_helper'
 
-class MembershipTest < ActiveSupport::TestCase
-  setup do
-    @membership = memberships(:walrus_shopify_developers)
-  end
+module Shipit
+  class MembershipTest < ActiveSupport::TestCase
+    setup do
+      @membership = shipit_memberships(:walrus_shopify_developers)
+    end
 
-  test "no duplicates are accepted" do
-    membership = Membership.new(user: @membership.user, team: @membership.team)
-    refute membership.valid?
+    test "no duplicates are accepted" do
+      membership = Membership.new(user: @membership.user, team: @membership.team)
+      refute membership.valid?
+    end
   end
 end

data/test/models/missing_status_test.rb

@@ -1,21 +1,23 @@
 require 'test_helper'
 
-class MissingStatusTest < ActiveSupport::TestCase
-  setup do
-    @real_status = statuses(:first_pending)
-    @status = MissingStatus.new(@real_status, %w(ci/very-important style/very-important-too))
-  end
+module Shipit
+  class MissingStatusTest < ActiveSupport::TestCase
+    setup do
+      @real_status = shipit_statuses(:first_pending)
+      @status = MissingStatus.new(@real_status, %w(ci/very-important style/very-important-too))
+    end
 
-  test "#state is 'missing'" do
-    assert_equal 'missing', @status.state
-  end
+    test "#state is 'missing'" do
+      assert_equal 'missing', @status.state
+    end
 
-  test "#description explains the situation" do
-    message = 'ci/very-important and style/very-important-too are required for deploy but were not sent'
-    assert_equal message, @status.description
-  end
+    test "#description explains the situation" do
+      message = 'ci/very-important and style/very-important-too are required for deploy but were not sent'
+      assert_equal message, @status.description
+    end
 
-  test "#success? is false" do
-    refute_predicate @status, :success?
+    test "#success? is false" do
+      refute_predicate @status, :success?
+    end
   end
 end

data/test/models/output_chunk_test.rb

@@ -1,18 +1,20 @@
 require 'test_helper'
 
-class OutputChunkTest < ActiveSupport::TestCase
-  def setup
-    @deploy = deploys(:shipit)
-    @chunks = 3.times.map { OutputChunk.create!(text: 'bla', task: @deploy) }
-  end
+module Shipit
+  class OutputChunkTest < ActiveSupport::TestCase
+    def setup
+      @deploy = shipit_deploys(:shipit)
+      @chunks = 3.times.map { OutputChunk.create!(text: 'bla', task: @deploy) }
+    end
 
-  test "tail" do
-    start = @chunks.first
-    rest = @chunks - [start]
-    assert_equal rest, @deploy.chunks.tail(start.id)
-  end
+    test "tail" do
+      start = @chunks.first
+      rest = @chunks - [start]
+      assert_equal rest, @deploy.chunks.tail(start.id)
+    end
 
-  test "tail without start" do
-    assert_equal @deploy.chunks, @deploy.chunks.tail(nil)
+    test "tail without start" do
+      assert_equal @deploy.chunks, @deploy.chunks.tail(nil)
+    end
   end
 end

data/test/models/rollbacks_test.rb

@@ -1,19 +1,21 @@
 require 'test_helper'
 
-class RollbackTest < ActiveSupport::TestCase
-  setup do
-    @rollback = Rollback.new
-  end
+module Shipit
+  class RollbackTest < ActiveSupport::TestCase
+    setup do
+      @rollback = Rollback.new
+    end
 
-  test "#rollback? returns true" do
-    assert @rollback.rollback?
-  end
+    test "#rollback? returns true" do
+      assert @rollback.rollback?
+    end
 
-  test "#rollbackable? returns false" do
-    refute @rollback.rollbackable?
-  end
+    test "#rollbackable? returns false" do
+      refute @rollback.rollbackable?
+    end
 
-  test "#supports_rollback? returns false" do
-    refute @rollback.supports_rollback?
+    test "#supports_rollback? returns false" do
+      refute @rollback.supports_rollback?
+    end
   end
 end

data/test/models/stacks_test.rb

@@ -1,354 +1,356 @@
 require 'test_helper'
 
-class StacksTest < ActiveSupport::TestCase
-  def setup
-    @stack = stacks(:shipit)
-    @expected_base_path = Rails.root.join('data/stacks', @stack.to_param).to_s
-    GithubHook.any_instance.stubs(:teardown!)
-  end
+module Shipit
+  class StacksTest < ActiveSupport::TestCase
+    def setup
+      @stack = shipit_stacks(:shipit)
+      @expected_base_path = Rails.root.join('data/stacks', @stack.to_param).to_s
+      GithubHook.any_instance.stubs(:teardown!)
+    end
 
-  test "repo_owner, repo_name and environment uniqueness is enforced" do
-    clone = Stack.new(@stack.attributes.except('id'))
-    refute clone.save
-    assert_equal ["has already been taken"], clone.errors[:repo_name]
-  end
+    test "repo_owner, repo_name and environment uniqueness is enforced" do
+      clone = Stack.new(@stack.attributes.except('id'))
+      refute clone.save
+      assert_equal ["has already been taken"], clone.errors[:repo_name]
+    end
 
-  test "repo_owner, repo_name, and environment can only be ASCII" do
-    @stack.update(repo_owner: 'héllò', repo_name: 'wørld', environment: 'pródüctïòn')
-    refute_predicate @stack, :valid?
-  end
+    test "repo_owner, repo_name, and environment can only be ASCII" do
+      @stack.update(repo_owner: 'héllò', repo_name: 'wørld', environment: 'pródüctïòn')
+      refute_predicate @stack, :valid?
+    end
 
-  test "repo_owner is automatically downcased" do
-    @stack.repo_owner = 'George'
-    assert_equal 'george', @stack.repo_owner
-  end
+    test "repo_owner is automatically downcased" do
+      @stack.repo_owner = 'George'
+      assert_equal 'george', @stack.repo_owner
+    end
 
-  test "repo_name is automatically downcased" do
-    @stack.repo_name = 'Cyclim.se'
-    assert_equal 'cyclim.se', @stack.repo_name
-  end
+    test "repo_name is automatically downcased" do
+      @stack.repo_name = 'Cyclim.se'
+      assert_equal 'cyclim.se', @stack.repo_name
+    end
 
-  test "branch defaults to master" do
-    @stack.branch = ""
-    assert @stack.save
-    assert_equal 'master', @stack.branch
-  end
+    test "branch defaults to master" do
+      @stack.branch = ""
+      assert @stack.save
+      assert_equal 'master', @stack.branch
+    end
 
-  test "environment defaults to production" do
-    @stack.environment = ""
-    assert @stack.save
-    assert_equal 'production', @stack.environment
-  end
+    test "environment defaults to production" do
+      @stack.environment = ""
+      assert @stack.save
+      assert_equal 'production', @stack.environment
+    end
 
-  test "environment can contain a `:`" do
-    @stack.environment = 'foo:bar'
-    assert @stack.save
-    assert_equal 'foo:bar', @stack.environment
-  end
+    test "environment can contain a `:`" do
+      @stack.environment = 'foo:bar'
+      assert @stack.save
+      assert_equal 'foo:bar', @stack.environment
+    end
 
-  test "repo_owner cannot contain a `/`" do
-    assert @stack.valid?
-    @stack.repo_owner = 'foo/bar'
-    refute @stack.valid?
-  end
+    test "repo_owner cannot contain a `/`" do
+      assert @stack.valid?
+      @stack.repo_owner = 'foo/bar'
+      refute @stack.valid?
+    end
 
-  test "repo_name cannot contain a `/`" do
-    assert @stack.valid?
-    @stack.repo_name = 'foo/bar'
-    refute @stack.valid?
-  end
+    test "repo_name cannot contain a `/`" do
+      assert @stack.valid?
+      @stack.repo_name = 'foo/bar'
+      refute @stack.valid?
+    end
 
-  test "repo_http_url" do
-    assert_equal "https://github.com/#{@stack.repo_owner}/#{@stack.repo_name}", @stack.repo_http_url
-  end
+    test "repo_http_url" do
+      assert_equal "https://github.com/#{@stack.repo_owner}/#{@stack.repo_name}", @stack.repo_http_url
+    end
 
-  test "repo_git_url" do
-    assert_equal "git@github.com:#{@stack.repo_owner}/#{@stack.repo_name}.git", @stack.repo_git_url
-  end
+    test "repo_git_url" do
+      assert_equal "git@github.com:#{@stack.repo_owner}/#{@stack.repo_name}.git", @stack.repo_git_url
+    end
 
-  test "base_path" do
-    assert_equal @expected_base_path, @stack.base_path.to_s
-  end
+    test "base_path" do
+      assert_equal @expected_base_path, @stack.base_path.to_s
+    end
 
-  test "deploys_path" do
-    assert_equal File.join(@expected_base_path, "deploys"), @stack.deploys_path.to_s
-  end
+    test "deploys_path" do
+      assert_equal File.join(@expected_base_path, "deploys"), @stack.deploys_path.to_s
+    end
 
-  test "git_path" do
-    assert_equal File.join(@expected_base_path, "git"), @stack.git_path.to_s
-  end
+    test "git_path" do
+      assert_equal File.join(@expected_base_path, "git"), @stack.git_path.to_s
+    end
 
-  test "#trigger_deploy persist a new deploy" do
-    last_commit = commits(:third)
-    deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
-    assert deploy.persisted?
-    assert_equal last_commit.id, deploy.until_commit_id
-    assert_equal deploys(:shipit_complete).until_commit_id, deploy.since_commit_id
-  end
+    test "#trigger_deploy persist a new deploy" do
+      last_commit = shipit_commits(:third)
+      deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
+      assert deploy.persisted?
+      assert_equal last_commit.id, deploy.until_commit_id
+      assert_equal shipit_deploys(:shipit_complete).until_commit_id, deploy.since_commit_id
+    end
 
-  test "#trigger_deploy deploy until the commit passed in argument" do
-    last_commit = commits(:third)
-    deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
-    assert_equal last_commit.id, deploy.until_commit_id
-  end
+    test "#trigger_deploy deploy until the commit passed in argument" do
+      last_commit = shipit_commits(:third)
+      deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
+      assert_equal last_commit.id, deploy.until_commit_id
+    end
 
-  test "#trigger_deploy since_commit is the last completed deploy until_commit if there is a previous deploy" do
-    last_commit = commits(:fifth)
-    deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
-    assert_equal deploys(:shipit_complete).until_commit_id, deploy.since_commit_id
-  end
+    test "#trigger_deploy since_commit is the last completed deploy until_commit if there is a previous deploy" do
+      last_commit = shipit_commits(:fifth)
+      deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
+      assert_equal shipit_deploys(:shipit_complete).until_commit_id, deploy.since_commit_id
+    end
 
-  test "#trigger_deploy since_commit is the first stack commit if there is no previous deploy" do
-    @stack.deploys.destroy_all
+    test "#trigger_deploy since_commit is the first stack commit if there is no previous deploy" do
+      @stack.deploys.destroy_all
 
-    last_commit = commits(:third)
-    deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
-    assert_equal @stack.commits.first.id, deploy.since_commit_id
-  end
+      last_commit = shipit_commits(:third)
+      deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
+      assert_equal @stack.commits.first.id, deploy.since_commit_id
+    end
 
-  test "#trigger_deploy enqueue  a deploy job" do
-    @stack.deploys.destroy_all
-    Deploy.any_instance.expects(:enqueue).once
+    test "#trigger_deploy enqueue  a deploy job" do
+      @stack.deploys.destroy_all
+      Deploy.any_instance.expects(:enqueue).once
 
-    last_commit = commits(:third)
-    deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
-    assert_instance_of Deploy, deploy
-  end
+      last_commit = shipit_commits(:third)
+      deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
+      assert_instance_of Deploy, deploy
+    end
 
-  test "#update_deployed_revision bail out if there is an active deploy" do
-    assert_no_difference 'Deploy.count' do
-      @stack.update_deployed_revision(commits(:fifth).sha)
+    test "#update_deployed_revision bail out if there is an active deploy" do
+      assert_no_difference 'Deploy.count' do
+        @stack.update_deployed_revision(shipit_commits(:fifth).sha)
+      end
     end
-  end
 
-  test "#update_deployed_revision bail out if sha is unknown" do
-    assert_no_difference 'Deploy.count' do
-      @stack.update_deployed_revision('skldjaslkdjas')
+    test "#update_deployed_revision bail out if sha is unknown" do
+      assert_no_difference 'Deploy.count' do
+        @stack.update_deployed_revision('skldjaslkdjas')
+      end
     end
-  end
 
-  test "#update_deployed_revision create a new completed deploy" do
-    Deploy.active.update_all(status: 'error')
+    test "#update_deployed_revision create a new completed deploy" do
+      Deploy.active.update_all(status: 'error')
 
-    assert_equal commits(:fourth), @stack.last_deployed_commit
-    assert_difference 'Deploy.count', 1 do
-      deploy = @stack.update_deployed_revision(commits(:fifth).sha)
-      assert_not_nil deploy
-      assert_equal commits(:fourth), deploy.since_commit
-      assert_equal commits(:fifth), deploy.until_commit
+      assert_equal shipit_commits(:fourth), @stack.last_deployed_commit
+      assert_difference 'Deploy.count', 1 do
+        deploy = @stack.update_deployed_revision(shipit_commits(:fifth).sha)
+        assert_not_nil deploy
+        assert_equal shipit_commits(:fourth), deploy.since_commit
+        assert_equal shipit_commits(:fifth), deploy.until_commit
+      end
+      assert_equal shipit_commits(:fifth), @stack.last_deployed_commit
     end
-    assert_equal commits(:fifth), @stack.last_deployed_commit
-  end
 
-  test "#update_deployed_revision creates a new completed deploy without previous deploys" do
-    stack = stacks(:undeployed_stack)
-    assert_empty stack.deploys_and_rollbacks
-    assert_difference 'Deploy.count', 1 do
-      deploy = stack.update_deployed_revision(commits(:undeployed_stack_first).sha)
-      assert_not_nil deploy
-      assert_equal commits(:undeployed_stack_first), deploy.since_commit
-      assert_equal commits(:undeployed_stack_first), deploy.until_commit
+    test "#update_deployed_revision creates a new completed deploy without previous deploys" do
+      stack = shipit_stacks(:undeployed_stack)
+      assert_empty stack.deploys_and_rollbacks
+      assert_difference 'Deploy.count', 1 do
+        deploy = stack.update_deployed_revision(shipit_commits(:undeployed_stack_first).sha)
+        assert_not_nil deploy
+        assert_equal shipit_commits(:undeployed_stack_first), deploy.since_commit
+        assert_equal shipit_commits(:undeployed_stack_first), deploy.until_commit
+      end
+      assert_equal shipit_commits(:undeployed_stack_first), stack.last_deployed_commit
     end
-    assert_equal commits(:undeployed_stack_first), stack.last_deployed_commit
-  end
 
-  test "#update_deployed_revision works with short shas" do
-    Deploy.active.update_all(status: 'error')
+    test "#update_deployed_revision works with short shas" do
+      Deploy.active.update_all(status: 'error')
 
-    assert_equal commits(:fourth), @stack.last_deployed_commit
-    assert_difference 'Deploy.count', 1 do
-      deploy = @stack.update_deployed_revision(commits(:fifth).sha[0..5])
-      assert_not_nil deploy
-      assert_equal commits(:fourth), deploy.since_commit
-      assert_equal commits(:fifth), deploy.until_commit
+      assert_equal shipit_commits(:fourth), @stack.last_deployed_commit
+      assert_difference 'Deploy.count', 1 do
+        deploy = @stack.update_deployed_revision(shipit_commits(:fifth).sha[0..5])
+        assert_not_nil deploy
+        assert_equal shipit_commits(:fourth), deploy.since_commit
+        assert_equal shipit_commits(:fifth), deploy.until_commit
+      end
+      assert_equal shipit_commits(:fifth), @stack.last_deployed_commit
     end
-    assert_equal commits(:fifth), @stack.last_deployed_commit
-  end
 
-  test "#update_deployed_revision accepts the deploy if the reported revision is consistent" do
-    Deploy.active.update_all(status: 'error')
+    test "#update_deployed_revision accepts the deploy if the reported revision is consistent" do
+      Deploy.active.update_all(status: 'error')
 
-    Deploy.any_instance.expects(:accept!).once
-    last_deploy = @stack.deploys_and_rollbacks.completed.last
-    @stack.update_deployed_revision(last_deploy.until_commit.sha)
-  end
+      Deploy.any_instance.expects(:accept!).once
+      last_deploy = @stack.deploys_and_rollbacks.completed.last
+      @stack.update_deployed_revision(last_deploy.until_commit.sha)
+    end
 
-  test "#update_deployed_revision reject the deploy if the reported revision is inconsistent" do
-    Deploy.active.update_all(status: 'error')
+    test "#update_deployed_revision reject the deploy if the reported revision is inconsistent" do
+      Deploy.active.update_all(status: 'error')
 
-    Deploy.any_instance.expects(:reject!).once
-    last_deploy = @stack.deploys_and_rollbacks.completed.last
-    @stack.update_deployed_revision(last_deploy.since_commit.sha)
-  end
-
-  test "#create queues 2 GithubSetupWebhooksJob" do
-    assert_enqueued_with(job: SetupGithubHookJob) do
-      Stack.create!(repo_name: 'rails', repo_owner: 'rails')
+      Deploy.any_instance.expects(:reject!).once
+      last_deploy = @stack.deploys_and_rollbacks.completed.last
+      @stack.update_deployed_revision(last_deploy.since_commit.sha)
     end
-  end
 
-  test "#create queues a GithubSyncJob" do
-    assert_enqueued_with(job: GithubSyncJob) do
-      Stack.create!(repo_name: 'rails', repo_owner: 'rails')
+    test "#create queues 2 GithubSetupWebhooksJob" do
+      assert_enqueued_with(job: SetupGithubHookJob) do
+        Stack.create!(repo_name: 'rails', repo_owner: 'rails')
+      end
     end
-  end
 
-  test "#destroy also destroy associated GithubHooks" do
-    assert_difference -> { GithubHook.count }, -2 do
-      stacks(:shipit).destroy
+    test "#create queues a GithubSyncJob" do
+      assert_enqueued_with(job: GithubSyncJob) do
+        Stack.create!(repo_name: 'rails', repo_owner: 'rails')
+      end
     end
-  end
 
-  test "#destroy delete all local files (git mirror and deploy clones)" do
-    FileUtils.expects(:rm_rf).with(Rails.root.join('data', 'stacks', 'shopify', 'shipit-engine', 'production').to_s)
-    stacks(:shipit).destroy
-  end
-
-  test "#deploying? is false if stack has no deploy in either pending or running state" do
-    @stack.deploys.active.destroy_all
-    refute @stack.deploying?
-  end
+    test "#destroy also destroy associated GithubHooks" do
+      assert_difference -> { GithubHook.count }, -2 do
+        shipit_stacks(:shipit).destroy
+      end
+    end
 
-  test "#deploying? is false if stack has no deploy at all" do
-    @stack.deploys.destroy_all
-    refute @stack.deploying?
-  end
+    test "#destroy delete all local files (git mirror and deploy clones)" do
+      FileUtils.expects(:rm_rf).with(Rails.root.join('data', 'stacks', 'shopify', 'shipit-engine', 'production').to_s)
+      shipit_stacks(:shipit).destroy
+    end
 
-  test "#deploying? is true if stack has a deploy in either pending or running state" do
-    @stack.trigger_deploy(commits(:third), AnonymousUser.new)
-    assert @stack.deploying?
-  end
+    test "#deploying? is false if stack has no deploy in either pending or running state" do
+      @stack.deploys.active.destroy_all
+      refute @stack.deploying?
+    end
 
-  test "#deploying? is true if a rollback is ongoing" do
-    deploys(:shipit_complete).trigger_rollback(AnonymousUser.new)
-    assert @stack.deploying?
-  end
+    test "#deploying? is false if stack has no deploy at all" do
+      @stack.deploys.destroy_all
+      refute @stack.deploying?
+    end
 
-  test "#deploying? is memoized" do
-    assert_queries(1) do
-      10.times { @stack.deploying? }
+    test "#deploying? is true if stack has a deploy in either pending or running state" do
+      @stack.trigger_deploy(shipit_commits(:third), AnonymousUser.new)
+      assert @stack.deploying?
     end
-  end
 
-  test "#deploying? cache is cleared if a deploy change state" do
-    assert_queries(1) do
-      10.times { @stack.deploying? }
+    test "#deploying? is true if a rollback is ongoing" do
+      shipit_deploys(:shipit_complete).trigger_rollback(AnonymousUser.new)
+      assert @stack.deploying?
     end
-    @stack.tasks.where(status: 'running').first.error!
-    assert_queries(1) do
-      10.times { @stack.deploying? }
+
+    test "#deploying? is memoized" do
+      assert_queries(1) do
+        10.times { @stack.deploying? }
+      end
     end
-  end
 
-  test "#deployable? returns true if stack is not locked and is not deploying" do
-    @stack.deploys.destroy_all
-    assert @stack.deployable?
-  end
+    test "#deploying? cache is cleared if a deploy change state" do
+      assert_queries(1) do
+        10.times { @stack.deploying? }
+      end
+      @stack.tasks.where(status: 'running').first.error!
+      assert_queries(1) do
+        10.times { @stack.deploying? }
+      end
+    end
 
-  test "#deployable? returns false if stack is locked" do
-    @stack.update!(lock_reason: 'Maintenance operation')
-    refute @stack.deployable?
-  end
+    test "#deployable? returns true if stack is not locked and is not deploying" do
+      @stack.deploys.destroy_all
+      assert @stack.deployable?
+    end
 
-  test "#deployable? returns false if stack is deploying" do
-    @stack.trigger_deploy(commits(:third), AnonymousUser.new)
-    refute @stack.deployable?
-  end
+    test "#deployable? returns false if stack is locked" do
+      @stack.update!(lock_reason: 'Maintenance operation')
+      refute @stack.deployable?
+    end
 
-  test "#monitoring is empty if cached_deploy_spec is blank" do
-    @stack.cached_deploy_spec = nil
-    assert_equal [], @stack.monitoring
-  end
+    test "#deployable? returns false if stack is deploying" do
+      @stack.trigger_deploy(shipit_commits(:third), AnonymousUser.new)
+      refute @stack.deployable?
+    end
 
-  test "#monitoring returns deploy_spec's content" do
-    assert_equal [{'image' => 'https://example.com/monitor.png', 'width' => 200, 'height' => 300}], @stack.monitoring
-  end
+    test "#monitoring is empty if cached_deploy_spec is blank" do
+      @stack.cached_deploy_spec = nil
+      assert_equal [], @stack.monitoring
+    end
 
-  test "#destroy deletes the related commits" do
-    assert_difference -> { @stack.commits.count }, -@stack.commits.count do
-      @stack.destroy
+    test "#monitoring returns deploy_spec's content" do
+      assert_equal [{'image' => 'https://example.com/monitor.png', 'width' => 200, 'height' => 300}], @stack.monitoring
     end
-  end
 
-  test "#destroy deletes the related tasks" do
-    assert_difference -> { @stack.tasks.count }, -@stack.tasks.count do
-      @stack.destroy
+    test "#destroy deletes the related commits" do
+      assert_difference -> { @stack.commits.count }, -@stack.commits.count do
+        @stack.destroy
+      end
     end
-  end
 
-  test "#destroy deletes the related webhooks" do
-    assert_difference -> { @stack.github_hooks.count }, -@stack.github_hooks.count do
-      @stack.destroy
+    test "#destroy deletes the related tasks" do
+      assert_difference -> { @stack.tasks.count }, -@stack.tasks.count do
+        @stack.destroy
+      end
     end
-  end
 
-  test "locking the stack triggers a webhook" do
-    expect_hook(:lock, @stack, locked: true, stack: @stack)
-    @stack.update(lock_reason: "Just for fun", lock_author: users(:walrus))
-  end
+    test "#destroy deletes the related webhooks" do
+      assert_difference -> { @stack.github_hooks.count }, -@stack.github_hooks.count do
+        @stack.destroy
+      end
+    end
 
-  test "unlocking the stack triggers a webhook" do
-    @stack.update(lock_reason: "Just for fun", lock_author: users(:walrus))
-    expect_hook(:lock, @stack, locked: false, stack: @stack)
-    @stack.update(lock_reason: nil)
-  end
+    test "locking the stack triggers a webhook" do
+      expect_hook(:lock, @stack, locked: true, stack: @stack)
+      @stack.update(lock_reason: "Just for fun", lock_author: shipit_users(:walrus))
+    end
 
-  test "the git cache lock prevent concurrent access to the git cache" do
-    @stack.acquire_git_cache_lock do
-      assert_raises Redis::Lock::LockTimeout do
-        @stack.acquire_git_cache_lock(timeout: 0.1) {}
-      end
+    test "unlocking the stack triggers a webhook" do
+      @stack.update(lock_reason: "Just for fun", lock_author: shipit_users(:walrus))
+      expect_hook(:lock, @stack, locked: false, stack: @stack)
+      @stack.update(lock_reason: nil)
     end
-  end
 
-  test "the git cache lock is scoped to the stack" do
-    called = false
-    stacks(:cyclimse).acquire_git_cache_lock do
+    test "the git cache lock prevent concurrent access to the git cache" do
       @stack.acquire_git_cache_lock do
-        called = true
+        assert_raises Redis::Lock::LockTimeout do
+          @stack.acquire_git_cache_lock(timeout: 0.1) {}
+        end
       end
     end
-    assert called
-  end
 
-  test "#clear_git_cache! deletes the stack git directory" do
-    FileUtils.mkdir_p(@stack.git_path)
-    path = File.join(@stack.git_path, 'foo')
-    File.write(path, 'bar')
-    @stack.clear_git_cache!
-    refute File.exist?(path)
-  end
+    test "the git cache lock is scoped to the stack" do
+      called = false
+      shipit_stacks(:cyclimse).acquire_git_cache_lock do
+        @stack.acquire_git_cache_lock do
+          called = true
+        end
+      end
+      assert called
+    end
 
-  test "#clear_git_cache! does nothing if the git directory is not present" do
-    FileUtils.rm_rf(@stack.git_path)
-    assert_nothing_raised do
+    test "#clear_git_cache! deletes the stack git directory" do
+      FileUtils.mkdir_p(@stack.git_path)
+      path = File.join(@stack.git_path, 'foo')
+      File.write(path, 'bar')
       @stack.clear_git_cache!
+      refute File.exist?(path)
     end
-  end
 
-  test "#filter_visible_statuses removes statuses from hidden contexts" do
-    stack = stacks(:cyclimse)
-    stack.stubs(hidden_statuses: ['ci/hidden'])
-    commit1 = Status.new(state: 'pending', context: 'ci/valid')
-    commit2 = Status.new(state: 'pending', context: 'ci/valid')
-    hidden = Status.new(state: 'pending', context: 'ci/hidden')
+    test "#clear_git_cache! does nothing if the git directory is not present" do
+      FileUtils.rm_rf(@stack.git_path)
+      assert_nothing_raised do
+        @stack.clear_git_cache!
+      end
+    end
 
-    assert_equal [commit1, commit2], stack.filter_visible_statuses([hidden, commit1, commit2])
-  end
+    test "#filter_visible_statuses removes statuses from hidden contexts" do
+      stack = shipit_stacks(:cyclimse)
+      stack.stubs(hidden_statuses: ['ci/hidden'])
+      commit1 = Status.new(state: 'pending', context: 'ci/valid')
+      commit2 = Status.new(state: 'pending', context: 'ci/valid')
+      hidden = Status.new(state: 'pending', context: 'ci/hidden')
 
-  test "#filter_meaningful_statuses removes statuses from soft-failing contexts" do
-    stack = stacks(:cyclimse)
-    stack.stubs(soft_failing_statuses: ['ci/soft-fail'])
-    commit1 = Status.new(state: 'pending', context: 'ci/valid')
-    commit2 = Status.new(state: 'pending', context: 'ci/valid')
-    soft_fail = Status.new(state: 'pending', context: 'ci/soft-fail')
+      assert_equal [commit1, commit2], stack.filter_visible_statuses([hidden, commit1, commit2])
+    end
 
-    assert_equal [commit1, commit2], stack.filter_meaningful_statuses([soft_fail, commit1, commit2])
-  end
+    test "#filter_meaningful_statuses removes statuses from soft-failing contexts" do
+      stack = shipit_stacks(:cyclimse)
+      stack.stubs(soft_failing_statuses: ['ci/soft-fail'])
+      commit1 = Status.new(state: 'pending', context: 'ci/valid')
+      commit2 = Status.new(state: 'pending', context: 'ci/valid')
+      soft_fail = Status.new(state: 'pending', context: 'ci/soft-fail')
 
-  private
+      assert_equal [commit1, commit2], stack.filter_meaningful_statuses([soft_fail, commit1, commit2])
+    end
+
+    private
 
-  def expect_hook(event, stack, payload)
-    Hook.expects(:emit).with(event, stack, payload)
+    def expect_hook(event, stack, payload)
+      Hook.expects(:emit).with(event, stack, payload)
+    end
   end
 end