shipit-engine 0.20.0 → 0.21.0

data/test/models/deploy_spec_test.rb

@@ -284,11 +284,16 @@ module Shipit
           'require' => [],
           'ignore' => [],
           'revalidate_after' => nil,
+          'max_divergence' => {
+            'commits' => nil,
+            'age' => nil,
+          },
         },
         'ci' => {
           'hide' => [],
           'allow_failures' => [],
           'require' => [],
+          'blocking' => [],
         },
         'machine' => {'environment' => {}, 'directory' => nil, 'cleanup' => true},
         'review' => {'checklist' => [], 'monitoring' => [], 'checks' => []},
@@ -318,59 +323,19 @@ module Shipit
       assert_equal 'SAFETY_DISABLED', variable_definition.name
     end
 
-    test "task definitions prepend bundle exec by default" do
-      @spec.expects(:load_config).returns('tasks' => {'restart' => {'steps' => %w(foo)}})
-      @spec.expects(:bundler?).returns(true).at_least_once
-      assert_deprecated(/Automatically prepending `bundle exec`/) do
-        definition = @spec.find_task_definition('restart')
-        assert_equal ['bundle exec foo'], definition.steps
-      end
-    end
-
-    test "task definitions prepend bundle exec if enabled" do
-      Shipit.expects(:automatically_prepend_bundle_exec).returns(true).at_least_once
+    test "task definitions don't prepend bundle exec by default" do
       @spec.expects(:load_config).returns('tasks' => {'restart' => {'steps' => %w(foo)}})
-      @spec.expects(:bundler?).returns(true).at_least_once
       definition = @spec.find_task_definition('restart')
-
-      assert_equal ['bundle exec foo'], definition.steps
-    end
-
-    test "task definitions do not prepend bundle exec if disabled" do
-      Shipit.expects(:automatically_prepend_bundle_exec).returns(false).at_least_once
-      @spec.expects(:load_config).returns('tasks' => {'restart' => {'steps' => %w(foo)}})
-      definition = @spec.find_task_definition('restart')
-
       assert_equal ['foo'], definition.steps
     end
 
-    test "task definitions do not prepend bundle exec if the task already does" do
-      Shipit.expects(:automatically_prepend_bundle_exec).returns(true).at_least_once
-      @spec.expects(:load_config).returns('tasks' => {'restart' => {'steps' => ['bundle exec foo']}})
-      @spec.stubs(:bundler?).returns(true)
-      definition = @spec.find_task_definition('restart')
-
-      assert_equal ['bundle exec foo'], definition.steps
-    end
-
-    test "task definitions do not prepend bundle exec if depedency step is overridden" do
-      @spec.expects(:load_config).returns(
-        'dependencies' => {'override' => []},
-        'tasks' => {'restart' => {'steps' => %w(foo)}},
-      )
-      @spec.expects(:bundler?).returns(true).at_least_once
-      definition = @spec.find_task_definition('restart')
-
-      assert_equal ['foo'], definition.steps
-    end
-
-    test "task definitions prepend bundle exec before serialization" do
+    test "task definitions don't bundle exec before serialization" do
       @spec.expects(:discover_task_definitions).returns('restart' => {'steps' => %w(foo)})
       @spec.expects(:bundler?).returns(true).at_least_once
 
       cached_spec = DeploySpec.load(DeploySpec.dump(@spec))
       definition = cached_spec.find_task_definition('restart')
-      assert_equal ['bundle exec foo'], definition.steps
+      assert_equal ['foo'], definition.steps
     end
 
     test "#task_definitions returns kubernetes commands as well as comands from the config" do
@@ -455,6 +420,16 @@ module Shipit
       assert_equal %w(ci/circleci ci/jenkins), @spec.hidden_statuses
     end
 
+    test "#required_statuses automatically includes #blocking_statuses" do
+      @spec.expects(:load_config).returns(
+        'ci' => {
+          'require' => %w(ci/circleci),
+          'blocking' => %w(soc/compliance),
+        },
+      )
+      assert_equal %w(ci/circleci soc/compliance), @spec.required_statuses
+    end
+
     test "pull_request_ignored_statuses defaults to the union of ci.hide and ci.allow_failures" do
       @spec.expects(:load_config).returns(
         'ci' => {
@@ -573,26 +548,43 @@ module Shipit
       assert_equal ['fake gem task'], @spec.deploy_steps
     end
 
+    test 'lerna monorepos take priority over solo npm deploys' do
+      @spec.expects(:discover_npm_package).never
+      @spec.stubs(:discover_lerna_packages).returns(['fake monorepo task']).once
+
+      assert_equal ['fake monorepo task'], @spec.deploy_steps
+    end
+
+    test '#lerna? is false if there is no lerna.json' do
+      @spec.expects(:lerna_json).returns(Shipit::Engine.root.join("tmp-#{SecureRandom.hex}"))
+      refute @spec.lerna?
+    end
+
     test '#npm? is false if there is no package.json' do
       @spec.expects(:package_json).returns(Shipit::Engine.root.join("tmp-#{SecureRandom.hex}"))
       refute @spec.npm?
     end
 
-    test '#npm? is false if npm package is private' do
+    test '#npm? is true if npm package is public' do
       file = Pathname.new('/tmp/fake_package.json')
-      file.write('{"private": true}')
+      file.write('{"private": false}')
 
       @spec.expects(:package_json).returns(file)
-      refute @spec.npm?
+
+      assert @spec.npm?
     end
 
-    test '#npm? is true if npm package is public' do
+    test '#npm? is false if npm package is private' do
       file = Pathname.new('/tmp/fake_package.json')
-      file.write('{"private": false}')
+      file.write('{"private": true}')
 
       @spec.expects(:package_json).returns(file)
+      refute @spec.npm?
+    end
 
-      assert @spec.npm?
+    test 'lerna monorepos have a checklist' do
+      @spec.stubs(:lerna?).returns(true).at_least_once
+      assert_match(/lerna publish --skip-npm/, @spec.review_checklist[0])
     end
 
     test 'npm packages have a checklist' do
@@ -600,14 +592,223 @@ module Shipit
       assert_match(/npm version/, @spec.review_checklist[0])
     end
 
+    test '#lerna_version returns the monorepo root version number' do
+      file = Pathname.new('/tmp/fake_lerna.json')
+      file.write('{"version": "1.0.0-beta.1"}')
+
+      @spec.expects(:lerna_json).returns(file)
+      assert_equal '1.0.0-beta.1', @spec.lerna_version
+    end
+
+    test '#package_version returns the version number' do
+      file = Pathname.new('/tmp/fake_package.json')
+      file.write('{"version": "1.0.0-beta.1"}')
+
+      @spec.expects(:package_json).returns(file)
+      assert_equal '1.0.0-beta.1', @spec.package_version
+    end
+
+    test '#dist_tag returns "latest" if the version does not contains a standard pre-release tag' do
+      assert_equal 'latest', @spec.dist_tag('1.0.0')
+      assert_equal 'latest', @spec.dist_tag('1.0.0-shopifyv4')
+    end
+
+    test '#dist_tag returns "next" if the version contains a pre-release tag' do
+      assert_equal 'next', @spec.dist_tag('1.0.0-alpha.1')
+      assert_equal 'next', @spec.dist_tag('1.0.0-beta')
+      assert_equal 'next', @spec.dist_tag('1.0.0-rc.3')
+      assert_equal 'next', @spec.dist_tag('1.0.0-next')
+    end
+
+    test '#dependencies_steps returns lerna setup if a `lerna.json` is present' do
+      @spec.expects(:lerna?).returns(true).at_least_once
+      assert_equal ['npm install --no-progress', 'node_modules/.bin/lerna bootstrap'], @spec.dependencies_steps
+    end
+
     test '#dependencies_steps returns `npm install` if a `package.json` is present' do
       @spec.expects(:npm?).returns(true).at_least_once
       assert_equal ['npm install --no-progress'], @spec.dependencies_steps
     end
 
+    test '#publish_lerna_packages checks if independent version tags exist, and then invokes lerna deploy script' do
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_version).returns('independent')
+      assert_equal 'assert-lerna-independent-version-tags', @spec.deploy_steps[0]
+      assert_equal 'publish-lerna-independent-packages', @spec.deploy_steps[1]
+    end
+
+    test '#publish_lerna_packages checks if fixed version tag exists, and then invokes lerna deploy script' do
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_version).returns('1.0.0')
+      assert_equal 'assert-lerna-fixed-version-tag', @spec.deploy_steps[0]
+      assert_equal 'node_modules/.bin/lerna publish --yes --skip-git --repo-version 1.0.0 --force-publish=* --npm-tag latest', @spec.deploy_steps[1]
+    end
+
+    test '#enforce_publish_config? is false when Shipit.enforce_publish_config is nil' do
+      Shipit.stubs(:enforce_publish_config).returns(nil)
+      refute @spec.enforce_publish_config?
+    end
+
+    test '#enforce_publish_config? is false when Shipit.enforce_publish_config is 0' do
+      Shipit.stubs(:enforce_publish_config).returns('0')
+      refute @spec.enforce_publish_config?
+    end
+
+    test '#enforce_publish_config? is true when Shipit.enforce_publish_config is 1' do
+      Shipit.stubs(:enforce_publish_config).returns('1')
+      assert @spec.enforce_publish_config?
+    end
+
+    test '#valid_publish_config? is false when enforce_publish_config? is true and publishConfig is missing from package.json' do
+      Shipit.stubs(:private_npm_registry).returns('some_private_registry')
+      @spec.stubs(:enforce_publish_config?).returns(true)
+      @spec.stubs(:publish_config_access).returns('restricted')
+
+      package_json = Pathname.new('/tmp/fake_package.json')
+      package_json.write('{"name": "foo"}')
+
+      @spec.expects(:package_json).returns(package_json)
+      refute @spec.valid_publish_config?
+    end
+
+    test '#valid_publish_config? is true when enforce_publish_config? is true and publishConfig.access is public' do
+      Shipit.stubs(:private_npm_registry).returns('some_private_registry')
+      @spec.stubs(:enforce_publish_config?).returns(true)
+      @spec.stubs(:publish_config_access).returns('public')
+      @spec.stubs(:publish_config).returns('something')
+
+      assert @spec.valid_publish_config?
+    end
+
+    test '#valid_publish_config? is true when shipit does not enforce a publishConfig' do
+      @spec.stubs(:lerna_version).returns('1.0.0')
+      assert @spec.valid_publish_config?
+    end
+
+    test '#publish_config returns publishConfig from package.json' do
+      package_json = Pathname.new('/tmp/fake_package.json')
+      package_json.write('{"publishConfig": "foo"}')
+
+      @spec.expects(:package_json).returns(package_json)
+      assert_equal "foo", @spec.publish_config
+    end
+
+    test '#valid_publish_config_access? is false when publishConfig.access is invalid' do
+      @spec.stubs(:publish_config_access).returns('foo')
+      refute @spec.valid_publish_config_access?
+    end
+
+    test '#valid_publish_config_access? is true when publishConfig.access is public or restricted' do
+      @spec.stubs(:publish_config_access).returns('public')
+      assert @spec.valid_publish_config_access?
+
+      @spec.stubs(:publish_config_access).returns('restricted')
+      assert @spec.valid_publish_config_access?
+    end
+
+    test '#publish_config_access is restricted when enforce_publish_config? is true and publishConfig is missing' do
+      package_json = Pathname.new('/tmp/fake_package.json')
+      package_json.write('{"name": "@shopify/foo"}')
+
+      @spec.stubs(:enforce_publish_config?).returns(true)
+      @spec.expects(:package_json).returns(package_json)
+      assert_equal 'restricted', @spec.publish_config_access
+    end
+
+    test '#publish_config_access is public when enforce_publish_config? is false and publishConfig is missing' do
+      package_json = Pathname.new('/tmp/fake_package.json')
+      package_json.write('{"name": "@shopify/foo"}')
+
+      @spec.stubs(:enforce_publish_config?).returns(false)
+      @spec.expects(:package_json).returns(package_json)
+      assert_equal 'public', @spec.publish_config_access
+    end
+
+    test '#publish_config_access returns publishConfig.access from package.json when enforce_publish_config? is true' do
+      package_json = Pathname.new('/tmp/fake_package.json')
+      package_json.write('{
+        "name": "@shopify/foo",
+        "publishConfig": {
+          "access": "foo"
+        }
+      }')
+
+      @spec.stubs(:enforce_publish_config?).returns(false)
+      @spec.expects(:package_json).returns(package_json)
+      assert_equal 'foo', @spec.publish_config_access
+    end
+
+    test "#scoped_package? is false when Shipit.npm_org_scope is not set and the package is private" do
+      Shipit.stubs(:npm_org_scope).returns(nil)
+      @spec.stubs(:publish_config_access).returns('restricted')
+      refute @spec.scoped_package?
+    end
+
+    test "#scoped_package? is true when Shipit.npm_org_scope is set and package_name starts with scope and the package is private" do
+      Shipit.stubs(:npm_org_scope).returns('@shopify')
+      @spec.stubs(:publish_config_access).returns('restricted')
+      @spec.stubs(:package_name).returns('@shopify/polaris')
+      assert @spec.scoped_package?
+    end
+
+    test "#private_scoped_package? is false when private packages are not scoped" do
+      @spec.stubs(:scoped_package?).returns(false)
+      @spec.stubs(:publish_config_access).returns("restricted")
+      refute @spec.private_scoped_package?
+    end
+
+    test "#private_scoped_package? is true when private packages are scoped" do
+      @spec.stubs(:scoped_package?).returns(true)
+      @spec.stubs(:publish_config_access).returns("restricted")
+      assert @spec.private_scoped_package?
+    end
+
     test '#publish_npm_package checks if version tag exists, and then invokes npm deploy script' do
       @spec.stubs(:npm?).returns(true)
-      assert_equal ['assert-npm-version-tag', 'npm publish'], @spec.deploy_steps
+      @spec.stubs(:package_version).returns('1.0.0')
+      @spec.stubs(:valid_publish_config?).returns(true)
+      @spec.stubs(:publish_config_access).returns('restricted')
+      @spec.stubs(:registry).returns("@private:registry=some_private_registry")
+      assert_equal ['assert-npm-version-tag', 'npm publish --tag latest --access restricted'], @spec.deploy_steps
+    end
+
+    test '#npmrc_contents returns a scoped private package configuration when the package is scoped and private' do
+      registry = "@shopify:registry=some_private_registry"
+      Shipit.stubs(:npm_org_scope).returns('@shopify')
+      Shipit.stubs(:private_npm_registry).returns('some_private_registry')
+      @spec.stubs(:scoped_package?).returns(true)
+      @spec.stubs(:publish_config_access).returns('restricted')
+      assert_equal registry, @spec.registry
+    end
+
+    test '#npmrc_contents returns a public scoped package configuration when the package is scoped and public' do
+      registry = "@shopify:registry=https://registry.npmjs.org/"
+      Shipit.stubs(:npm_org_scope).returns('@shopify')
+      @spec.stubs(:scoped_package?).returns(true)
+      @spec.stubs(:publish_config_access).returns('public')
+      assert_equal registry, @spec.registry
+    end
+
+    test '#npmrc_contents returns a public non-scoped package configuration when the package is not scoped and public' do
+      registry = "registry=https://registry.npmjs.org/"
+      @spec.stubs(:scoped_package?).returns(false)
+      @spec.stubs(:publish_config_access).returns('public')
+      assert_equal registry, @spec.registry
+    end
+
+    test '#publish_lerna_packages guesses npm tag' do
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_version).returns('1.0.0-alpha.1')
+      assert_match(/--npm-tag next/, @spec.deploy_steps.last)
+    end
+
+    test '#publish_npm_package checks if version tag and a pre-release flag exist, and then invokes npm deploy script' do
+      @spec.stubs(:npm?).returns(true)
+      @spec.stubs(:package_version).returns('1.0.0-alpha.1')
+      @spec.stubs(:valid_publish_config?).returns(true)
+      @spec.stubs(:publish_config_access).returns('restricted')
+      @spec.stubs(:registry).returns("@private:registry=some_private_registry")
+      assert_equal ['assert-npm-version-tag', 'npm publish --tag next --access restricted'], @spec.deploy_steps
     end
 
     test 'bundler installs take priority over yarn installs' do
@@ -663,14 +864,49 @@ module Shipit
       assert_equal ['yarn install --no-progress'], @spec.dependencies_steps
     end
 
-    test '#publish_yarn_package checks if version tag exists, and then invokes npm publish script' do
+    test '#publish_npm_package checks if version tag exists, and then invokes npm publish script' do
       @spec.stubs(:yarn?).returns(true).at_least_once
-      assert_equal ['assert-npm-version-tag', 'npm publish'], @spec.deploy_steps
+      @spec.stubs(:package_version).returns('1.0.0')
+      @spec.stubs(:valid_publish_config?).returns(true)
+      @spec.stubs(:publish_config_access).returns('restricted')
+      @spec.stubs(:registry).returns("@private:registry=some_private_registry")
+      assert_equal ['assert-npm-version-tag', 'npm publish --tag latest --access restricted'], @spec.deploy_steps
+    end
+
+    test '#publish_npm_package checks if version tag exists, generates npmrc, and then invokes npm publish script when enforce_publish_config? is true' do
+      @spec.stubs(:yarn?).returns(true).at_least_once
+      @spec.stubs(:package_version).returns('1.0.0')
+      @spec.stubs(:valid_publish_config?).returns(true)
+
+      @spec.stubs(:publish_config_access).returns('restricted')
+      @spec.stubs(:enforce_publish_config?).returns(true)
+      @spec.stubs(:registry).returns('fake')
+
+      generate_npmrc = 'generate-local-npmrc "fake"'
+      npm_publish = 'npm publish --tag latest --access restricted'
+      deploy_steps = ['assert-npm-version-tag', generate_npmrc, npm_publish]
+      assert_equal deploy_steps, @spec.deploy_steps
     end
 
     test 'yarn checklist takes precedence over npm checklist' do
       @spec.stubs(:yarn?).returns(true).at_least_once
       assert_match(/yarn version/, @spec.review_checklist[0])
     end
+
+    test "max_divergence_commits defaults to `nil" do
+      @spec.expects(:load_config).returns({})
+      assert_nil @spec.max_divergence_commits
+    end
+
+    test "max_divergence_age defaults to `nil` if `merge.max_divergence.age` cannot be parsed" do
+      @spec.expects(:load_config).returns(
+        'merge' => {
+          'max_divergence' => {
+            'age' => 'badbadbad',
+          },
+        },
+      )
+      assert_nil @spec.max_divergence_age
+    end
   end
 end

data/test/models/deploys_test.rb

@@ -229,7 +229,7 @@ module Shipit
       @deploy = shipit_deploys(:shipit_running)
       @deploy.complete!
       @stack.reload
-      assert_in_delta @deploy.ended_at, @stack.last_deployed_at, 1
+      assert_in_delta @deploy.ended_at, @stack.last_deployed_at, 2
     end
 
     test "transitioning to success schedule a MergePullRequests job" do
@@ -264,7 +264,7 @@ module Shipit
       @deploy = shipit_deploys(:shipit_running)
       @deploy.ping
       @deploy.pid = 42
-      @deploy.abort!(rollback_once_aborted: true)
+      @deploy.abort!(rollback_once_aborted: true, aborted_by: @user)
 
       assert_difference -> { @stack.rollbacks.count }, 1 do
         assert_enqueued_with(job: PerformTaskJob) do
@@ -346,12 +346,12 @@ module Shipit
 
     test "abort! transition to `aborting`" do
       @deploy.ping
-      @deploy.abort!
+      @deploy.abort!(aborted_by: @user)
       assert_equal 'aborting', @deploy.status
     end
 
     test "abort! schedule the rollback if `rollback_once_aborted` is true" do
-      @deploy.abort!(rollback_once_aborted: true)
+      @deploy.abort!(rollback_once_aborted: true, aborted_by: @user)
       assert_predicate @deploy.reload, :rollback_once_aborted?
     end
 
@@ -359,11 +359,11 @@ module Shipit
       @deploy.ping
       aborts = []
 
-      @deploy.abort!
+      @deploy.abort!(aborted_by: @user)
       @deploy.should_abort? { |abort_count| aborts << abort_count }
       assert_equal [1], aborts
 
-      3.times { @deploy.abort! }
+      3.times { @deploy.abort!(aborted_by: @user) }
       @deploy.should_abort? { |abort_count| aborts << abort_count }
       assert_equal [1, 2, 3, 4], aborts
     end
@@ -373,7 +373,7 @@ module Shipit
       refute_predicate @deploy, :alive?
       refute_predicate @deploy, :finished?
 
-      @deploy.abort!
+      @deploy.abort!(aborted_by: @user)
       assert_predicate @deploy, :error?
     end
 

data/test/models/hook_test.rb

@@ -58,10 +58,16 @@ module Shipit
 
     test "#purge_old_deliveries!" do
       Hook.deliver(:deploy, @stack, 'foo' => 42)
+      @hook.deliveries.update_all(status: 'sent')
 
-      assert_difference -> { Delivery.count }, -1 do
+      previous_ids = @hook.deliveries.sent.order(id: :desc).pluck(:id)
+
+      assert_difference -> { @hook.deliveries.sent.count }, -1 do
         @hook.purge_old_deliveries!(keep: 1)
       end
+
+      after_ids = @hook.deliveries.sent.order(id: :desc).pluck(:id)
+      assert_equal previous_ids[0..-2], after_ids
     end
   end
 end

data/test/models/pull_request_test.rb

@@ -29,7 +29,7 @@ module Shipit
       PullRequest.request_merge!(@stack, @pr.number, @user)
       assert_predicate @pr.reload, :pending?
       assert_not_equal original_merge_requested_at, @pr.merge_requested_at
-      assert_in_delta Time.now.utc, @pr.merge_requested_at, 1
+      assert_in_delta Time.now.utc, @pr.merge_requested_at, 2
     end
 
     test ".request_merge! retry rejected pull requests" do
@@ -39,7 +39,7 @@ module Shipit
       PullRequest.request_merge!(@stack, @pr.number, @user)
       assert_predicate @pr.reload, :pending?
       assert_not_equal original_merge_requested_at, @pr.merge_requested_at
-      assert_in_delta Time.now.utc, @pr.merge_requested_at, 1
+      assert_in_delta Time.now.utc, @pr.merge_requested_at, 2
       assert_nil @pr.rejection_reason
     end
 
@@ -68,6 +68,7 @@ module Shipit
       pull_request = shipit_pull_requests(:shipit_fetching)
 
       head_sha = '64b3833d39def7ec65b57b42f496eb27ab4980b6'
+      base_sha = 'ba7ab50e02286f7d6c60c1ef75258133dd9ea763'
       Shipit.github_api.expects(:pull_request).with(@stack.github_repo_name, pull_request.number).returns(
         stub(
           id: 4_857_578,
@@ -82,6 +83,10 @@ module Shipit
             ref: 'super-branch',
             sha: head_sha,
           ),
+          base: stub(
+            ref:  'default-branch',
+            sha: base_sha,
+          ),
         ),
       )
 
@@ -91,22 +96,25 @@ module Shipit
         name: 'Bob the Builder',
         email: 'bob@bob.com',
       )
-      Shipit.github_api.expects(:commit).with(@stack.github_repo_name, head_sha).returns(
-        stub(
-          sha: head_sha,
-          author: author,
-          committer: author,
-          commit: stub(
-            message: 'Great feature',
-            author: stub(date: 1.day.ago),
-            committer: stub(date: 1.day.ago),
-          ),
-          stats: stub(
-            additions: 24,
-            deletions: 5,
+
+      [head_sha, base_sha].each do |sha|
+        Shipit.github_api.expects(:commit).with(@stack.github_repo_name, sha).returns(
+          stub(
+            sha: sha,
+            author: author,
+            committer: author,
+            commit: stub(
+              message: 'Great feature',
+              author: stub(date: 1.day.ago),
+              committer: stub(date: 1.day.ago),
+            ),
+            stats: stub(
+              additions: 24,
+              deletions: 5,
+            ),
           ),
-        ),
-      )
+        )
+      end
 
       Shipit.github_api.expects(:statuses).with(@stack.github_repo_name, head_sha).returns([stub(
         state: 'success',
@@ -156,21 +164,30 @@ module Shipit
       assert_equal 'merge_conflict', @pr.rejection_reason
     end
 
-    test "#reject_unless_mergeable! rejects the PR if it has a failing or pending CI status" do
-      @pr.head.statuses.create!(stack: @pr.stack, state: 'pending', context: 'ci/circle')
+    test "#reject_unless_mergeable! rejects the PR if it has a failing CI status" do
+      @pr.head.statuses.create!(stack: @pr.stack, state: 'failure', context: 'ci/circle')
 
       refute_predicate @pr, :all_status_checks_passed?
+      assert_predicate @pr, :any_status_checks_failed?
       assert_equal true, @pr.reject_unless_mergeable!
       assert_predicate @pr, :rejected?
       assert_equal 'ci_failing', @pr.rejection_reason
     end
 
-    test "#merge! revalidates the PR if it has been enqueued for too long" do
-      @pr.update!(revalidated_at: 5.hours.ago)
+    test "#reject_unless_mergeable! does not reject the PR if it has a pending CI status" do
+      @pr.head.statuses.create!(stack: @pr.stack, state: 'pending', context: 'ci/circle')
 
-      assert_predicate @pr, :need_revalidation?
-      assert_equal false, @pr.merge!
-      assert_predicate @pr, :revalidating?
+      refute_predicate @pr, :all_status_checks_passed?
+      refute_predicate @pr, :any_status_checks_failed?
+      assert_equal false, @pr.reject_unless_mergeable!
+      refute_predicate @pr, :rejected?
+    end
+
+    test "#reject_unless_mergeable! rejects the PR if it is stale" do
+      @pr.stubs(:stale?).returns(true)
+      assert_equal true, @pr.reject_unless_mergeable!
+      assert_predicate @pr, :rejected?
+      assert_equal 'requires_rebase', @pr.rejection_reason
     end
 
     test "#merge! raises a PullRequest::NotReady if the PR isn't mergeable yet" do
@@ -211,5 +228,42 @@ module Shipit
         @stack.reload
       end
     end
+
+    test "#all_status_checks_passed? returns false when head commit is unknown" do
+      @pr.update(head_id: nil)
+      refute_predicate @pr, :all_status_checks_passed?
+    end
+
+    test "#stale? returns false by default" do
+      refute_predicate @pr, :stale?
+    end
+
+    test "#stale? returns true when the branch falls behind the maximum commits" do
+      @pr.base_commit = shipit_commits(:second)
+      @pr.base_ref = 'default-branch'
+      Shipit.github_api.expects(:compare).with(@stack.github_repo_name, @pr.base_ref, @pr.head.sha).returns(
+        stub(
+          behind_by: 10,
+        ),
+      )
+      spec = {'merge' => {'max_divergence' => {'commits' => 1}}}
+      @pr.stack.cached_deploy_spec = DeploySpec.new(spec)
+      assert_predicate @pr, :stale?
+    end
+
+    test "#stale? returns true when the branch falls behind the maximum age" do
+      @pr.base_commit = shipit_commits(:second)
+      @pr.head.committed_at = 2.hours.ago
+      spec = {'merge' => {'max_divergence' => {'age' => '1h'}}}
+      @pr.stack.cached_deploy_spec = DeploySpec.new(spec)
+      assert_predicate @pr, :stale?
+    end
+
+    test "#stale? is false when base_commit information is missing" do
+      @pr.base_commit = nil
+      spec = {'merge' => {'max_divergence' => {'age' => '1h', 'commits' => 10}}}
+      @pr.stack.cached_deploy_spec = DeploySpec.new(spec)
+      refute_predicate @pr, :stale?
+    end
   end
 end