shipit-engine 0.5.2 → 0.6.0

data/test/jobs/refresh_github_user_job_test.rb

@@ -1,13 +1,15 @@
 require 'test_helper'
 
-class RefreshGithubUserJobTest < ActiveSupport::TestCase
-  setup do
-    @user = users(:walrus)
-    @job = RefreshGithubUserJob.new
-  end
+module Shipit
+  class RefreshGithubUserJobTest < ActiveSupport::TestCase
+    setup do
+      @user = shipit_users(:walrus)
+      @job = RefreshGithubUserJob.new
+    end
 
-  test "#perform call #refresh_from_github! on the provided user" do
-    @user.expects(:refresh_from_github!)
-    @job.perform(@user)
+    test "#perform call #refresh_from_github! on the provided user" do
+      @user.expects(:refresh_from_github!)
+      @job.perform(@user)
+    end
   end
 end

data/test/jobs/refresh_status_job_test.rb

@@ -1,20 +1,22 @@
 require 'test_helper'
 
-class RefreshStatusesJobTest < ActiveSupport::TestCase
-  setup do
-    @stack = stacks(:shipit)
-    @job = RefreshStatusesJob.new
-  end
+module Shipit
+  class RefreshStatusesJobTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @job = RefreshStatusesJob.new
+    end
 
-  test "#perform call #refresh_statuses! on the last 30 commits of the stack" do
-    Commit.any_instance.expects(:refresh_statuses!).times(@stack.commits.count)
+    test "#perform call #refresh_statuses! on the last 30 commits of the stack" do
+      Commit.any_instance.expects(:refresh_statuses!).times(@stack.commits.count)
 
-    @job.perform(stack_id: @stack.id)
-  end
+      @job.perform(stack_id: @stack.id)
+    end
 
-  test "if :commit_id param is present only this commit is refreshed" do
-    Commit.any_instance.expects(:refresh_statuses!).once
+    test "if :commit_id param is present only this commit is refreshed" do
+      Commit.any_instance.expects(:refresh_statuses!).once
 
-    @job.perform(stack_id: @stack.id, commit_id: commits(:first).id)
+      @job.perform(stack_id: @stack.id, commit_id: shipit_commits(:first).id)
+    end
   end
 end

data/test/jobs/unique_job_test.rb

@@ -1,23 +1,26 @@
 require 'test_helper'
 
-class UniqueJobTest < ActiveSupport::TestCase
-  test "the lock key contains the job type" do
-    task = tasks(:shipit_restart)
-    job_a = ChunkRollupJob.new(task)
-    job_b = GithubSyncJob.new(task)
+module Shipit
+  class UniqueJobTest < ActiveSupport::TestCase
+    test "the lock key contains the job type" do
+      task = shipit_tasks(:shipit_restart)
+      job_a = ChunkRollupJob.new(task)
+      job_b = GithubSyncJob.new(task)
 
-    called = false
-    job_a.acquire_lock do
-      job_b.acquire_lock do
-        called = true
+      called = false
+      job_a.acquire_lock do
+        job_b.acquire_lock do
+          called = true
+        end
       end
+      assert called
     end
-    assert called
-  end
 
-  test "the lock key is serialized" do
-    task = tasks(:shipit_restart)
-    job = ChunkRollupJob.new(task)
-    assert_equal %(ChunkRollupJob-{"_aj_globalid"=>"gid://shipit/Task/#{task.id}"}), job.lock_key(*job.arguments)
+    test "the lock key is serialized" do
+      task = shipit_tasks(:shipit_restart)
+      job = ChunkRollupJob.new(task)
+      key = %(Shipit::ChunkRollupJob-{"_aj_globalid"=>"gid://shipit/Shipit::Task/#{task.id}"})
+      assert_equal key, job.lock_key(*job.arguments)
+    end
   end
 end

data/test/models/api_client_test.rb

@@ -1,27 +1,29 @@
 require 'test_helper'
 
-class ApiClientTest < ActiveSupport::TestCase
-  setup do
-    @client = api_clients(:spy)
-  end
+module Shipit
+  class ApiClientTest < ActiveSupport::TestCase
+    setup do
+      @client = shipit_api_clients(:spy)
+    end
 
-  test "#authentication_token is the signed id" do
-    assert_match(/^\d+--[\da-f]{40}$/, @client.authentication_token)
-  end
+    test "#authentication_token is the signed id" do
+      assert_match(/^\d+--[\da-f]{40}$/, @client.authentication_token)
+    end
 
-  test "#authentication_token casted as integer is the client id" do
-    assert_equal @client.id, @client.authentication_token.to_i
-  end
+    test "#authentication_token casted as integer is the client id" do
+      assert_equal @client.id, @client.authentication_token.to_i
+    end
 
-  test ".authenticate returns nil if the signature is invalid" do
-    assert_nil ApiClient.authenticate("#{@client.id}--foobar")
-  end
+    test ".authenticate returns nil if the signature is invalid" do
+      assert_nil ApiClient.authenticate("#{@client.id}--foobar")
+    end
 
-  test ".authenticate returns nil if the api client do not exists" do
-    assert_nil ApiClient.authenticate(ApiClient.new(id: 42).authentication_token)
-  end
+    test ".authenticate returns nil if the api client do not exists" do
+      assert_nil ApiClient.authenticate(ApiClient.new(id: 42).authentication_token)
+    end
 
-  test ".authenticate returns the matching ApiClient record if the token is valid" do
-    assert_equal @client, ApiClient.authenticate(@client.authentication_token)
+    test ".authenticate returns the matching ApiClient record if the token is valid" do
+      assert_equal @client, ApiClient.authenticate(@client.authentication_token)
+    end
   end
 end

data/test/models/commit_checks_test.rb

@@ -1,83 +1,85 @@
 require 'test_helper'
 require 'tmpdir'
 
-class CommitChecksTest < ActiveSupport::TestCase
-  setup do
-    @commit = commits(:fifth)
-    @checks = @commit.checks
-  end
+module Shipit
+  class CommitChecksTest < ActiveSupport::TestCase
+    setup do
+      @commit = shipit_commits(:fifth)
+      @checks = @commit.checks
+    end
 
-  test "#schedule schedule the checks if output is missing" do
-    assert_enqueued_with(job: PerformCommitChecksJob, args: [commit: @commit]) do
-      @checks.schedule
+    test "#schedule schedule the checks if output is missing" do
+      assert_enqueued_with(job: PerformCommitChecksJob, args: [commit: @commit]) do
+        @checks.schedule
+      end
     end
-  end
 
-  test "#schedule just returns the current output if present" do
-    schedule_checks
+    test "#schedule just returns the current output if present" do
+      schedule_checks
 
-    assert_no_enqueued_jobs do
-      @checks.schedule
+      assert_no_enqueued_jobs do
+        @checks.schedule
+      end
     end
-  end
 
-  test "it is considered finished if the status is `success`, `failed` or `error`" do
-    @checks.status = 'success'
-    assert @checks.finished?
+    test "it is considered finished if the status is `success`, `failed` or `error`" do
+      @checks.status = 'success'
+      assert @checks.finished?
 
-    @checks.status = 'failed'
-    assert @checks.finished?
+      @checks.status = 'failed'
+      assert @checks.finished?
 
-    @checks.status = 'error'
-    assert @checks.finished?
+      @checks.status = 'error'
+      assert @checks.finished?
 
-    @checks.status = 'scheduled'
-    refute @checks.finished?
+      @checks.status = 'scheduled'
+      refute @checks.finished?
 
-    @checks.status = 'running'
-    refute @checks.finished?
+      @checks.status = 'running'
+      refute @checks.finished?
 
-    @checks.status = nil
-    refute @checks.finished?
-  end
+      @checks.status = nil
+      refute @checks.finished?
+    end
 
-  test "#status is `scheduled` when the job is triggered" do
-    schedule_checks
-    assert_equal 'scheduled', @checks.status
-  end
+    test "#status is `scheduled` when the job is triggered" do
+      schedule_checks
+      assert_equal 'scheduled', @checks.status
+    end
 
-  test "#write append the string in redis" do
-    CommitChecks.new(@commit).write('foo')
-    CommitChecks.new(@commit).write('bar')
-    assert_equal 'foobar', CommitChecks.new(@commit).output
-  end
+    test "#write append the string in redis" do
+      CommitChecks.new(@commit).write('foo')
+      CommitChecks.new(@commit).write('bar')
+      assert_equal 'foobar', CommitChecks.new(@commit).output
+    end
 
-  test "#output allow to retreive only a slice of the output" do
-    @checks.write('foobar')
-    assert_equal 'bar', @checks.output(since: 3)
-  end
+    test "#output allow to retreive only a slice of the output" do
+      @checks.write('foobar')
+      assert_equal 'bar', @checks.output(since: 3)
+    end
 
-  test "#run execute the shell commands and update the status and output" do
-    StackCommands.any_instance.expects(:with_temporary_working_directory).yields(Pathname.new(Dir.tmpdir))
-    DeploySpec::FileSystem.any_instance.expects(:dependencies_steps).returns(['echo dependencies'])
-    DeploySpec::FileSystem.any_instance.expects(:review_checks).returns(['echo review'])
-
-    @checks.run
-    lines = [
-      '$ echo dependencies',
-      'dependencies',
-      '',
-      '$ echo review',
-      'review',
-      '',
-    ]
-    assert_equal 'success', @checks.status
-    assert_equal lines, @checks.output.lines.map(&:strip)
-  end
+    test "#run execute the shell commands and update the status and output" do
+      StackCommands.any_instance.expects(:with_temporary_working_directory).yields(Pathname.new(Dir.tmpdir))
+      DeploySpec::FileSystem.any_instance.expects(:dependencies_steps).returns(['echo dependencies'])
+      DeploySpec::FileSystem.any_instance.expects(:review_checks).returns(['echo review'])
+
+      @checks.run
+      lines = [
+        '$ echo dependencies',
+        'dependencies',
+        '',
+        '$ echo review',
+        'review',
+        '',
+      ]
+      assert_equal 'success', @checks.status
+      assert_equal lines, @checks.output.lines.map(&:strip)
+    end
 
-  private
+    private
 
-  def schedule_checks
-    CommitChecks.new(@commit).schedule
+    def schedule_checks
+      CommitChecks.new(@commit).schedule
+    end
   end
 end

data/test/models/commits_test.rb

@@ -1,398 +1,401 @@
 require 'test_helper'
 
-class CommitsTest < ActiveSupport::TestCase
-  setup do
-    @stack = stacks(:shipit)
-    @pr = @stack.commits.new
-    @pr.message = "Merge pull request #31 from Shopify/improve-polling\n\nSeveral improvements to polling"
-    @commit = commits(:first)
-  end
+module Shipit
+  class CommitsTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @pr = @stack.commits.new
+      @pr.message = "Merge pull request #31 from Shopify/improve-polling\n\nSeveral improvements to polling"
+      @commit = shipit_commits(:first)
+    end
 
-  test "#pull_request? detect pull request based on message format" do
-    assert @pr.pull_request?
-    refute @commit.pull_request?
-  end
+    test "#pull_request? detect pull request based on message format" do
+      assert @pr.pull_request?
+      refute @commit.pull_request?
+    end
 
-  test "#pull_request? detects pull requests with unusual branch names" do
-    @pr.message = "Merge pull request #7 from Shopify/bump-to-v1.0.1\n\nBump to v1.0.1"
-    assert @pr.pull_request?
-    assert_equal "Bump to v1.0.1", @pr.pull_request_title
-  end
+    test "#pull_request? detects pull requests with unusual branch names" do
+      @pr.message = "Merge pull request #7 from Shopify/bump-to-v1.0.1\n\nBump to v1.0.1"
+      assert @pr.pull_request?
+      assert_equal "Bump to v1.0.1", @pr.pull_request_title
+    end
 
-  test "#pull_request_id extract the pull request id from the message" do
-    assert_equal 31, @pr.pull_request_id
-    assert_nil @commit.pull_request_id
-  end
+    test "#pull_request_id extract the pull request id from the message" do
+      assert_equal 31, @pr.pull_request_id
+      assert_nil @commit.pull_request_id
+    end
 
-  test "#pull_request_title extract the pull request title from the message" do
-    assert_equal 'Several improvements to polling', @pr.pull_request_title
-    assert_nil @commit.pull_request_title
-  end
+    test "#pull_request_title extract the pull request title from the message" do
+      assert_equal 'Several improvements to polling', @pr.pull_request_title
+      assert_nil @commit.pull_request_title
+    end
 
-  test "#pull_request_url build the pull request url from the message" do
-    assert_equal 'https://github.com/shopify/shipit-engine/pull/31', @pr.pull_request_url
-    assert_nil @commit.pull_request_url
-  end
+    test "#pull_request_url build the pull request url from the message" do
+      assert_equal 'https://github.com/shopify/shipit-engine/pull/31', @pr.pull_request_url
+      assert_nil @commit.pull_request_url
+    end
 
-  test "#newer_than(nil) returns all commits" do
-    assert_equal @stack.commits.all.to_a, @stack.commits.newer_than(nil).to_a
-  end
+    test "#newer_than(nil) returns all commits" do
+      assert_equal @stack.commits.all.to_a, @stack.commits.newer_than(nil).to_a
+    end
 
-  test "updating to detached broadcasts an update event" do
-    expect_event(@stack)
-    @commit.update(detached: true)
-  end
+    test "updating to detached broadcasts an update event" do
+      expect_event(@stack)
+      @commit.update(detached: true)
+    end
 
-  test ".detach! detaches commits" do
-    parent = commits(:fourth)
-    child = commits(:fifth)
-    refute child.detached?, "fifth commit should not be detached"
+    test ".detach! detaches commits" do
+      parent = shipit_commits(:fourth)
+      child = shipit_commits(:fifth)
+      refute child.detached?, "fifth commit should not be detached"
 
-    parent.detach_children!
+      parent.detach_children!
 
-    assert child.reload.detached?, "children commits must be detached"
-  end
+      assert child.reload.detached?, "children commits must be detached"
+    end
 
-  test "#destroy broadcasts an update event" do
-    expect_event(@stack)
-    @commit.destroy
-  end
+    test "#destroy broadcasts an update event" do
+      expect_event(@stack)
+      @commit.destroy
+    end
 
-  test "updating broadcasts an update event" do
-    expect_event(@stack)
-    @commit.update_attributes(message: "toto")
-  end
+    test "updating broadcasts an update event" do
+      expect_event(@stack)
+      @commit.update_attributes(message: "toto")
+    end
 
-  test "updating state to success triggers new deploy when stack has continuous deployment" do
-    @stack.reload.update(continuous_deployment: true)
-    @stack.deploys.destroy_all
+    test "updating state to success triggers new deploy when stack has continuous deployment" do
+      @stack.reload.update(continuous_deployment: true)
+      @stack.deploys.destroy_all
 
-    assert_difference "Deploy.count" do
-      @stack.commits.last.statuses.create!(state: 'success', context: 'ci/travis')
+      assert_difference "Deploy.count" do
+        @stack.commits.last.statuses.create!(state: 'success', context: 'ci/travis')
+      end
     end
-  end
 
-  test "updating state to success skips deploy when stack has CD but a deploy is in progress" do
-    @stack.reload.update(continuous_deployment: true)
-    @stack.trigger_deploy(@commit, @commit.committer)
+    test "updating state to success skips deploy when stack has CD but a deploy is in progress" do
+      @stack.reload.update(continuous_deployment: true)
+      @stack.trigger_deploy(@commit, @commit.committer)
 
-    assert_no_difference "Deploy.count" do
-      @commit.statuses.create!(state: 'success', context: 'ci/travis')
+      assert_no_difference "Deploy.count" do
+        @commit.statuses.create!(state: 'success', context: 'ci/travis')
+      end
     end
-  end
 
-  test "updating state to success skips deploy when stack has CD but the stack is locked" do
-    @stack.deploys.destroy_all
-    @stack.reload.update!(continuous_deployment: true, lock_reason: "Maintenance ongoing")
+    test "updating state to success skips deploy when stack has CD but the stack is locked" do
+      @stack.deploys.destroy_all
+      @stack.reload.update!(continuous_deployment: true, lock_reason: "Maintenance ongoing")
 
-    assert_no_difference "Deploy.count" do
-      @commit.statuses.create!(state: 'success', context: 'ci/travis')
+      assert_no_difference "Deploy.count" do
+        @commit.statuses.create!(state: 'success', context: 'ci/travis')
+      end
     end
-  end
 
-  test "updating won't trigger a deploy if a newer commit has been deployed" do
-    @stack.reload.update(continuous_deployment: true)
-    @stack.deploys.destroy_all
-
-    walrus = users(:walrus)
-    new_commit = @stack.commits.create!(
-      sha: '1234',
-      message: 'bla',
-      author: walrus,
-      committer: walrus,
-      authored_at: Time.now,
-      committed_at: Time.now,
-    )
-
-    @stack.deploys.create!(
-      user_id: walrus.id,
-      since_commit: @stack.last_deployed_commit,
-      until_commit: new_commit,
-      status: 'success',
-    )
-
-    assert_no_difference "Deploy.count" do
-      @commit.statuses.create!(state: 'success')
+    test "updating won't trigger a deploy if a newer commit has been deployed" do
+      @stack.reload.update(continuous_deployment: true)
+      @stack.deploys.destroy_all
+
+      walrus = shipit_users(:walrus)
+      new_commit = @stack.commits.create!(
+        sha: '1234',
+        message: 'bla',
+        author: walrus,
+        committer: walrus,
+        authored_at: Time.now,
+        committed_at: Time.now,
+      )
+
+      @stack.deploys.create!(
+        user_id: walrus.id,
+        since_commit: @stack.last_deployed_commit,
+        until_commit: new_commit,
+        status: 'success',
+      )
+
+      assert_no_difference "Deploy.count" do
+        @commit.statuses.create!(state: 'success')
+      end
     end
-  end
 
-  test "updating won't trigger a deploy if this commit has already been deployed" do
-    @stack.reload.update!(continuous_deployment: true)
+    test "updating won't trigger a deploy if this commit has already been deployed" do
+      @stack.reload.update!(continuous_deployment: true)
 
-    assert_no_difference "Deploy.count" do
-      @stack.last_deployed_commit.statuses.create!(state: 'success')
+      assert_no_difference "Deploy.count" do
+        @stack.last_deployed_commit.statuses.create!(state: 'success')
+      end
     end
-  end
 
-  test "updating without CD skips deploy regardless of state" do
-    @stack.reload.deploys.destroy_all
+    test "updating without CD skips deploy regardless of state" do
+      @stack.reload.deploys.destroy_all
 
-    assert_no_difference "Deploy.count" do
-      @commit.statuses.create!(state: 'success')
+      assert_no_difference "Deploy.count" do
+        @commit.statuses.create!(state: 'success')
+      end
     end
-  end
 
-  test "updating when not success does not schedule CD" do
-    @stack.reload.update(continuous_deployment: true)
-    @stack.deploys.destroy_all
+    test "updating when not success does not schedule CD" do
+      @stack.reload.update(continuous_deployment: true)
+      @stack.deploys.destroy_all
 
-    assert_no_difference "Deploy.count" do
-      @commit.statuses.create!(state: 'failure')
+      assert_no_difference "Deploy.count" do
+        @commit.statuses.create!(state: 'failure')
+      end
     end
-  end
-
-  test "creating broadcasts an update event" do
-    expect_event(@stack)
-    walrus = users(:walrus)
-    @stack.commits.create(author: walrus,
-                          committer: walrus,
-                          sha: "ab12",
-                          authored_at: DateTime.now,
-                          committed_at: DateTime.now,
-                          message: "more fish!")
-  end
 
-  test "refresh_statuses! pull state from github" do
-    rels = {target: mock(href: 'http://example.com')}
-    status = mock(state: 'success', description: nil, context: 'default', rels: rels, created_at: 1.day.ago)
-    Shipit.github_api.expects(:statuses).with(@stack.github_repo_name, @commit.sha).returns([status])
-    assert_difference '@commit.statuses.count', 1 do
-      @commit.refresh_statuses!
+    test "creating broadcasts an update event" do
+      expect_event(@stack)
+      walrus = shipit_users(:walrus)
+      @stack.commits.create(author: walrus,
+                            committer: walrus,
+                            sha: "ab12",
+                            authored_at: DateTime.now,
+                            committed_at: DateTime.now,
+                            message: "more fish!")
     end
-    assert_equal 'success', @commit.statuses.first.state
-  end
 
-  test "#creating a commit update the undeployed_commits_count" do
-    walrus = users(:walrus)
-    assert_equal 1, @stack.undeployed_commits_count
-    @stack.commits.create(author: walrus,
-                          committer: walrus,
-                          sha: "ab12",
-                          authored_at: DateTime.now,
-                          committed_at: DateTime.now,
-                          message: "more fish!")
-
-    @stack.reload
-    assert_equal 2, @stack.undeployed_commits_count
-  end
+    test "refresh_statuses! pull state from github" do
+      rels = {target: mock(href: 'http://example.com')}
+      status = mock(state: 'success', description: nil, context: 'default', rels: rels, created_at: 1.day.ago)
+      Shipit.github_api.expects(:statuses).with(@stack.github_repo_name, @commit.sha).returns([status])
+      assert_difference '@commit.statuses.count', 1 do
+        @commit.refresh_statuses!
+      end
+      assert_equal 'success', @commit.statuses.first.state
+    end
 
-  test "fetch_stats! pulls additions and deletions from github" do
-    commit = stub(stats: stub(additions: 4242, deletions: 2424))
-    Shipit.github_api.expects(:commit).with(@stack.github_repo_name, @commit.sha).returns(commit)
-    @commit.fetch_stats!
-    assert_equal 4242, @commit.additions
-    assert_equal 2424, @commit.deletions
-  end
+    test "#creating a commit update the undeployed_commits_count" do
+      walrus = shipit_users(:walrus)
+      assert_equal 1, @stack.undeployed_commits_count
+      @stack.commits.create(author: walrus,
+                            committer: walrus,
+                            sha: "ab12",
+                            authored_at: DateTime.now,
+                            committed_at: DateTime.now,
+                            message: "more fish!")
+
+      @stack.reload
+      assert_equal 2, @stack.undeployed_commits_count
+    end
 
-  test "fetch_stats! doesn't fail if the commits have no stats" do
-    commit = stub(stats: nil)
-    Shipit.github_api.expects(:commit).with(@stack.github_repo_name, @commit.sha).returns(commit)
-    assert_nothing_raised do
+    test "fetch_stats! pulls additions and deletions from github" do
+      commit = stub(stats: stub(additions: 4242, deletions: 2424))
+      Shipit.github_api.expects(:commit).with(@stack.github_repo_name, @commit.sha).returns(commit)
       @commit.fetch_stats!
+      assert_equal 4242, @commit.additions
+      assert_equal 2424, @commit.deletions
     end
-  end
 
-  test ".by_sha! can match sha prefixes" do
-    assert_equal @commit, Commit.by_sha!(@commit.sha[0..7])
-  end
+    test "fetch_stats! doesn't fail if the commits have no stats" do
+      commit = stub(stats: nil)
+      Shipit.github_api.expects(:commit).with(@stack.github_repo_name, @commit.sha).returns(commit)
+      assert_nothing_raised do
+        @commit.fetch_stats!
+      end
+    end
 
-  test ".by_sha! raises on ambigous sha prefixes" do
-    assert_raises Commit::AmbiguousRevision do
-      Commit.by_sha!(@commit.sha[0..3])
+    test ".by_sha! can match sha prefixes" do
+      assert_equal @commit, Commit.by_sha!(@commit.sha[0..7])
     end
-  end
 
-  test ".by_sha! raises if the sha prefix matches multiple commits" do
-    clone = Commit.new(@commit.attributes.except('id'))
-    clone.sha[8..-1] = 'abc12'
-    clone.save!
+    test ".by_sha! raises on ambigous sha prefixes" do
+      assert_raises Commit::AmbiguousRevision do
+        Commit.by_sha!(@commit.sha[0..3])
+      end
+    end
+
+    test ".by_sha! raises if the sha prefix matches multiple commits" do
+      clone = Commit.new(@commit.attributes.except('id'))
+      clone.sha[8..-1] = 'abc12'
+      clone.save!
 
-    assert_raises Commit::AmbiguousRevision do
-      Commit.by_sha!(@commit.sha[0..7])
+      assert_raises Commit::AmbiguousRevision do
+        Commit.by_sha!(@commit.sha[0..7])
+      end
     end
-  end
 
-  test "#state is `unknown` by default" do
-    assert_equal 'unknown', @stack.commits.new.state
-  end
+    test "#state is `unknown` by default" do
+      assert_equal 'unknown', @stack.commits.new.state
+    end
 
-  test "#state is `success` if all most recent the statuses are `success`" do
-    assert_equal 'success', commits(:third).state
-  end
+    test "#state is `success` if all most recent the statuses are `success`" do
+      assert_equal 'success', shipit_commits(:third).state
+    end
 
-  test "#state is `failure` one of the most recent the statuses is `failure`" do
-    assert_equal 'failure', commits(:second).state
-  end
+    test "#state is `failure` one of the most recent the statuses is `failure`" do
+      assert_equal 'failure', shipit_commits(:second).state
+    end
 
-  test "#state is `pending` one of the most recent the statuses is `pending` and none is `failure` or `error`" do
-    assert_equal 'pending', commits(:fourth).state
-  end
+    test "#state is `pending` one of the most recent the statuses is `pending` and none is `failure` or `error`" do
+      assert_equal 'pending', shipit_commits(:fourth).state
+    end
 
-  test "#state doesn't consider statuses that are hidden or allowed to fail" do
-    assert_equal 'pending', @commit.state
+    test "#state doesn't consider statuses that are hidden or allowed to fail" do
+      assert_equal 'pending', @commit.state
 
-    @commit.statuses.create!(context: 'metrics/coveralls', state: 'failure')
-    @commit.statuses.create!(context: 'metrics/performance', state: 'failure')
-    assert_equal 'failure', @commit.reload.state
+      @commit.statuses.create!(context: 'metrics/coveralls', state: 'failure')
+      @commit.statuses.create!(context: 'metrics/performance', state: 'failure')
+      assert_equal 'failure', @commit.reload.state
 
-    @commit.stack.update!(cached_deploy_spec: DeploySpec.new('ci' => {
-      'hide' => 'metrics/coveralls',
-      'allow_failures' => 'metrics/performance',
-    }))
-    assert_equal 'pending', @commit.reload.state
-  end
+      @commit.stack.update!(cached_deploy_spec: DeploySpec.new('ci' => {
+        'hide' => 'metrics/coveralls',
+        'allow_failures' => 'metrics/performance',
+      }))
+      assert_equal 'pending', @commit.reload.state
+    end
 
-  test "#last_statuses returns the list of the most recent status of each context" do
-    assert_equal 4, commits(:second).statuses.count
-    assert_equal 2, commits(:second).last_statuses.count
-  end
+    test "#last_statuses returns the list of the most recent status of each context" do
+      assert_equal 4, shipit_commits(:second).statuses.count
+      assert_equal 2, shipit_commits(:second).last_statuses.count
+    end
 
-  test "#last_statuses return [UnknownStatus] if the commit has no statuses" do
-    commit = commits(:second)
-    commit.statuses = []
-    assert_equal UnknownStatus.new(commit), commit.significant_status
-  end
+    test "#last_statuses return [UnknownStatus] if the commit has no statuses" do
+      commit = shipit_commits(:second)
+      commit.statuses = []
+      assert_equal UnknownStatus.new(commit), commit.significant_status
+    end
 
-  test "#visible_statuses rejects the statuses that are specified in the deploy spec's `ci.hide`" do
-    commit = commits(:second)
-    assert_equal 2, commit.visible_statuses.count
-    commit.stack.update!(cached_deploy_spec: DeploySpec.new('ci' => {'hide' => 'metrics/coveralls'}))
-    commit.reload
-    assert_equal 1, commit.visible_statuses.size
-  end
+    test "#visible_statuses rejects the statuses that are specified in the deploy spec's `ci.hide`" do
+      commit = shipit_commits(:second)
+      assert_equal 2, commit.visible_statuses.count
+      commit.stack.update!(cached_deploy_spec: DeploySpec.new('ci' => {'hide' => 'metrics/coveralls'}))
+      commit.reload
+      assert_equal 1, commit.visible_statuses.size
+    end
 
-  test "#deployable? is true if commit status is 'success'" do
-    assert_predicate commits(:cyclimse_first), :deployable?
-  end
+    test "#deployable? is true if commit status is 'success'" do
+      assert_predicate shipit_commits(:cyclimse_first), :deployable?
+    end
 
-  test "#deployable? is true if stack is set to 'ignore_ci'" do
-    commit = commits(:first)
-    commit.stack.update!(ignore_ci: true)
-    assert_predicate commit, :deployable?
-  end
+    test "#deployable? is true if stack is set to 'ignore_ci'" do
+      commit = shipit_commits(:first)
+      commit.stack.update!(ignore_ci: true)
+      assert_predicate commit, :deployable?
+    end
 
-  test "#deployable? is false if commit has no statuses" do
-    refute_predicate commits(:fifth), :deployable?
-  end
+    test "#deployable? is false if commit has no statuses" do
+      refute_predicate shipit_commits(:fifth), :deployable?
+    end
 
-  test "#deployable? is false if a required status is missing" do
-    commit = commits(:cyclimse_first)
-    commit.stack.stubs(:required_statuses).returns(%w(ci/very-important))
-    refute_predicate commit, :deployable?
-  end
+    test "#deployable? is false if a required status is missing" do
+      commit = shipit_commits(:cyclimse_first)
+      commit.stack.stubs(:required_statuses).returns(%w(ci/very-important))
+      refute_predicate commit, :deployable?
+    end
 
-  expected_webhook_transitions = { # we expect deployable_status to fire on these transitions, and not on any others
-    'pending' => %w(success failure error),
-    'success' => %w(failure error),
-    'failure' => %w(success),
-    'error' => %w(success),
-  }
-  expected_webhook_transitions.each do |initial_state, firing_states|
-    initial_status_attributes = {state: initial_state, description: 'abc', context: 'ci/travis'}
-    expected_webhook_transitions.keys.each do |new_state|
-      should_fire = firing_states.include?(new_state)
-      test "#add_status #{should_fire ? 'fires' : 'does not fire'} for status from #{initial_state} to #{new_state}" do
-        commit = commits(:cyclimse_first)
-        assert commit.stack.hooks.where(events: ['deploy_status']).size >= 1
-        refute commit.stack.ignore_ci
-        commit.statuses.destroy_all
-        commit.reload
-        commit.statuses.create!(initial_status_attributes.merge(created_at: 10.days.ago.to_s(:db)))
-        assert_equal initial_state, commit.state
-
-        expected_status_attributes = {state: new_state, description: initial_state, context: 'ci/travis'}
-        if should_fire
-          expect_hook_emit(commit, :deployable_status, expected_status_attributes)
-        else
-          Hook.expects(:emit).never
+    expected_webhook_transitions = { # we expect deployable_status to fire on these transitions, and not on any others
+      'pending' => %w(success failure error),
+      'success' => %w(failure error),
+      'failure' => %w(success),
+      'error' => %w(success),
+    }
+    expected_webhook_transitions.each do |initial_state, firing_states|
+      initial_status_attributes = {state: initial_state, description: 'abc', context: 'ci/travis'}
+      expected_webhook_transitions.keys.each do |new_state|
+        should_fire = firing_states.include?(new_state)
+        action = should_fire ? 'fires' : 'does not fire'
+        test "#add_status #{action} for status from #{initial_state} to #{new_state}" do
+          commit = shipit_commits(:cyclimse_first)
+          assert commit.stack.hooks.where(events: ['deploy_status']).size >= 1
+          refute commit.stack.ignore_ci
+          commit.statuses.destroy_all
+          commit.reload
+          commit.statuses.create!(initial_status_attributes.merge(created_at: 10.days.ago.to_s(:db)))
+          assert_equal initial_state, commit.state
+
+          expected_status_attributes = {state: new_state, description: initial_state, context: 'ci/travis'}
+          if should_fire
+            expect_hook_emit(commit, :deployable_status, expected_status_attributes)
+          else
+            Hook.expects(:emit).never
+          end
+          expect_hook_emit(commit, :commit_status, expected_status_attributes)
+
+          commit.add_status(expected_status_attributes.merge(created_at: 1.day.ago.to_s(:db)))
         end
-        expect_hook_emit(commit, :commit_status, expected_status_attributes)
-
-        commit.add_status(expected_status_attributes.merge(created_at: 1.day.ago.to_s(:db)))
       end
     end
-  end
 
-  test "#add_status does not fire webhooks for invisible statuses" do
-    commit = commits(:second)
-    assert commit.stack.hooks.where(events: ['commit_status']).size >= 1
-    Hook.expects(:emit).never
-    commit.add_status(state: 'failure', description: 'Sad', context: 'ci/hidden', created_at: 1.day.ago.to_s(:db))
-  end
+    test "#add_status does not fire webhooks for invisible statuses" do
+      commit = shipit_commits(:second)
+      assert commit.stack.hooks.where(events: ['commit_status']).size >= 1
+      Hook.expects(:emit).never
+      commit.add_status(state: 'failure', description: 'Sad', context: 'ci/hidden', created_at: 1.day.ago.to_s(:db))
+    end
 
-  test "#add_status does not fire webhooks for non-meaningful statuses" do
-    commit = commits(:second)
-    assert commit.stack.hooks.where(events: ['commit_status']).size >= 1
-    Hook.expects(:emit).never
-    commit.add_status(state: 'failure', description: 'Sad', context: 'ci/ok_to_fail', created_at: 1.day.ago.to_s(:db))
-  end
+    test "#add_status does not fire webhooks for non-meaningful statuses" do
+      commit = shipit_commits(:second)
+      assert commit.stack.hooks.where(events: ['commit_status']).size >= 1
+      Hook.expects(:emit).never
+      commit.add_status(state: 'failure', description: 'Sad', context: 'ci/ok_to_fail', created_at: 1.day.ago.to_s(:db))
+    end
 
-  test "#visible_statuses forward the last_statuses to the stack" do
-    commit = commits(:second)
-    stack = commit.stack
-    stack.expects(:filter_visible_statuses).with(commit.last_statuses)
-    commit.visible_statuses
-  end
+    test "#visible_statuses forward the last_statuses to the stack" do
+      commit = shipit_commits(:second)
+      stack = commit.stack
+      stack.expects(:filter_visible_statuses).with(commit.last_statuses)
+      commit.visible_statuses
+    end
 
-  test "#meaningful_statuses forward the last_statuses to the stack" do
-    commit = commits(:second)
-    stack = commit.stack
-    stack.expects(:filter_meaningful_statuses).with(commit.last_statuses)
-    commit.meaningful_statuses
-  end
+    test "#meaningful_statuses forward the last_statuses to the stack" do
+      commit = shipit_commits(:second)
+      stack = commit.stack
+      stack.expects(:filter_meaningful_statuses).with(commit.last_statuses)
+      commit.meaningful_statuses
+    end
 
-  test "#significant_status is UnknownStatus when the commit has no statuses" do
-    commit = commits(:first)
-    commit.statuses = []
-    assert_equal UnknownStatus.new(commit), commit.significant_status
-  end
+    test "#significant_status is UnknownStatus when the commit has no statuses" do
+      commit = shipit_commits(:first)
+      commit.statuses = []
+      assert_equal UnknownStatus.new(commit), commit.significant_status
+    end
 
-  test "#significant_status hierarchy uses failures and errors, then pending, then successes, then UnknownStatus" do
-    commit = commits(:first)
-    pending = commit.statuses.new(state: 'pending', context: 'ci/pending')
-    failure = commit.statuses.new(state: 'failure', context: 'ci/failure')
-    error = commit.statuses.new(state: 'error', context: 'ci/error')
-    success = commit.statuses.new(state: 'success', context: 'ci/success')
+    test "#significant_status hierarchy uses failures and errors, then pending, then successes, then UnknownStatus" do
+      commit = shipit_commits(:first)
+      pending = commit.statuses.new(state: 'pending', context: 'ci/pending')
+      failure = commit.statuses.new(state: 'failure', context: 'ci/failure')
+      error = commit.statuses.new(state: 'error', context: 'ci/error')
+      success = commit.statuses.new(state: 'success', context: 'ci/success')
 
-    commit.reload.statuses = [pending, failure, success, error]
-    assert_includes [error, failure], commit.significant_status
+      commit.reload.statuses = [pending, failure, success, error]
+      assert_includes [error, failure], commit.significant_status
 
-    commit.reload.statuses = [pending, failure, success]
-    assert_equal failure, commit.significant_status
+      commit.reload.statuses = [pending, failure, success]
+      assert_equal failure, commit.significant_status
 
-    commit.reload.statuses = [pending, error, success]
-    assert_equal error, commit.significant_status
+      commit.reload.statuses = [pending, error, success]
+      assert_equal error, commit.significant_status
 
-    commit.reload.statuses = [success, pending]
-    assert_equal pending, commit.significant_status
+      commit.reload.statuses = [success, pending]
+      assert_equal pending, commit.significant_status
 
-    commit.reload.statuses = [success]
-    assert_equal success, commit.significant_status
+      commit.reload.statuses = [success]
+      assert_equal success, commit.significant_status
 
-    commit.reload.statuses = []
-    assert_equal UnknownStatus.new(commit), commit.significant_status
-  end
+      commit.reload.statuses = []
+      assert_equal UnknownStatus.new(commit), commit.significant_status
+    end
 
-  test "#significant_status is UnknownStatus when the commit has statuses but none meaningful" do
-    commit = commits(:first)
-    commit.stubs(meaningful_statuses: [])
-    assert_equal UnknownStatus.new(commit), commit.significant_status
-  end
+    test "#significant_status is UnknownStatus when the commit has statuses but none meaningful" do
+      commit = shipit_commits(:first)
+      commit.stubs(meaningful_statuses: [])
+      assert_equal UnknownStatus.new(commit), commit.significant_status
+    end
 
-  private
+    private
 
-  def expect_event(stack)
-    Pubsubstub::RedisPubSub.expects(:publish).at_least_once
-    Pubsubstub::RedisPubSub.expects(:publish).with do |channel, event|
-      data = JSON.load(event.data)
-      channel == "stack.#{stack.id}" && data['url'] == "/#{stack.to_param}"
+    def expect_event(stack)
+      Pubsubstub::RedisPubSub.expects(:publish).at_least_once
+      Pubsubstub::RedisPubSub.expects(:publish).with do |channel, event|
+        data = JSON.load(event.data)
+        channel == "stack.#{stack.id}" && data['url'] == "/#{stack.to_param}"
+      end
     end
-  end
 
-  def expect_hook_emit(commit, event, status_attributes)
-    matchers = status_attributes.to_a.map { |pair| responds_with(pair.first, pair.second) }
-    Hook.expects(:emit).with(event, commit.stack, has_entries(commit: commit, stack: commit.stack,
-                                                              event => all_of(*matchers),
-                                                              status: status_attributes[:state]))
+    def expect_hook_emit(commit, event, status_attributes)
+      matchers = status_attributes.to_a.map { |pair| responds_with(pair.first, pair.second) }
+      Hook.expects(:emit).with(event, commit.stack, has_entries(commit: commit, stack: commit.stack,
+                                                                event => all_of(*matchers),
+                                                                status: status_attributes[:state]))
+    end
   end
 end