shipit-engine 0.27.1 → 0.28.0

data/test/models/rollbacks_test.rb

@@ -19,10 +19,14 @@ module Shipit
       refute @rollback.supports_rollback?
     end
 
-    test "when a rollback succeed reverted commits are locked" do
-      @stack.tasks.where.not(id: shipit_tasks(:shipit_complete).id).delete_all
+    test "when a rollback succeeds reverted commits are locked" do
+      @stack.tasks.where.not(id: shipit_tasks(:shipit_complete, :shipit).map(&:id)).delete_all
 
+      # Adjust the from/to commits of the two deploys to be in sequence (Any-3, 3-4)
+      to_revert_to = @stack.deploys.success.second_to_last
       deploy = @stack.deploys.success.last
+      to_revert_to.until_commit = deploy.since_commit
+      to_revert_to.save
       reverted_commit = deploy.until_commit
 
       @stack.commits.create!(
@@ -35,23 +39,25 @@ module Shipit
       )
 
       expected = [
-        ['Revert "Merge pull request #7 from shipit-engine/yoloshipit"', false],
-        ["whoami", false],
-        ['fix all the things', false],
+        ['Revert "Merge pull request #7 from shipit-engine/yoloshipit"', false, nil],
+        ["whoami", false, nil],
+        ['fix all the things', false, nil],
       ]
-      assert_equal expected, @stack.undeployed_commits.map { |c| [c.title, c.locked?] }
+      assert_equal(expected, @stack.undeployed_commits.map { |c| [c.title, c.locked?, c.lock_author_id] })
 
       rollback = deploy.trigger_revert
       rollback.run!
       rollback.complete!
 
+      user_id = reverted_commit.author.id
       expected = [
-        ['Revert "Merge pull request #7 from shipit-engine/yoloshipit"', false],
-        ["whoami", true],
-        ['fix all the things', true],
-        ['yoloshipit!', true],
+        ['Revert "Merge pull request #7 from shipit-engine/yoloshipit"', false, nil],
+        ["whoami", true, user_id],
+        ['fix all the things', true, user_id],
+        ['yoloshipit!', true, user_id],
       ]
-      assert_equal expected, @stack.undeployed_commits.map { |c| [c.title, c.locked?] }
+
+      assert_equal(expected, @stack.undeployed_commits.map { |c| [c.title, c.locked?, c.lock_author_id] })
     end
   end
 end

data/test/models/stacks_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'securerandom'
 
 module Shipit
   class StacksTest < ActiveSupport::TestCase
@@ -132,6 +133,15 @@ module Shipit
       assert_instance_of Deploy, deploy
     end
 
+    test "#trigger_deploy doesn't enqueues a deploy job when run_now is provided" do
+      @stack.deploys.destroy_all
+      Deploy.any_instance.expects(:run_now!).once
+
+      last_commit = shipit_commits(:third)
+      deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new, run_now: true)
+      assert_instance_of Deploy, deploy
+    end
+
     test "#trigger_deploy marks the deploy as `ignored_safeties` if the commit wasn't deployable" do
       last_commit = shipit_commits(:fifth)
       refute_predicate last_commit, :deployable?
@@ -262,6 +272,16 @@ module Shipit
       assert @stack.active_task?
     end
 
+    test ".run_deploy_in_foreground triggers a deploy" do
+      stack = Stack.create!(repo_owner: 'foo', repo_name: 'bar', environment: 'production')
+      commit = shipit_commits(:first)
+      stack.commits << commit
+
+      Stack.any_instance.expects(:trigger_deploy).with(anything, anything, env: {}, force: true, run_now: true)
+
+      Stack.run_deploy_in_foreground(stack: stack.to_param, revision: commit.sha)
+    end
+
     test "#active_task? is memoized" do
       assert_queries(1) do
         10.times { @stack.active_task? }
@@ -330,15 +350,19 @@ module Shipit
     end
 
     test "locking the stack triggers a webhook" do
-      expect_hook(:lock, @stack, locked: true, stack: @stack) do
+      expect_hook(:lock, @stack, locked: true, lock_details: nil, stack: @stack) do
         @stack.update(lock_reason: "Just for fun", lock_author: shipit_users(:walrus))
       end
     end
 
     test "unlocking the stack triggers a webhook" do
-      @stack.update(lock_reason: "Just for fun", lock_author: shipit_users(:walrus))
-      expect_hook(:lock, @stack, locked: false, stack: @stack) do
-        @stack.update(lock_reason: nil)
+      freeze_time do
+        time = Time.current
+        @stack.update(lock_reason: "Just for fun", lock_author: shipit_users(:walrus))
+        travel 1.day
+        expect_hook(:lock, @stack, locked: false, lock_details: {from: time, until: Time.current}, stack: @stack) do
+          @stack.update(lock_reason: nil)
+        end
       end
     end
 
@@ -493,6 +517,7 @@ module Shipit
       deploy = @stack.trigger_deploy(shipit_commits(:first), AnonymousUser.new)
       deploy.run!
       deploy.complete!
+      @stack.reload
 
       assert_predicate @stack, :deployable?
       assert_predicate @stack, :deployed_too_recently?
@@ -548,6 +573,39 @@ module Shipit
       end
     end
 
+    test "#trigger_continuous_delivery enqueues deployment ref update job" do
+      @stack = shipit_stacks(:shipit_canaries)
+      shipit_tasks(:canaries_running).delete
+
+      assert_no_enqueued_jobs(only: Shipit::UpdateGithubLastDeployedRefJob) do
+        assert_no_difference -> { Deploy.count } do
+          @stack.trigger_continuous_delivery
+        end
+      end
+
+      assert_enqueued_with(job: Shipit::UpdateGithubLastDeployedRefJob, args: [@stack]) do
+        @stack.last_active_task.complete!
+      end
+    end
+
+    test "#trigger_continuous_delivery executes ref update job with correct sha" do
+      @stack = shipit_stacks(:shipit_canaries)
+      shipit_tasks(:canaries_running).delete
+
+      assert_no_enqueued_jobs(only: Shipit::UpdateGithubLastDeployedRefJob) do
+        assert_no_difference -> { Deploy.count } do
+          @stack.trigger_continuous_delivery
+        end
+      end
+
+      desired_last_commit_sha = @stack.last_active_task.until_commit.sha
+      Shipit.github.api.expects(:update_ref).with(anything, anything, desired_last_commit_sha).returns("test")
+
+      perform_enqueued_jobs(only: Shipit::UpdateGithubLastDeployedRefJob) do
+        @stack.last_active_task.complete!
+      end
+    end
+
     test "#trigger_continuous_delivery trigger a deploy if all conditions are met" do
       @stack.tasks.delete_all
       assert_predicate @stack, :deployable?
@@ -669,5 +727,160 @@ module Shipit
       Rails.cache.clear
       refute_predicate @stack, :ci_enabled?
     end
+
+    test "#undeployed_commits returns list of commits newer than last deployed commit" do
+      @stack = shipit_stacks(:shipit_undeployed)
+      last_deployed_commit = @stack.last_deployed_commit
+      commits = @stack.undeployed_commits
+
+      assert_equal @stack.undeployed_commits_count, commits.size
+
+      commits.each { |c| assert c.id > last_deployed_commit.id }
+    end
+
+    test "#next_expected_commit_to_deploy returns nil if there is no deployable commit" do
+      commits = @stack.undeployed_commits
+
+      assert !commits.empty?
+      commits.each { |c| refute_predicate c, :deployable? }
+
+      assert_nil @stack.next_expected_commit_to_deploy(commits: commits)
+    end
+
+    test "#next_expected_commit_to_deploy returns nil if all deployable commits are active" do
+      @stack = shipit_stacks(:shipit_undeployed)
+      commits = @stack.undeployed_commits.select(&:active?)
+
+      assert !commits.empty?
+      commits.each { |c| assert_predicate c, :active? }
+
+      assert_nil @stack.next_expected_commit_to_deploy(commits: commits)
+    end
+
+    test "#next_expected_commit_to_deploy returns nil if there are no commits" do
+      assert_nil @stack.next_expected_commit_to_deploy(commits: [])
+    end
+
+    test "#next_expected_commit_to_deploy returns the most recent non-active deployable commit limited by maximum commits per deploy" do
+      @stack = shipit_stacks(:shipit_undeployed)
+      commits = @stack.undeployed_commits
+
+      assert !commits.empty?
+
+      most_recent_limited = @stack.next_expected_commit_to_deploy(commits: commits)
+      most_recent = commits.find { |c| !c.active? && c.deployable? }
+
+      assert most_recent.id > most_recent_limited.id
+      assert_equal @stack.maximum_commits_per_deploy, commits.find_index(most_recent_limited) + 1
+    end
+
+    test "#async_refresh_deployed_revision suppresses and logs raised exception" do
+      error_message = "Error message"
+
+      Rails.logger.expects(:warn).with("Failed to dispatch FetchDeployedRevisionJob: [StandardError] #{error_message}")
+      @stack.expects(:async_refresh_deployed_revision!).raises(StandardError.new(error_message))
+
+      @stack.async_refresh_deployed_revision
+    end
+
+    test "#lock_reverted_commits! locks all commits between the original and reverted commits" do
+      reverted_commit = @stack.undeployed_commits.first
+      revert_author = shipit_users(:bob)
+      generate_revert_commit(stack: @stack, reverted_commit: reverted_commit, author: revert_author)
+      @stack.reload
+
+      assert_equal(
+        [
+          ['Revert "whoami"', false, nil],
+          ["whoami", false, nil],
+          ["fix all the things", false, nil],
+        ],
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+      )
+
+      @stack.lock_reverted_commits!
+      @stack.reload
+
+      assert_equal(
+        [
+          ['Revert "whoami"', false, nil],
+          ["whoami", true, revert_author.id],
+          ["fix all the things", false, nil],
+        ],
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+      )
+    end
+
+    test "#lock_reverted_commits! is a no-op if the reverted commit has already shipped" do
+      reverted_commit = shipit_commits(:first)
+      revert_author = shipit_users(:bob)
+      generate_revert_commit(stack: @stack, reverted_commit: reverted_commit, author: revert_author)
+      @stack.reload
+
+      initial_state = [
+        ['Revert "lets go"', false, nil],
+        ["whoami", false, nil],
+        ["fix all the things", false, nil],
+      ]
+
+      assert_equal(
+        initial_state,
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+      )
+
+      @stack.lock_reverted_commits!
+      @stack.reload
+
+      assert_equal(
+        initial_state,
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+      )
+    end
+
+    test "#lock_reverted_commits! handles multiple reverts" do
+      first_reverted_commit = @stack.undeployed_commits.last
+      second_reverted_commit = @stack.undeployed_commits.first
+      first_revert_author = shipit_users(:bob)
+      second_revert_author = shipit_users(:walrus)
+      generate_revert_commit(stack: @stack, reverted_commit: first_reverted_commit, author: first_revert_author)
+      generate_revert_commit(stack: @stack, reverted_commit: second_reverted_commit, author: second_revert_author)
+      @stack.reload
+
+      assert_equal(
+        [
+          ['Revert "whoami"', false, nil],
+          ['Revert "fix all the things"', false, nil],
+          ["whoami", false, nil],
+          ["fix all the things", false, nil],
+        ],
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+      )
+
+      @stack.lock_reverted_commits!
+      @stack.reload
+
+      assert_equal(
+        [
+          ['Revert "whoami"', false, nil],
+          ['Revert "fix all the things"', true, second_revert_author.id],
+          ["whoami", true, first_revert_author.id],
+          ["fix all the things", true, first_revert_author.id],
+        ],
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+      )
+    end
+
+    private
+
+    def generate_revert_commit(stack:, reverted_commit:, author: reverted_commit.author)
+      stack.commits.create(
+        sha: SecureRandom.hex(20),
+        message: "Revert \"#{reverted_commit.message_header}\"",
+        author: author,
+        committer: author,
+        authored_at: Time.zone.now,
+        committed_at: Time.zone.now,
+      )
+    end
   end
 end

data/test/models/tasks_test.rb

@@ -17,5 +17,18 @@ module Shipit
       task = shipit_tasks(:shipit_with_title_parsing_issue)
       assert_equal 'This task (title: Using the %{WRONG_VARIABLE_NAME}) cannot be shown due to an incorrect variable name. Check your shipit.yml file', task.title
     end
+
+    test "#write sends line-buffered output to task logger" do
+      task = shipit_tasks(:shipit)
+
+      mock_task_logger = mock.tap do |m|
+        m.expects(:info).with("[shipit-engine#1] hello").once
+        m.expects(:info).never
+      end
+
+      Shipit.stubs(:task_logger).returns(mock_task_logger)
+
+      task.write("hello\nworld")
+    end
   end
 end

data/test/models/undeployed_commits_test.rb

@@ -4,7 +4,7 @@ module Shipit
   class UndeployedCommitsTest < ActiveSupport::TestCase
     setup do
       @real_commit = shipit_commits(:cyclimse_first)
-      @commit = UndeployedCommit.new(@real_commit, 0)
+      @commit = UndeployedCommit.new(@real_commit, index: 0)
       @stack = @commit.stack
     end
 
@@ -34,11 +34,70 @@ module Shipit
     end
 
     test "#deploy_discouraged? returns true if the commit index is equal or bigger then the maximum commits per deploy" do
-      @commit = UndeployedCommit.new(@real_commit, 2)
+      @commit = UndeployedCommit.new(@real_commit, index: 2)
       assert_equal 2, @stack.maximum_commits_per_deploy
       assert_predicate @commit, :deploy_discouraged?
     end
 
+    test "#expected_to_be_deployed? returns true if the stack has continuous deployment enabled, next expected commit to deploy id is greater or equals to the commit id and commit is not active" do
+      commit = shipit_commits(:undeployed_4)
+      next_expected_commit_to_deploy = commit.stack.next_expected_commit_to_deploy
+      undeployed_commit = UndeployedCommit.new(commit, index: 1, next_expected_commit_to_deploy: next_expected_commit_to_deploy)
+
+      refute_predicate next_expected_commit_to_deploy, :nil?
+      assert_predicate undeployed_commit.stack, :continuous_deployment
+      assert next_expected_commit_to_deploy.id >= undeployed_commit.id
+      refute_predicate undeployed_commit, :active?
+
+      assert_predicate undeployed_commit, :expected_to_be_deployed?
+    end
+
+    test "#expected_to_be_deployed? returns false if the stack has continuous deployment disabled" do
+      commit = shipit_commits(:cyclimse_first)
+      next_expected_commit_to_deploy = commit.stack.next_expected_commit_to_deploy
+      undeployed_commit = UndeployedCommit.new(commit, index: 1, next_expected_commit_to_deploy: next_expected_commit_to_deploy)
+
+      refute_predicate next_expected_commit_to_deploy, :nil?
+      refute_predicate undeployed_commit.stack, :continuous_deployment
+      assert next_expected_commit_to_deploy.id >= undeployed_commit.id
+      refute_predicate undeployed_commit, :active?
+
+      refute_predicate undeployed_commit, :expected_to_be_deployed?
+    end
+
+    test "#expected_to_be_deployed? returns false if the commit is part of the active task" do
+      commit = shipit_commits(:undeployed_3)
+      next_expected_commit_to_deploy = commit.stack.next_expected_commit_to_deploy
+      undeployed_commit = UndeployedCommit.new(commit, index: 1, next_expected_commit_to_deploy: next_expected_commit_to_deploy)
+
+      refute_predicate next_expected_commit_to_deploy, :nil?
+      assert_predicate undeployed_commit.stack, :continuous_deployment
+      assert next_expected_commit_to_deploy.id >= undeployed_commit.id
+      assert_predicate undeployed_commit, :active?
+
+      refute_predicate undeployed_commit, :expected_to_be_deployed?
+    end
+
+    test "#expected_to_be_deployed? returns false if there is no commit to deploy" do
+      commit = shipit_commits(:undeployed_3)
+      undeployed_commit = UndeployedCommit.new(commit, index: 1, next_expected_commit_to_deploy: nil)
+
+      refute_predicate undeployed_commit, :expected_to_be_deployed?
+    end
+
+    test "#expected_to_be_deployed? returns false if the commit has an id greater than next commit to deploy" do
+      commit = shipit_commits(:undeployed_7)
+      next_expected_commit_to_deploy = commit.stack.next_expected_commit_to_deploy
+      undeployed_commit = UndeployedCommit.new(commit, index: 1, next_expected_commit_to_deploy: next_expected_commit_to_deploy)
+
+      refute_predicate next_expected_commit_to_deploy, :nil?
+      assert_predicate undeployed_commit.stack, :continuous_deployment
+      assert undeployed_commit.id > next_expected_commit_to_deploy.id
+      refute_predicate undeployed_commit, :active?
+
+      refute_predicate undeployed_commit, :expected_to_be_deployed?
+    end
+
     test "#deploy_state returns `allowed` by default" do
       assert_equal 'allowed', @commit.deploy_state
     end
@@ -73,7 +132,7 @@ module Shipit
       blocking_commit.statuses.delete_all
       assert_predicate blocking_commit, :blocking?
 
-      commit = UndeployedCommit.new(shipit_commits(:soc_third), 0)
+      commit = UndeployedCommit.new(shipit_commits(:soc_third), index: 0)
       assert_equal 'blocked', commit.deploy_state
     end
 

data/test/test_helper.rb

@@ -42,7 +42,6 @@ class ActiveSupport::TestCase
 
   setup do
     @routes = Shipit::Engine.routes
-    Process.stubs(:kill)
     Shipit.github.api.stubs(:login).returns('shipit')
   end
 

data/test/unit/command_test.rb

@@ -66,5 +66,60 @@ module Shipit
       end
       assert_equal '/etc/passwd: Permission denied', error.message
     end
+
+    test 'sets code and message correctly on success' do
+      command = Command.new('true', chdir: '.')
+      assert_nil command.code
+      command.run
+      refute_predicate command, :running?
+      assert_predicate command.code, :zero?
+      assert_equal 'terminated successfully', command.termination_status
+    end
+
+    test 'sets code and message correctly on error' do
+      command = Command.new('false', chdir: '.')
+      assert_nil command.code
+      command.run
+      refute_predicate command, :running?
+      assert_predicate command.code, :nonzero?
+      assert_equal 'terminated with exit status 1', command.termination_status
+    end
+
+    test 'handles externally signalled commands correctly' do
+      command = Command.new('sleep 10', chdir: '.')
+      t = command_signaller_thread(command)
+      command.run
+      assert t.join, "subprocess wasn't signalled"
+      assert_predicate command, :signaled?
+      refute_predicate command, :running?
+      assert_nil command.code
+      assert_equal 'terminated with KILL signal', command.termination_status
+    end
+
+    test 'reports timedout command correctly' do
+      command = Command.new('sleep 10', chdir: '.', default_timeout: 0.5)
+      assert_raises(Command::TimedOut) { command.run }
+      assert_predicate command, :signaled?
+      refute_predicate command, :running?
+      assert_nil command.code
+      assert_equal 'timed out and terminated with INT signal', command.termination_status
+    end
+
+    private
+
+    def command_signaller_thread(command, signal: 'KILL')
+      Thread.new do
+        signalled = false
+        20.times do
+          if command.running?
+            Process.kill(signal, command.pid)
+            signalled = true
+            break
+          end
+          sleep 0.1
+        end
+        signalled
+      end
+    end
   end
 end