shipit-engine 0.33.0 → 0.34.0

data/test/models/shipit/check_run_test.rb

@@ -9,13 +9,130 @@ module Shipit
       @check_run = shipit_check_runs(:second_pending_travis)
     end
 
+    test ".create_or_update_from_github! updates successfully" do
+      completed_at = Time.now
+      assert_difference -> { @commit.check_runs.count }, +1 do
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(conclusion: nil, completed_at: '2021-04-29T18:05:12Z')
+        )
+      end
+
+      assert_no_enqueued_jobs(only: RefreshCheckRunsJob) do
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(conclusion: 'success', completed_at: completed_at + 1.minute)
+        )
+      end
+
+      assert_equal 'success', @commit.check_runs.last.conclusion
+    end
+
+    test ".create_or_update_from_github! updates successfully using latest timestamp" do
+      completed_at = Time.now
+      assert_difference -> { @commit.check_runs.count }, +1 do
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(conclusion: 'success', completed_at: completed_at)
+        )
+      end
+
+      assert_enqueued_with(job: RefreshCheckRunsJob) do
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(conclusion: nil, completed_at: completed_at)
+        )
+      end
+
+      # RefreshCheckRunsJob would enqueue if the timestamp was older/equivalent
+      assert_no_enqueued_jobs(only: RefreshCheckRunsJob) do
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(
+            conclusion: 'action_required',
+            completed_at: completed_at,
+            started_at: completed_at + 1.minute,
+          ),
+        )
+      end
+
+      assert_equal 'action_required', @commit.check_runs.last.conclusion
+    end
+
     test ".create_or_update_from_github! is idempotent" do
+      completed_at = Time.now
+      assert_difference -> { @commit.check_runs.count }, +1 do
+        @commit.check_runs.create_or_update_from_github!(@stack.id, github_check_run(completed_at: completed_at))
+      end
+
+      assert_no_difference -> { @commit.check_runs.count } do
+        assert_no_enqueued_jobs(only: RefreshCheckRunsJob) do
+          @commit.check_runs.create_or_update_from_github!(@stack.id, github_check_run(completed_at: completed_at))
+        end
+      end
+    end
+
+    test ".create_or_update_from_github! enqueues refresh and updates record when new statuses have stale timestamps" do
+      completed_at = Time.now
       assert_difference -> { @commit.check_runs.count }, +1 do
-        @commit.check_runs.create_or_update_from_github!(@stack.id, github_check_run)
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(conclusion: 'success', completed_at: completed_at)
+        )
+      end
+
+      assert_equal 'success', @commit.check_runs.last.conclusion
+
+      updated_conclusion = 'action_required'
+      updated_check_run = github_check_run(conclusion: updated_conclusion, completed_at: completed_at - 1.minute)
+
+      assert_no_difference -> { @commit.check_runs.count } do
+        assert_enqueued_with(job: RefreshCheckRunsJob) do
+          @commit.check_runs.create_or_update_from_github!(@stack.id, updated_check_run)
+        end
+      end
+
+      assert_equal updated_conclusion, @commit.check_runs.last.conclusion
+
+      # If the refresh returns the same data, then the record should end up the same, but no refresh should be necessary
+      assert_no_difference -> { @commit.check_runs.count } do
+        assert_no_enqueued_jobs(only: RefreshCheckRunsJob) do
+          @commit.check_runs.create_or_update_from_github!(@stack.id, updated_check_run)
+        end
       end
 
+      assert_equal updated_conclusion, @commit.check_runs.last.conclusion
+    end
+
+    test ".create_or_update_from_github! does not enqueues refresh when old statuses has no timestamp" do
+      completed_at = Time.now
+      assert_difference -> { @commit.check_runs.count }, +1 do
+        @commit.check_runs.create_or_update_from_github!(
+          @stack.id,
+          github_check_run(conclusion: 'success', completed_at: completed_at)
+        )
+      end
+
+      @commit.check_runs.last.update!(github_updated_at: nil)
+
+      assert_no_difference -> { @commit.check_runs.count } do
+        assert_no_enqueued_jobs(only: RefreshCheckRunsJob) do
+          @commit.check_runs.create_or_update_from_github!(
+            @stack.id,
+            github_check_run(conclusion: nil, completed_at: completed_at - 1.minute)
+          )
+        end
+      end
+    end
+
+    test ".create_or_update_from_github! enqueues refresh when new statuses have no timestamps" do
       assert_no_difference -> { @commit.check_runs.count } do
-        @commit.check_runs.create_or_update_from_github!(@stack.id, github_check_run)
+        assert_enqueued_with(job: RefreshCheckRunsJob, args: [stack_id: @stack.id]) do
+          @commit.check_runs.create_or_update_from_github!(
+            @stack.id,
+            github_check_run(conclusion: nil, completed_at: nil, started_at: nil)
+          )
+        end
       end
     end
 
@@ -36,16 +153,18 @@ module Shipit
 
     private
 
-    def github_check_run
-      @github_check_run ||= OpenStruct.new(
+    def github_check_run(conclusion: 'success', completed_at: Time.now, started_at: Time.now - 1.minute)
+      OpenStruct.new(
         id: 424_242,
-        conclusion: 'success',
+        conclusion: conclusion,
         output: OpenStruct.new(
           description: 'This is a description',
         ),
         name: 'Test Suite',
         html_url: 'http://example.com/run',
         details_url: 'http://example.com/details',
+        completed_at: completed_at,
+        started_at: started_at,
       )
     end
   end

data/test/models/shipit/review_stack_test.rb

@@ -9,12 +9,20 @@ module Shipit
     end
 
     test "clearing stale caches" do
-      # Asserting that :archived_25hours_ago, :archived_30minutes_ago and :shipit are not queued.
-      assert_enqueued_jobs 1 do
-        assert_enqueued_with(job: Shipit::ClearGitCacheJob, args: [shipit_stacks(:archived_6hours_ago)]) do
-          ReviewStack.clear_stale_caches
-        end
-      end
+      stale_stack = shipit_stacks(:archived_6hours_ago)
+      FileUtils.mkdir_p(stale_stack.base_path)
+      path = File.join(stale_stack.base_path, 'foo')
+      File.write(path, 'bar')
+
+      not_stale_stack = shipit_stacks(:archived_30minutes_ago)
+      FileUtils.mkdir_p(not_stale_stack.base_path)
+      path = File.join(not_stale_stack.base_path, 'foo')
+      File.write(path, 'bar')
+
+      ReviewStack.clear_stale_caches
+
+      refute File.exist?(stale_stack.base_path)
+      assert File.exist?(not_stale_stack.base_path)
     end
 
     test "creating a review stack emits a hook" do
@@ -55,5 +63,29 @@ module Shipit
       assert_equal stack.env["WIP"], "true"
       assert_equal stack.env["BUG"], "true"
     end
+
+    test "#unarchive! triggers a GithubSync job" do
+      stack = shipit_stacks(:review_stack)
+      assert_no_enqueued_jobs(only: GithubSyncJob) do
+        stack.archive!(shipit_users(:codertocat))
+      end
+
+      assert_enqueued_with(job: GithubSyncJob, args: [stack_id: stack.id]) do
+        stack.unarchive!
+      end
+    end
+
+    test "#trigger_continuous_delivery does not enqueue deployment ref update job" do
+      Shipit.stubs(:update_latest_deployed_ref).returns(true)
+      @stack = shipit_stacks(:review_stack)
+      assert_no_enqueued_jobs(only: Shipit::UpdateGithubLastDeployedRefJob) do
+        task = @stack.trigger_continuous_delivery
+        task.update!(status: "running")
+      end
+
+      assert_no_enqueued_jobs(only: Shipit::UpdateGithubLastDeployedRefJob) do
+        @stack.last_active_task.complete!
+      end
+    end
   end
 end

data/test/models/shipit/stacks_test.rb

@@ -10,10 +10,20 @@ module Shipit
       GithubHook.any_instance.stubs(:teardown!)
     end
 
-    test "branch defaults to master" do
+    test "branch defaults to default branch name" do
       @stack.branch = ""
+      Shipit.github.api.expects(:repo).with("shopify/shipit-engine").returns(
+        Struct.new(:default_branch).new('something')
+      )
       assert @stack.save
-      assert_equal 'master', @stack.branch
+      assert_equal 'something', @stack.branch
+    end
+
+    test "branch is blank when default cannot be determined" do
+      @stack.branch = ""
+      Shipit.github.api.expects(:repo).raises(Octokit::NotFound)
+      assert_not @stack.save
+      assert_nil @stack.branch
     end
 
     test "environment defaults to production" do
@@ -201,7 +211,7 @@ module Shipit
 
     test "#create queues a GithubSyncJob" do
       assert_enqueued_with(job: GithubSyncJob) do
-        Stack.create!(repository: shipit_repositories(:rails))
+        Stack.create!(repository: shipit_repositories(:rails), branch: 'main')
       end
     end
 
@@ -252,6 +262,7 @@ module Shipit
       stack = Stack.create!(
         repository: Repository.new(owner: "foo", name: "bar"),
         environment: 'production',
+        branch: 'main',
       )
       commit = shipit_commits(:first)
       stack.commits << commit
@@ -362,13 +373,24 @@ module Shipit
     end
 
     test "the git cache lock prevent concurrent access to the git cache" do
-      @stack.acquire_git_cache_lock do
+      second_stack = Shipit::Stack.find(@stack.id)
+      second_stack.acquire_git_cache_lock do
         assert_raises Flock::TimeoutError do
           @stack.acquire_git_cache_lock(timeout: 0.1) {}
         end
       end
     end
 
+    test "the git cache lock is reentrant if called on the same Stack instance" do
+      called = false
+      @stack.acquire_git_cache_lock(timeout: 0.01) do
+        @stack.acquire_git_cache_lock(timeout: 0.01) do
+          called = true
+        end
+      end
+      assert called
+    end
+
     test "the git cache lock is scoped to the stack" do
       called = false
       shipit_stacks(:cyclimse).acquire_git_cache_lock do
@@ -926,6 +948,22 @@ module Shipit
       )
     end
 
+    test "#unarchive! triggers a GithubSync job" do
+      assert_no_enqueued_jobs(only: GithubSyncJob) do
+        @stack.archive!(shipit_users(:codertocat))
+      end
+
+      assert_enqueued_with(job: GithubSyncJob, args: [stack_id: @stack.id]) do
+        @stack.unarchive!
+      end
+    end
+
+    test "#update that changes the branch name triggers a GithubSync job" do
+      assert_enqueued_with(job: GithubSyncJob, args: [stack_id: @stack.id]) do
+        @stack.update!(branch: 'test')
+      end
+    end
+
     private
 
     def generate_revert_commit(stack:, reverted_commit:, author: reverted_commit.author)

data/test/models/shipit/webhooks/handlers/pull_request/review_stack_adapter_test.rb

@@ -19,6 +19,30 @@ module Shipit
             review_stack.unarchive!
           end
 
+          test "unarchive! syncs with GitHub" do
+            stack = create_archived_stack
+            review_stack = Shipit::Webhooks::Handlers::PullRequest::ReviewStackAdapter.new(
+              params_for(stack),
+              scope: stack.repository.stacks
+            )
+
+            assert_enqueued_with(job: GithubSyncJob, args: [stack_id: stack.id]) do
+              review_stack.unarchive!
+            end
+          end
+
+          test "unarchive! schedules provisioning" do
+            stack = create_archived_stack
+            review_stack = Shipit::Webhooks::Handlers::PullRequest::ReviewStackAdapter.new(
+              params_for(stack),
+              scope: stack.repository.stacks
+            )
+
+            assert_changes -> { stack.reload.awaiting_provision }, from: false, to: true do
+              review_stack.unarchive!
+            end
+          end
+
           test "archive! on an archived stack is a no-op" do
             stack = create_archived_stack
             review_stack = Shipit::Webhooks::Handlers::PullRequest::ReviewStackAdapter.new(

data/test/models/tasks_test.rb

@@ -88,5 +88,27 @@ module Shipit
       task_with_zero_retries = shipit_tasks(:shipit_restart)
       refute_predicate task_with_zero_retries, :retries_configured?
     end
+
+    test ".due_for_rollup includes tasks in successful terminal states" do
+      task = shipit_tasks(:shipit)
+      task.update(
+        rolled_up: false,
+        created_at: (60 + 1).minutes.ago.to_s(:db),
+        status: "success",
+      )
+
+      assert_includes Shipit::Task.due_for_rollup, task
+    end
+
+    test ".due_for_rollup includes tasks in unsuccessful terminal states" do
+      task = shipit_tasks(:shipit)
+      task.update(
+        rolled_up: false,
+        created_at: (60 + 1).minutes.ago.to_s(:db),
+        status: "error",
+      )
+
+      assert_includes Shipit::Task.due_for_rollup, task
+    end
   end
 end

data/test/test_helper.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 ENV["RAILS_ENV"] ||= "test"
 
+if Warning.respond_to?(:[]=)
+  Warning[:deprecated] = true
+end
+
 require 'simplecov'
 SimpleCov.start('rails') do
   enable_coverage :branch
@@ -32,6 +36,17 @@ begin
 rescue LoadError
 end
 
+# FIXME: We need to get rid of active_model_serializers
+# This is a monkey patch for Ruby 2.7+ compatibility
+module ActionController
+  module SerializationAssertions
+    def process(*, **)
+      @serializers = Hash.new(0)
+      super
+    end
+  end
+end
+
 module ActiveSupport
   class TestCase
     include PayloadsHelper

data/test/unit/anonymous_user_serializer_test.rb

@@ -8,7 +8,7 @@ module Shipit
       serializer = ActiveModel::Serializer.serializer_for(user)
       assert_equal AnonymousUserSerializer, serializer
       serialized = serializer.new(user).to_json
-      assert_json("anonymous", true, document: serialized)
+      assert_json_document(serialized, "anonymous", true)
     end
   end
 end

data/test/unit/command_test.rb

@@ -34,6 +34,11 @@ module Shipit
       ENV['SHIPIT_TEST'] = previous
     end
 
+    test "#env cast to strings except for `nil`" do
+      command = Command.new('echo foo', env: { 'SOME_PATH' => Pathname.new('/foo'), 'HOST' => nil }, chdir: '.')
+      assert_equal({ 'SOME_PATH' => '/foo', 'HOST' => nil }, command.env)
+    end
+
     test "#timeout is 5 minutes by default" do
       command = Command.new('cap $LANG deploy', env: { 'ENVIRONMENT' => 'production' }, chdir: '.')
       assert_equal 5.minutes.to_i, command.timeout

data/test/unit/commit_serializer_test.rb

@@ -10,7 +10,7 @@ module Shipit
       assert_equal CommitSerializer, serializer
       serialized = serializer.new(commit).to_json
 
-      assert_json("author.name", commit.author.name, document: serialized)
+      assert_json_document(serialized, "author.name", commit.author.name)
     end
   end
 end

data/test/unit/deploy_commands_test.rb

@@ -4,8 +4,9 @@ require 'test_helper'
 module Shipit
   class DeployCommandsTest < ActiveSupport::TestCase
     def setup
-      @stack = shipit_stacks(:shipit)
       @deploy = shipit_deploys(:shipit_pending)
+      @stack = @deploy.stack
+      @stack.stubs(:clear_git_cache!)
       @commands = DeployCommands.new(@deploy)
       @deploy_spec = stub(
         dependencies_steps!: ['bundle install --some-args'],
@@ -21,42 +22,97 @@ module Shipit
     end
 
     test "#fetch calls git fetch if repository cache already exist" do
-      Dir.expects(:exist?).with(@stack.git_path).returns(true)
+      @stack.git_path.stubs(:exist?).returns(true)
+      @stack.git_path.stubs(:empty?).returns(false)
+
       command = @commands.fetch
+
       assert_equal %w(git fetch origin --tags master), command.args
     end
 
     test "#fetch calls git fetch in git_path directory if repository cache already exist" do
-      Dir.expects(:exist?).with(@stack.git_path).returns(true)
+      @stack.git_path.stubs(:exist?).returns(true)
+      @stack.git_path.stubs(:empty?).returns(false)
+
       command = @commands.fetch
-      assert_equal @stack.git_path, command.chdir
+
+      assert_equal @stack.git_path.to_s, command.chdir
     end
 
     test "#fetch calls git clone if repository cache do not exist" do
-      Dir.expects(:exist?).with(@stack.git_path).returns(false)
+      @stack.git_path.stubs(:exist?).returns(false)
+
+      command = @commands.fetch
+
+      expected = %W(git clone --single-branch --recursive --branch master #{@stack.repo_git_url} #{@stack.git_path})
+      assert_equal expected, command.args.map(&:to_s)
+    end
+
+    test "#fetch calls git clone if repository cache is empty" do
+      @stack.git_path.stubs(:exist?).returns(true)
+      @stack.git_path.stubs(:empty?).returns(true)
+
+      command = @commands.fetch
+
+      expected = %W(git clone --single-branch --recursive --branch master #{@stack.repo_git_url} #{@stack.git_path})
+      assert_equal expected, command.args
+    end
+
+    test "#fetch calls git clone if repository cache corrupt" do
+      @stack.git_path.stubs(:exist?).returns(true)
+      @stack.git_path.stubs(:empty?).returns(false)
+      StackCommands.any_instance.expects(:git_cmd_succeeds?)
+        .with(@stack.git_path)
+        .returns(false)
+
       command = @commands.fetch
+
+      expected = %W(git clone --single-branch --recursive --branch master #{@stack.repo_git_url} #{@stack.git_path})
+      assert_equal expected, command.args
+    end
+
+    test "#fetch clears a corrupted git stash before cloning" do
+      @stack.expects(:clear_git_cache!)
+      @stack.git_path.stubs(:exist?).returns(true)
+      @stack.git_path.stubs(:empty?).returns(false)
+      StackCommands.any_instance.expects(:git_cmd_succeeds?)
+        .with(@stack.git_path)
+        .returns(false)
+
+      command = @commands.fetch
+
       expected = %W(git clone --single-branch --recursive --branch master #{@stack.repo_git_url} #{@stack.git_path})
       assert_equal expected, command.args
     end
 
     test "#fetch does not use --single-branch if git is outdated" do
-      Dir.expects(:exist?).with(@stack.git_path).returns(false)
+      @stack.git_path.stubs(:exist?).returns(false)
       StackCommands.stubs(git_version: Gem::Version.new('1.7.2.30'))
+
       command = @commands.fetch
+
       expected = %W(git clone --recursive --branch master #{@stack.repo_git_url} #{@stack.git_path})
-      assert_equal expected, command.args
+      assert_equal expected, command.args.map(&:to_s)
     end
 
     test "#fetch calls git fetch in base_path directory if repository cache do not exist" do
-      Dir.expects(:exist?).with(@stack.git_path).returns(false)
+      @stack.git_path.stubs(:exist?).returns(false)
+
       command = @commands.fetch
-      assert_equal @stack.deploys_path, command.chdir
+
+      assert_equal @stack.deploys_path.to_s, command.chdir
     end
 
     test "#fetch merges Shipit.env in ENVIRONMENT" do
       Shipit.stubs(:env).returns("SPECIFIC_CONFIG" => 5)
       command = @commands.fetch
-      assert_equal 5, command.env["SPECIFIC_CONFIG"]
+      assert_equal '5', command.env["SPECIFIC_CONFIG"]
+    end
+
+    test "#env uses the correct Github token for a stack" do
+      Shipit.github(organization: 'shopify').stubs(:token).returns('aS3cr3Tt0kEn')
+      command = @commands.fetch
+      assert_equal 'aS3cr3Tt0kEn', command.env["GITHUB_TOKEN"]
     end
 
     test "#clone clones the repository cache into the working directory" do
@@ -65,15 +121,15 @@ module Shipit
       clone_args = [
         'git', 'clone', '--quiet',
         '--local', '--origin', 'cache',
-        @stack.git_path, @deploy.working_directory
+        @stack.git_path.to_s, @deploy.working_directory,
       ]
       assert_equal clone_args, commands.first.args
-      assert_equal ['git', 'remote', 'add', 'origin', @stack.repo_git_url], commands.second.args
+      assert_equal ['git', 'remote', 'add', 'origin', @stack.repo_git_url.to_s], commands.second.args
     end
 
     test "#clone clones the repository cache from the deploys_path" do
       commands = @commands.clone
-      assert_equal @stack.deploys_path, commands.first.chdir
+      assert_equal @stack.deploys_path.to_s, commands.first.chdir
     end
 
     test "#checkout checks out the deployed commit" do
@@ -182,7 +238,7 @@ module Shipit
     test "#install_dependencies merges Shipit.env in ENVIRONMENT" do
       Shipit.stubs(:env).returns("SPECIFIC_CONFIG" => 5)
       command = @commands.install_dependencies.first
-      assert_equal 5, command.env["SPECIFIC_CONFIG"]
+      assert_equal '5', command.env["SPECIFIC_CONFIG"]
     end
 
     test "#install_dependencies merges machine_env in ENVIRONMENT" do