shipit-engine 0.32.0 → 0.35.1

data/test/models/deploy_spec_test.rb

@@ -106,6 +106,12 @@ module Shipit
       refute @spec.bundle_install.last.include?('--frozen')
     end
 
+    test "#provisioning_handler returns `provision.handler` if present" do
+      @spec.stubs(:load_config).returns('provision' => { 'handler_name' => 'ExpectedProvisioningHandler' })
+
+      assert_equal "ExpectedProvisioningHandler", @spec.provisioning_handler_name
+    end
+
     test '#deploy_steps returns `deploy.override` if present' do
       @spec.stubs(:load_config).returns('deploy' => { 'override' => %w(foo bar baz) })
       assert_equal %w(foo bar baz), @spec.deploy_steps
@@ -175,11 +181,31 @@ module Shipit
       end
     end
 
+    test '#retries_on_deploy returns `deploy.retries` if present' do
+      @spec.stubs(:load_config).returns('deploy' => { 'retries' => 5 })
+      assert_equal 5, @spec.retries_on_deploy
+    end
+
+    test '#retries_on_deploy returns a default value if `deploy.retries` is not present' do
+      @spec.stubs(:load_config).returns('deploy' => {})
+      assert_nil @spec.retries_on_deploy
+    end
+
     test '#rollback_steps returns `rollback.override` if present' do
       @spec.stubs(:load_config).returns('rollback' => { 'override' => %w(foo bar baz) })
       assert_equal %w(foo bar baz), @spec.rollback_steps
     end
 
+    test '#retries_on_rollback returns `rollback.retries` if present' do
+      @spec.stubs(:load_config).returns('rollback' => { 'retries' => 5 })
+      assert_equal 5, @spec.retries_on_rollback
+    end
+
+    test '#retries_on_rollback returns a default value if `rollback.retries` is not present' do
+      @spec.stubs(:load_config).returns('rollback' => {})
+      assert_nil @spec.retries_on_rollback
+    end
+
     test '#rollback_steps returns `cap $ENVIRONMENT deploy:rollback` if a `Capfile` is present' do
       @spec.expects(:bundler?).returns(true).at_least_once
       @spec.expects(:capistrano?).returns(true)
@@ -364,13 +390,20 @@ module Shipit
         },
         'dependencies' => { 'override' => [] },
         'plugins' => {},
+        'provision' => {
+          'handler_name' => nil,
+        },
         'deploy' => {
           'override' => nil,
           'variables' => [],
           'max_commits' => 8,
           'interval' => 0,
+          'retries' => nil,
+        },
+        'rollback' => {
+          'override' => nil,
+          'retries' => nil,
         },
-        'rollback' => { 'override' => nil },
         'fetch' => nil,
         'tasks' => {},
       }
@@ -559,40 +592,40 @@ module Shipit
       assert_equal %w(ci/circleci soc/compliance), @spec.required_statuses
     end
 
-    test "pull_request_merge_method defaults to `nil`" do
+    test "merge_request_merge_method defaults to `nil`" do
       @spec.expects(:load_config).returns({})
-      assert_nil @spec.pull_request_merge_method
+      assert_nil @spec.merge_request_merge_method
     end
 
-    test "pull_request_merge_method returns `merge.method`" do
+    test "merge_request_merge_method returns `merge.method`" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'method' => 'squash',
         },
       )
-      assert_equal 'squash', @spec.pull_request_merge_method
+      assert_equal 'squash', @spec.merge_request_merge_method
     end
 
-    test "pull_request_merge_method returns `nil` if `merge.method` is invalid" do
+    test "merge_request_merge_method returns `nil` if `merge.method` is invalid" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'method' => 'squashing',
         },
       )
-      assert_nil @spec.pull_request_merge_method
+      assert_nil @spec.merge_request_merge_method
     end
 
-    test "pull_request_ignored_statuses defaults to the union of ci.hide and ci.allow_failures" do
+    test "merge_request_ignored_statuses defaults to the union of ci.hide and ci.allow_failures" do
       @spec.expects(:load_config).returns(
         'ci' => {
           'hide' => %w(ci/circleci ci/jenkins),
           'allow_failures' => %w(ci/circleci ci/travis),
         },
       )
-      assert_equal %w(ci/circleci ci/jenkins ci/travis).sort, @spec.pull_request_ignored_statuses.sort
+      assert_equal %w(ci/circleci ci/jenkins ci/travis).sort, @spec.merge_request_ignored_statuses.sort
     end
 
-    test "pull_request_ignored_statuses defaults to empty if `merge.require` is present" do
+    test "merge_request_ignored_statuses defaults to empty if `merge.require` is present" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'require' => 'bar',
@@ -602,10 +635,10 @@ module Shipit
           'allow_failures' => %w(ci/circleci ci/travis),
         },
       )
-      assert_equal [], @spec.pull_request_ignored_statuses
+      assert_equal [], @spec.merge_request_ignored_statuses
     end
 
-    test "pull_request_ignored_statuses returns `merge.ignore` if present" do
+    test "merge_request_ignored_statuses returns `merge.ignore` if present" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'ignore' => 'bar',
@@ -615,19 +648,19 @@ module Shipit
           'allow_failures' => %w(ci/circleci ci/travis),
         },
       )
-      assert_equal ['bar'], @spec.pull_request_ignored_statuses
+      assert_equal ['bar'], @spec.merge_request_ignored_statuses
     end
 
-    test "pull_request_required_statuses defaults to ci.require" do
+    test "merge_request_required_statuses defaults to ci.require" do
       @spec.expects(:load_config).returns(
         'ci' => {
           'require' => %w(ci/circleci ci/jenkins),
         },
       )
-      assert_equal %w(ci/circleci ci/jenkins), @spec.pull_request_required_statuses
+      assert_equal %w(ci/circleci ci/jenkins), @spec.merge_request_required_statuses
     end
 
-    test "pull_request_required_statuses defaults to empty if `merge.ignore` is present" do
+    test "merge_request_required_statuses defaults to empty if `merge.ignore` is present" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'ignore' => 'bar',
@@ -636,10 +669,10 @@ module Shipit
           'require' => %w(ci/circleci ci/jenkins),
         },
       )
-      assert_equal [], @spec.pull_request_required_statuses
+      assert_equal [], @spec.merge_request_required_statuses
     end
 
-    test "pull_request_required_statuses returns `merge.require` if present" do
+    test "merge_request_required_statuses returns `merge.require` if present" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'require' => 'bar',
@@ -649,21 +682,21 @@ module Shipit
           'allow_failures' => %w(ci/circleci ci/travis),
         },
       )
-      assert_equal ['bar'], @spec.pull_request_required_statuses
+      assert_equal ['bar'], @spec.merge_request_required_statuses
     end
 
-    test "revalidate_pull_requests_after defaults to `nil" do
+    test "revalidate_merge_requests_after defaults to `nil" do
       @spec.expects(:load_config).returns({})
-      assert_nil @spec.revalidate_pull_requests_after
+      assert_nil @spec.revalidate_merge_requests_after
     end
 
-    test "revalidate_pull_requests_after defaults to `nil` if `merge.timeout` cannot be parsed" do
+    test "revalidate_merge_requests_after defaults to `nil` if `merge.timeout` cannot be parsed" do
       @spec.expects(:load_config).returns(
         'merge' => {
           'revalidate_after' => 'ALSKhfjsdkf',
         },
       )
-      assert_nil @spec.revalidate_pull_requests_after
+      assert_nil @spec.revalidate_merge_requests_after
     end
 
     test "revalidate_after returns `merge.revalidate_after` if present" do
@@ -672,7 +705,7 @@ module Shipit
           'revalidate_after' => '5m30s',
         },
       )
-      assert_equal 330, @spec.revalidate_pull_requests_after.to_i
+      assert_equal 330, @spec.revalidate_merge_requests_after.to_i
     end
 
     test "#file is impacted by `machine.directory`" do
@@ -795,6 +828,13 @@ module Shipit
       @spec.stubs(:lerna?).returns(true)
       @spec.stubs(:lerna_config).returns('lerna' => '2.0.0', 'version' => 'independent')
       assert_equal 'assert-lerna-independent-version-tags', @spec.deploy_steps[0]
+      assert_equal 'publish-lerna-independent-packages-legacy', @spec.deploy_steps[1]
+    end
+
+    test '#publish_lerna_packages checks if independent version tags exist, checks if a newer version of lerna is used, and then invokes lerna deploy script' do
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_config).returns('lerna' => '3.0.0', 'version' => 'independent')
+      assert_equal 'assert-lerna-independent-version-tags', @spec.deploy_steps[0]
       assert_equal 'publish-lerna-independent-packages', @spec.deploy_steps[1]
     end
 

data/test/models/deploys_test.rb

@@ -5,6 +5,7 @@ module Shipit
   class DeploysTest < ActiveSupport::TestCase
     def setup
       @deploy = shipit_deploys(:shipit)
+      @deploy.write("dummy output")
       @deploy.pid = 42
       @stack = shipit_stacks(:shipit)
       @user = shipit_users(:walrus)
@@ -60,6 +61,146 @@ module Shipit
       assert_equal [], @deploy.commits
     end
 
+    test "deploys retry up to limit upon timeout when configured" do
+      runnable_deploy = shipit_deploys(:shipit_pending)
+      deploy_stack = runnable_deploy.stack
+
+      Shipit::Deploy.any_instance.expects(:acquire_git_cache_lock).twice
+        .raises(Shipit::Command::TimedOut, 'Deploy timed out')
+        .then.raises(Shipit::Command::Error, "Second command error failure")
+
+      perform_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        runnable_deploy.enqueue
+      end
+      assert_performed_jobs 2
+
+      runnable_deploy.reload
+      assert_equal 'timedout', runnable_deploy.status
+
+      retried_deploy = deploy_stack.deploys.last
+      assert_not_equal runnable_deploy.id, retried_deploy.id
+      assert_equal runnable_deploy.since_commit, retried_deploy.since_commit
+      assert_equal runnable_deploy.until_commit, retried_deploy.until_commit
+      assert_equal 'failed', retried_deploy.status
+      assert_equal 1, retried_deploy.retry_attempt
+    end
+
+    test "deploys retry up to limit upon failure when configured" do
+      runnable_deploy = shipit_deploys(:shipit_pending)
+      deploy_stack = runnable_deploy.stack
+
+      Shipit::Deploy.any_instance.expects(:acquire_git_cache_lock).twice
+        .raises(Shipit::Command::Error, 'Deploy failed')
+        .then.raises(Shipit::Command::Error, "Second deploy failed")
+
+      perform_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        runnable_deploy.enqueue
+      end
+      assert_performed_jobs 2
+
+      runnable_deploy.reload
+      assert_equal 'failed', runnable_deploy.status
+
+      retried_deploy = deploy_stack.deploys.last
+      assert_not_equal runnable_deploy.id, retried_deploy.id
+      assert_equal runnable_deploy.since_commit, retried_deploy.since_commit
+      assert_equal runnable_deploy.until_commit, retried_deploy.until_commit
+      assert_equal 'failed', retried_deploy.status
+      assert_equal 1, retried_deploy.retry_attempt
+    end
+
+    test "deploys retry up to limit upon error when configured" do
+      runnable_deploy = shipit_deploys(:shipit_pending)
+      deploy_stack = runnable_deploy.stack
+
+      Shipit::Deploy.any_instance.expects(:acquire_git_cache_lock).twice
+        .raises(StandardError, 'Deploy failed')
+        .then.raises(StandardError, "Second deploy failed")
+
+      perform_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        runnable_deploy.enqueue
+      end
+      assert_performed_jobs 2
+
+      runnable_deploy.reload
+      assert_equal 'error', runnable_deploy.status
+
+      retried_deploy = deploy_stack.deploys.last
+      assert_not_equal runnable_deploy.id, retried_deploy.id
+      assert_equal runnable_deploy.since_commit, retried_deploy.since_commit
+      assert_equal runnable_deploy.until_commit, retried_deploy.until_commit
+      assert_equal 'error', retried_deploy.status
+      assert_equal 1, retried_deploy.retry_attempt
+    end
+
+    test "deploys do not retry upon timeout when not configured" do
+      runnable_deploy = shipit_deploys(:shipit_pending)
+      runnable_deploy.update!(retry_attempt: 0, max_retries: 0)
+
+      Shipit::Deploy.any_instance.expects(:acquire_git_cache_lock)
+        .raises(Shipit::Command::TimedOut, 'Deploy timed out')
+
+      perform_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        runnable_deploy.enqueue
+      end
+      assert_performed_jobs 1
+
+      runnable_deploy.reload
+
+      assert_equal 'timedout', runnable_deploy.status
+    end
+
+    test "rollbacks retry on timeouts if configured" do
+      deploy = shipit_deploys(:shipit)
+      deploy_stack = deploy.stack
+
+      DeploySpec.any_instance.expects(:retries_on_rollback).returns(1)
+
+      Shipit::Command.any_instance.expects(:run).twice
+        .raises(Shipit::Command::TimedOut, 'Rollback timed out')
+        .then.raises(Shipit::Command::Error, "Second command error failure")
+
+      first_rollback = nil
+
+      perform_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        first_rollback = deploy.trigger_rollback(@user, force: true)
+      end
+      assert_performed_jobs 2
+
+      first_rollback.reload
+
+      assert_equal 'timedout', first_rollback.status
+      retried_rollback = deploy_stack.deploys_and_rollbacks.last
+
+      assert_not_equal first_rollback.id, retried_rollback.id
+      assert_equal first_rollback.since_commit, retried_rollback.since_commit
+      assert_equal first_rollback.until_commit, retried_rollback.until_commit
+      assert_equal 'failed', retried_rollback.status
+      assert_equal 1, retried_rollback.max_retries
+    end
+
+    test "rollbacks do not retry if not configured" do
+      deploy_stack = @deploy.stack
+
+      DeploySpec.any_instance.expects(:retries_on_rollback).returns(0)
+
+      Shipit::Command.any_instance.expects(:run).once
+        .raises(Shipit::Command::TimedOut, 'Rollback timed out')
+        .then.raises(Shipit::Command::Error, "Second command error failure")
+
+      first_rollback = nil
+
+      perform_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        first_rollback = @deploy.trigger_rollback(@user, force: true)
+      end
+      assert_performed_jobs 1
+
+      first_rollback.reload
+
+      assert_equal 'timedout', first_rollback.status
+      assert_equal first_rollback, deploy_stack.deploys_and_rollbacks.last
+    end
+
     test "additions and deletions are denormalized on before create" do
       stack = shipit_stacks(:shipit)
       first = shipit_commits(:first)
@@ -200,7 +341,7 @@ module Shipit
         since_commit: shipit.commits.first,
         until_commit: shipit.commits.last,
       )
-      deploy.stubs(:pull_request_head_for_commit).returns(nil)
+      deploy.stubs(:merge_request_head_for_commit).returns(nil)
 
       expect_event(deploy)
       deploy.save!
@@ -263,9 +404,9 @@ module Shipit
       assert_in_delta @deploy.ended_at, @stack.last_deployed_at, 2
     end
 
-    test "transitioning to success schedule a MergePullRequests job" do
+    test "transitioning to success schedule a MergeMergeRequests job" do
       @deploy = shipit_deploys(:shipit_running)
-      assert_enqueued_with(job: MergePullRequestsJob, args: [@deploy.stack]) do
+      assert_enqueued_with(job: ProcessMergeRequestsJob, args: [@deploy.stack]) do
         @deploy.complete!
       end
     end
@@ -393,7 +534,7 @@ module Shipit
     # Check that the next item in the series is 1 greater than the last.
     def assert_generated_record_ids_are_sequential(record_id_series)
       record_id_series[0..-2].each_with_index do |id_element, index|
-        assert_equal id_element + 1, record_id_series[index + 1]
+        assert_equal(id_element + 1, record_id_series[index + 1])
       end
     end
 
@@ -661,6 +802,12 @@ module Shipit
       assert_equal @user, @stack.lock_author
     end
 
+    test "#trigger_rollback does not lock the stack if not requested" do
+      refute @stack.locked?
+      @deploy.trigger_rollback(@user, lock: false)
+      refute @stack.reload.locked?
+    end
+
     test "#trigger_rollback marks the rollback as `ignored_safeties` if the force option was used" do
       rollback = @deploy.trigger_rollback(@user, force: true)
       assert_predicate rollback, :ignored_safeties?
@@ -699,20 +846,13 @@ module Shipit
       assert_predicate @deploy, :error?
     end
 
-    test "destroy deletes the related output chunks" do
-      assert_difference -> { @deploy.chunks.count }, -@deploy.chunks.count do
-        @deploy.destroy
-      end
-    end
-
-    test "#chunk_output joins all chunk test if logs not rolled up" do
-      assert_equal @deploy.chunks.count, @deploy.chunks.count
-      assert_equal @deploy.chunks.pluck(:text).join, @deploy.chunk_output
+    test "#chunk_output fetches from Redis if logs not rolled up" do
+      assert_equal Shipit.redis.get(@deploy.send(:output_key)), @deploy.chunk_output
       refute @deploy.rolled_up
     end
 
     test "#chunk_output returns logs from records if rolled up" do
-      expected_output = @deploy.chunks.pluck(:text).join
+      expected_output = Shipit.redis.get(@deploy.send(:output_key))
       @deploy.rollup_chunks
 
       assert_no_queries do
@@ -833,6 +973,18 @@ module Shipit
       end
     end
 
+    test "succeeding a deploy sets the release status as pending and does not schedule job if the status delay is negative (-1)" do
+      @deploy = shipit_deploys(:canaries_running)
+      @deploy.stack.expects(:release_status_delay).at_least_once.returns(Duration.parse(-1))
+
+      assert_difference -> { ReleaseStatus.count }, +1 do
+        assert_not_equal 'success', @deploy.last_release_status.state
+        @deploy.report_complete!
+        assert_equal 'validating', @deploy.status
+        assert_equal 'pending', @deploy.last_release_status.state
+      end
+    end
+
     test "triggering a rollback via abort! sets the release status as failure" do
       @deploy = shipit_deploys(:canaries_running)
       @deploy.ping
@@ -878,6 +1030,28 @@ module Shipit
       end
     end
 
+    test "manually triggered rollbacks sets rollbacked deploys as faulty and not the rollback task" do
+      @deploy = shipit_deploys(:canaries_validating)
+      @middle_deploy = shipit_deploys(:canaries_faulty)
+      @rollback_to_deploy = shipit_deploys(:canaries_success)
+
+      @rollback_task = @rollback_to_deploy.trigger_rollback(force: true)
+
+      @rollback_task.run!
+      @rollback_task.complete!
+      @rollback_task.reload
+      @deploy.reload
+      @middle_deploy.reload
+
+      assert_equal 'faulty', @deploy.status
+      assert_equal 'failure', @deploy.last_release_status.state
+
+      assert_equal 'faulty', @middle_deploy.status
+      assert_equal 'failure', @middle_deploy.last_release_status.state
+
+      assert_equal 'success', @rollback_task.status
+    end
+
     test "succeeding a deploy creates CommitDeploymentStatuses" do
       @deploy = shipit_deploys(:shipit_running)
       refute_empty @deploy.commit_deployments