shipit-engine 0.30.0 → 0.34.0

data/test/models/shipit/review_stack_provisioning_queue_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Shipit
+  class ReviewStackProvisioningQueueTest < ActiveSupport::TestCase
+    test ".add en-queues a stack for provisioning" do
+      review_stack = shipit_stacks(:review_stack)
+      review_stack.update(lock_reason: nil)
+
+      assert_changes -> { review_stack.awaiting_provision }, from: false, to: true do
+        queue.add(review_stack)
+      end
+    end
+
+    test ".work provisions resource stacks when they are provision-able" do
+      review_stack = provisionable_review_stack
+      setup_provisioning_handler(for_stack: review_stack, provision: true)
+      queue.add(review_stack)
+
+      assert_changes -> { review_stack.reload.provision_status }, from: "deprovisioned", to: "provisioning" do
+        queue.work
+      end
+    end
+
+    test ".work does not provision resource stacks when they are not provisionable" do
+      review_stack = provisionable_review_stack
+      setup_provisioning_handler(for_stack: review_stack, provision: false)
+      queue.add(review_stack)
+
+      assert_equal "deprovisioned", review_stack.provision_status
+      assert_no_changes -> { review_stack.reload.provision_status } do
+        queue.work
+      end
+    end
+
+    private
+
+    def setup_provisioning_handler(for_stack:, provision:)
+      provisioning_handler_instance = mock("ProvisioningHandler instance")
+      provisioning_handler_instance.expects(:provision?).returns(provision)
+      provisioning_handler_instance.expects(:up).returns(true) if !!provision
+      provisioning_handler_class = mock("ProvisioningHandler class")
+      provisioning_handler_class.expects(:new).at_least_once.with(for_stack).returns(provisioning_handler_instance)
+      Shipit::ProvisioningHandler.expects(:fetch).at_least_once.returns(provisioning_handler_class)
+
+      provisioning_handler_instance
+    end
+
+    def provisionable_review_stack
+      review_stack = shipit_stacks(:review_stack)
+      review_stack.update(
+        provision_status: :deprovisioned,
+      )
+
+      review_stack
+    end
+
+    def queue
+      ReviewStackProvisioningQueue
+    end
+  end
+end

data/test/models/shipit/review_stack_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Shipit
+  class ReviewStackTest < ActiveSupport::TestCase
+    setup do
+      @review_stack = shipit_stacks(:review_stack)
+    end
+
+    test "clearing stale caches" do
+      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
+      new_review_stack = @review_stack.dup
+      new_review_stack.environment = "new-review-stack-environment"
+
+      expect_hook(:review_stack, new_review_stack, action: :added, review_stack: new_review_stack) do
+        new_review_stack.save!
+      end
+    end
+
+    test "updating a review stack emit a hook" do
+      expect_hook(:review_stack, @review_stack, action: :updated, review_stack: @review_stack) do
+        @review_stack.update(environment: 'foo')
+      end
+    end
+
+    test "updating a review stack doesn't emit a hook if only `updated_at` is changed" do
+      # force a save to make sure `cached_deploy_spec` serialization is consistent with how Active Record would
+      # serialize it.
+      @review_stack.update(updated_at: 2.days.ago)
+
+      expect_no_hook(:review_stack) do
+        @review_stack.update(updated_at: Time.zone.now)
+      end
+    end
+
+    test "deleteing a review stack emits a hook" do
+      expect_hook(:review_stack, @review_stack, action: :removed, review_stack: @review_stack) do
+        @review_stack.destroy!
+      end
+    end
+
+    test "#env includes the stack's pull request labels" do
+      stack = shipit_stacks(:review_stack)
+      stack.pull_request.labels = ["wip", "bug"]
+
+      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/{stacks_test.rb → shipit/stacks_test.rb}

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'test_helper'
 require 'securerandom'
 
@@ -9,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
@@ -70,11 +81,11 @@ module Shipit
 
       last_commit = shipit_commits(:third)
       deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
-      assert_includes FakeReceiver.hooks, [
+      assert_includes(FakeReceiver.hooks, [
         :deploy,
         @stack,
-        {deploy: deploy, status: "pending", stack: @stack},
-      ]
+        { deploy: deploy, status: "pending", stack: @stack },
+      ])
     ensure
       Shipit.internal_hook_receivers = original_receivers
     end
@@ -200,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
 
@@ -251,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
@@ -266,8 +278,9 @@ module Shipit
       end
     end
 
-    test "#deployable? returns true if the stack is not locked and is not deploying" do
+    test "#deployable? returns true if the stack is not locked, not awaiting provision, and is not deploying" do
       @stack.deploys.destroy_all
+      @stack.update!(lock_reason: nil, awaiting_provision: false)
       assert_predicate @stack, :deployable?
     end
 
@@ -281,6 +294,11 @@ module Shipit
       refute_predicate @stack, :deployable?
     end
 
+    test "#deployable? returns false if the stack is awaiting provisioning" do
+      @stack.update!(lock_reason: nil, awaiting_provision: true)
+      refute_predicate @stack, :deployable?
+    end
+
     test "#allows_merges? returns true if the stack is not locked and the branch is green" do
       assert_predicate @stack, :allows_merges?
     end
@@ -306,7 +324,7 @@ module Shipit
     end
 
     test "#monitoring returns deploy_spec's content" do
-      assert_equal [{'image' => 'https://example.com/monitor.png', 'width' => 200, 'height' => 300}], @stack.monitoring
+      assert_equal [{ 'image' => 'https://example.com/monitor.png', 'width' => 200, 'height' => 300 }], @stack.monitoring
     end
 
     test "#destroy deletes the related commits" do
@@ -338,30 +356,41 @@ module Shipit
         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
+        expect_hook(:lock, @stack, locked: false, lock_details: { from: time, until: Time.current }, stack: @stack) do
           @stack.update(lock_reason: nil)
         end
       end
     end
 
-    test "unlocking the stack triggers a MergePullRequests job" do
-      assert_no_enqueued_jobs(only: MergePullRequestsJob) do
+    test "unlocking the stack triggers a MergeMergeRequests job" do
+      assert_no_enqueued_jobs(only: ProcessMergeRequestsJob) do
         @stack.update(lock_reason: "Just for fun", lock_author: shipit_users(:walrus))
       end
 
-      assert_enqueued_with(job: MergePullRequestsJob, args: [@stack]) do
+      assert_enqueued_with(job: ProcessMergeRequestsJob, args: [@stack]) do
         @stack.update(lock_reason: nil)
       end
     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
@@ -389,7 +418,7 @@ module Shipit
 
     test "updating the stack emit a hook" do
       expect_hook(:stack, @stack, action: :updated, stack: @stack) do
-        @stack.update(repo_name: 'foo')
+        @stack.update(environment: 'foo')
       end
     end
 
@@ -483,7 +512,9 @@ module Shipit
 
       assert_no_enqueued_jobs do
         assert_no_difference -> { Deploy.count } do
-          @stack.trigger_continuous_delivery
+          value = @stack.trigger_continuous_delivery
+
+          assert_nil value
         end
       end
     end
@@ -551,7 +582,24 @@ module Shipit
       end
     end
 
+    test "#trigger_continuous_delivery bails out if no DeploySpec has been cached" do
+      @stack = shipit_stacks(:check_deploy_spec)
+      deploy_spec = @stack.cached_deploy_spec
+
+      assert_predicate @stack, :deployable?
+      refute_predicate @stack, :deployed_too_recently?
+      assert(deploy_spec.blank?, "DeploySpec blank? returned false")
+
+      assert_no_enqueued_jobs(only: Shipit::PerformTaskJob) do
+        assert_no_difference -> { Deploy.count } do
+          @stack.trigger_continuous_delivery
+        end
+      end
+    end
+
     test "#trigger_continuous_delivery enqueues deployment ref update job" do
+      Shipit.stubs(:update_latest_deployed_ref).returns(true)
+
       @stack = shipit_stacks(:shipit_canaries)
       shipit_tasks(:canaries_running).delete
 
@@ -567,6 +615,8 @@ module Shipit
     end
 
     test "#trigger_continuous_delivery executes ref update job with correct sha" do
+      Shipit.stubs(:update_latest_deployed_ref).returns(true)
+
       @stack = shipit_stacks(:shipit_canaries)
       shipit_tasks(:canaries_running).delete
 
@@ -598,7 +648,7 @@ module Shipit
       @stack.tasks.delete_all
 
       deploy = @stack.trigger_continuous_delivery
-      assert_equal({'SAFETY_DISABLED' => '0'}, deploy.env)
+      assert_equal({ 'SAFETY_DISABLED' => '0' }, deploy.env)
     end
 
     test "#continuous_delivery_delayed! bumps updated_at" do
@@ -863,6 +913,57 @@ module Shipit
       end
     end
 
+    test "#links performs template substitutions" do
+      @stack.repo_name = "expected-repository-name"
+      @stack.environment = "expected-environment"
+      @stack.cached_deploy_spec = create_deploy_spec(
+        "links" => {
+          "logs" => "http://logs.$GITHUB_REPO_NAME.$ENVIRONMENT.domain.com",
+          "monitoring" => "https://graphs.$GITHUB_REPO_NAME.$ENVIRONMENT.domain.com",
+        },
+      )
+
+      assert_equal(
+        {
+          "logs" => "http://logs.expected-repository-name.expected-environment.domain.com",
+          "monitoring" => "https://graphs.expected-repository-name.expected-environment.domain.com",
+        },
+        @stack.links,
+      )
+    end
+
+    test "#env includes the stack's environment" do
+      expected_environment = {
+        'ENVIRONMENT' => @stack.environment,
+        'LAST_DEPLOYED_SHA' => @stack.last_deployed_commit.sha,
+        'GITHUB_REPO_OWNER' => @stack.repository.owner,
+        'GITHUB_REPO_NAME' => @stack.repository.name,
+        'DEPLOY_URL' => @stack.deploy_url,
+        'BRANCH' => @stack.branch,
+      }
+
+      assert_equal(
+        @stack.env,
+        expected_environment,
+      )
+    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)
@@ -875,5 +976,9 @@ module Shipit
         committed_at: Time.zone.now,
       )
     end
+
+    def create_deploy_spec(spec)
+      Shipit::DeploySpec.new(spec.stringify_keys)
+    end
   end
 end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Shipit
+  module Webhooks
+    module Handlers
+      module PullRequest
+        class AssignedHandlerTest < ActiveSupport::TestCase
+          test "validates payload" do
+            assert_raise(StandardError) { AssignedHandler.new(payload_parsed(:invalid_pull_request)) }
+          end
+
+          test "ignores irrelevant PR actions" do
+            assert_no_enqueued_jobs do
+              AssignedHandler.new(payload_parsed(:pull_request_assigned).merge(action: "labeled")).process
+            end
+          end
+
+          test "updates the existing PullRequest's assignees" do
+            pull_request = shipit_pull_requests(:review_stack_review)
+            pull_request.assignees.clear
+            payload = payload_parsed(:pull_request_assigned)
+            payload["number"] = pull_request.number
+            payload["pull_request"]["number"] = pull_request.number
+
+            AssignedHandler.new(payload).process
+
+            assert [shipit_users(:codertocat)], pull_request.reload.assignees
+          end
+
+          test "does not attempt to update when PullRequest does not exist" do
+            unknown_pull_request_number = 999
+            payload = payload_parsed(:pull_request_assigned)
+            payload["number"] = unknown_pull_request_number
+
+            assert_no_changes -> { Shipit::PullRequestAssignment.count } do
+              AssignedHandler.new(payload).process
+            end
+          end
+        end
+      end
+    end
+  end
+end