shipit-engine 0.32.0 → 0.33.0

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
 
@@ -699,20 +840,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

data/test/models/{pull_request_test.rb → merge_request_test.rb}

@@ -2,24 +2,24 @@
 require 'test_helper'
 
 module Shipit
-  class PullRequestTest < ActiveSupport::TestCase
+  class MergeRequestTest < ActiveSupport::TestCase
     setup do
       @stack = shipit_stacks(:shipit)
-      @pr = shipit_pull_requests(:shipit_pending)
+      @pr = shipit_merge_requests(:shipit_pending)
       @user = shipit_users(:walrus)
     end
 
     test ".request_merge! creates a record and schedule a refresh" do
-      pull_request = nil
-      assert_enqueued_with(job: RefreshPullRequestJob) do
-        pull_request = PullRequest.request_merge!(@stack, 64, @user)
+      merge_request = nil
+      assert_enqueued_with(job: RefreshMergeRequestJob) do
+        merge_request = MergeRequest.request_merge!(@stack, 64, @user)
       end
-      assert_predicate pull_request, :persisted?
+      assert_predicate merge_request, :persisted?
     end
 
     test ".request_merge! only track pull requests once" do
-      assert_difference -> { PullRequest.count }, +1 do
-        5.times { PullRequest.request_merge!(@stack, 999, @user) }
+      assert_difference -> { MergeRequest.count }, +1 do
+        5.times { MergeRequest.request_merge!(@stack, 999, @user) }
       end
     end
 
@@ -27,7 +27,7 @@ module Shipit
       original_merge_requested_at = @pr.merge_requested_at
       @pr.cancel!
       assert_predicate @pr, :canceled?
-      PullRequest.request_merge!(@stack, @pr.number, @user)
+      MergeRequest.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, 2
@@ -37,7 +37,7 @@ module Shipit
       original_merge_requested_at = @pr.merge_requested_at
       @pr.reject!('merge_conflict')
       assert_predicate @pr, :rejected?
-      PullRequest.request_merge!(@stack, @pr.number, @user)
+      MergeRequest.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, 2
@@ -48,29 +48,29 @@ module Shipit
       original_merge_requested_at = @pr.merge_requested_at
       @pr.revalidate!
       assert_predicate @pr, :revalidating?
-      PullRequest.request_merge!(@stack, @pr.number, @user)
+      MergeRequest.request_merge!(@stack, @pr.number, @user)
       assert_predicate @pr.reload, :pending?
       assert_equal original_merge_requested_at, @pr.merge_requested_at
     end
 
     test ".extract_number can get a pull request number from different formats" do
-      assert_equal 42, PullRequest.extract_number(@stack, '42')
-      assert_equal 42, PullRequest.extract_number(@stack, '#42')
-      assert_equal 42, PullRequest.extract_number(@stack, 'https://github.com/Shopify/shipit-engine/pull/42')
+      assert_equal 42, MergeRequest.extract_number(@stack, '42')
+      assert_equal 42, MergeRequest.extract_number(@stack, '#42')
+      assert_equal 42, MergeRequest.extract_number(@stack, 'https://github.com/Shopify/shipit-engine/pull/42')
 
-      assert_nil PullRequest.extract_number(@stack, 'https://github.com/ACME/shipit-engine/pull/42')
+      assert_nil MergeRequest.extract_number(@stack, 'https://github.com/ACME/shipit-engine/pull/42')
 
       Shipit.github.expects(:domain).returns('github.acme.com').at_least_once
-      assert_equal 42, PullRequest.extract_number(@stack, 'https://github.acme.com/Shopify/shipit-engine/pull/42')
-      assert_nil PullRequest.extract_number(@stack, 'https://github.com/Shopify/shipit-engine/pull/42')
+      assert_equal 42, MergeRequest.extract_number(@stack, 'https://github.acme.com/Shopify/shipit-engine/pull/42')
+      assert_nil MergeRequest.extract_number(@stack, 'https://github.com/Shopify/shipit-engine/pull/42')
     end
 
     test "refresh! pulls state from GitHub" do
-      pull_request = shipit_pull_requests(:shipit_fetching)
+      merge_request = shipit_merge_requests(:shipit_fetching)
 
       head_sha = '64b3833d39def7ec65b57b42f496eb27ab4980b6'
       base_sha = 'ba7ab50e02286f7d6c60c1ef75258133dd9ea763'
-      Shipit.github.api.expects(:pull_request).with(@stack.github_repo_name, pull_request.number).returns(
+      Shipit.github.api.expects(:pull_request).with(@stack.github_repo_name, merge_request.number).returns(
         stub(
           id: 4_857_578,
           url: 'https://api.github.com/repos/Shopify/shipit-engine/pulls/64',
@@ -125,15 +125,15 @@ module Shipit
         created_at: 1.day.ago,
       )])
 
-      pull_request.refresh!
+      merge_request.refresh!
 
-      assert_predicate pull_request, :mergeable?
-      assert_predicate pull_request, :pending?
-      assert_equal 'super-branch', pull_request.branch
+      assert_predicate merge_request, :mergeable?
+      assert_predicate merge_request, :pending?
+      assert_equal 'super-branch', merge_request.branch
 
-      assert_not_nil pull_request.head
-      assert_predicate pull_request.head, :detached?
-      assert_predicate pull_request.head, :success?
+      assert_not_nil merge_request.head
+      assert_predicate merge_request.head, :detached?
+      assert_predicate merge_request.head, :success?
     end
 
     test "#reject! records the reason" do
@@ -216,11 +216,11 @@ module Shipit
       assert_equal 'requires_rebase', @pr.rejection_reason
     end
 
-    test "#merge! raises a PullRequest::NotReady if the PR isn't mergeable yet" do
+    test "#merge! raises a MergeRequest::NotReady if the PR isn't mergeable yet" do
       @pr.update!(mergeable: nil)
 
       assert_predicate @pr, :not_mergeable_yet?
-      assert_raises PullRequest::NotReady do
+      assert_raises MergeRequest::NotReady do
         @pr.merge!
       end
       @pr.reload
@@ -234,8 +234,8 @@ module Shipit
       params = job.arguments.first
       assert_equal 'merge', params[:event]
       assert_json 'status', 'rejected', document: params[:payload]
-      assert_json 'pull_request.rejection_reason', 'merge_conflict', document: params[:payload]
-      assert_json 'pull_request.number', @pr.number, document: params[:payload]
+      assert_json 'merge_request.rejection_reason', 'merge_conflict', document: params[:payload]
+      assert_json 'merge_request.number', @pr.number, document: params[:payload]
     end
 
     test "#merge! doesnt delete the branch if there are open PRs against it" do

data/test/models/pull_request_assignment_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Shipit
+  class PullRequestAssignmentTest < ActiveSupport::TestCase
+    setup do
+      @assignment = shipit_pull_request_assignments(:walrus_shopify_developers)
+    end
+
+    test "no duplicates are accepted" do
+      assignment = PullRequestAssignment.new(user: @assignment.user, pull_request: @assignment.pull_request)
+      refute assignment.valid?
+    end
+  end
+end

data/test/models/shipit/provisioning_handler/base_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Shipit
+  module ProvisioningHandler
+    class BaseTest < ActiveSupport::TestCase
+      test "provides a default #up handler" do
+        assert(
+          handler.respond_to?(:up),
+          "expected #{handler.class.name} to provide a default #up handler"
+        )
+      end
+
+      test "provides a default #down handler" do
+        assert(
+          handler.respond_to?(:down),
+          "expected #{handler.class.name} to provide a default #down handler"
+        )
+      end
+
+      test "provides a default #provision? handler" do
+        assert_equal true, handler.provision?
+      end
+
+      private
+
+      def handler
+        ProvisioningHandler::Base.new(mock("Stack"))
+      end
+    end
+  end
+end

data/test/models/shipit/provisioning_handler/unregistered_provisioning_handler_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Shipit
+  module ProvisioningHandler
+    class UnregisteredProvisioningHandlerTest < ActiveSupport::TestCase
+      test "#up stops transitions" do
+        stack = shipit_stacks(:shipit)
+        stack.update(provision_status: :deprovisioned)
+
+        assert_throws :halt do
+          UnregisteredProvisioningHandler.new(stack).up
+        end
+      end
+
+      test "#up locks the stack" do
+        stack = shipit_stacks(:shipit)
+        stack.update(provision_status: :deprovisioned)
+
+        assert_changes -> { stack.locked? }, from: false, to: true do
+          catch :halt do
+            UnregisteredProvisioningHandler.new(stack).up
+          end
+        end
+      end
+
+      test "#down stops transitions" do
+        stack = shipit_stacks(:shipit)
+        stack.update(provision_status: :deprovisioned)
+
+        assert_throws :halt do
+          UnregisteredProvisioningHandler.new(stack).down
+        end
+      end
+
+      test "#down prevents transitions" do
+        stack = shipit_stacks(:shipit)
+        stack.update(provision_status: :deprovisioned)
+
+        assert_changes -> { stack.locked? }, from: false, to: true do
+          catch :halt do
+            UnregisteredProvisioningHandler.new(stack).down
+          end
+        end
+      end
+    end
+  end
+end

data/test/models/shipit/provisioning_handler_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Shipit
+  class StackProvisioningHandlerTest < ActiveSupport::TestCase
+    teardown do
+      Shipit::ProvisioningHandler.reset_registry!
+    end
+
+    test "uses the no-op handler as default when no default handler is registered" do
+      assert_equal Shipit::ProvisioningHandler::Base, Shipit::ProvisioningHandler.default
+    end
+
+    test "allows registration of a default handler" do
+      mock_handler = mock("Mock Provisioning Handler")
+
+      Shipit::ProvisioningHandler.default = mock_handler
+
+      assert_equal mock_handler, Shipit::ProvisioningHandler.default
+    end
+
+    test "UnregisteredProvisioningHandler is returned when an attempt to fetch an unregistered handler is made" do
+      unregistered_handler = mock("Mock Provisioning Handler")
+
+      assert_equal(
+        Shipit::ProvisioningHandler::UnregisteredProvisioningHandler,
+        Shipit::ProvisioningHandler.fetch(unregistered_handler)
+      )
+    end
+
+    test "registers handlers so they become fetchable" do
+      mock_handler = mock("Mock Provisioning Handler")
+
+      Shipit::ProvisioningHandler.register(mock_handler)
+
+      assert_equal mock_handler, Shipit::ProvisioningHandler.fetch(mock_handler.to_s)
+    end
+
+    test "handlers are called during provisioning" do
+      stack = shipit_stacks(:review_stack)
+      stack.update(
+        provision_status: :deprovisioned
+      )
+      handler = Shipit::ProvisioningHandler.default
+
+      handler.any_instance.expects(:up)
+
+      assert stack.provision!, "stack should have provisioned."
+    end
+
+    test "handlers are called during deprovisioning" do
+      stack = shipit_stacks(:review_stack)
+      stack.update(
+        provision_status: :provisioned
+      )
+      handler = Shipit::ProvisioningHandler.default
+
+      handler.any_instance.expects(:down)
+
+      assert stack.deprovision!, "stack should have deprovisioned."
+    end
+  end
+end