shipit-engine 0.32.0 → 0.35.1

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

data/test/models/shipit/pull_request_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Shipit
+  class PullRequestTest < ActiveSupport::TestCase
+    test "github_pull_request= parses into a a Shipit::PullRequest" do
+      github_pull_request = resource(
+        {
+          url: "https://api.github.com/repos/Codertocat/Hello-World/pulls/2",
+          id: 279147437,
+          number: 2,
+          state: "open",
+          additions: 100,
+          deletions: 101,
+          title: "Update the README with new information.",
+          head: {
+            sha: "ec26c3e57ca3a959ca5aad62de7213c562f8c821",
+          },
+          user: {
+            login: "Codertocat",
+          },
+          assignees: [
+            {
+              login: "bob",
+            },
+          ],
+          labels: [
+            {
+              name: "deploy",
+            },
+          ],
+        }
+      )
+      stack = shipit_stacks(:review_stack)
+      pull_request = stack.pull_request
+
+      stack.pull_request.github_pull_request = github_pull_request
+
+      assert_equal 279147437, pull_request.github_id
+      assert_equal 2, pull_request.number
+      assert_equal "https://api.github.com/repos/Codertocat/Hello-World/pulls/2", pull_request.api_url
+      assert_equal "Update the README with new information.", pull_request.title
+      assert_equal "open", pull_request.state
+      assert_equal 100, pull_request.additions
+      assert_equal 101, pull_request.deletions
+      assert_equal shipit_users(:codertocat), pull_request.user
+      assert_equal [shipit_users(:bob)], pull_request.assignees
+      assert_equal ["deploy"], pull_request.labels
+    end
+  end
+end

data/test/models/shipit/repository_test.rb

@@ -20,7 +20,7 @@ module Shipit
 
     test "owner and name are case insensitive" do
       assert_no_difference -> { Repository.count } do
-        error = assert_raises ActiveRecord::RecordInvalid do
+        error = assert_raises(ActiveRecord::RecordInvalid) do
           Repository.create!(
             owner: @repository.owner.upcase,
             name: @repository.name.upcase,
@@ -63,6 +63,10 @@ module Shipit
       assert_equal "https://github.com/#{@repository.owner}/#{@repository.name}.git", @repository.git_url
     end
 
+    test "review_stacks_enabled defaults to false" do
+      assert_equal false, Repository.new.review_stacks_enabled
+    end
+
     test "from_github_repo_name" do
       owner = "repository-owner"
       name = "repository-name"

data/test/models/shipit/review_stack_provision_status_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Shipit
+  class ReviewStackProvisionStatusTest < ActiveSupport::TestCase
+    test "stacks default to deprovisioned state" do
+      stack = Shipit::ReviewStack.new
+
+      assert_equal 'deprovisioned', stack.provision_status
+    end
+
+    test "non-review stacks don't transition" do
+      stack = Shipit::ReviewStack.new
+      stack.provision
+
+      assert_equal 'deprovisioned', stack.provision_status
+    end
+
+    test "review stacks that are deprovisioned can be provisioned" do
+      stack = review_stack(provision_status: :deprovisioned)
+
+      stack.provision
+
+      assert_equal 'provisioning', stack.provision_status
+    end
+
+    test "review stacks that are provisioning can succeed" do
+      stack = review_stack(provision_status: :provisioning)
+
+      stack.provision_success
+
+      assert_equal 'provisioned', stack.provision_status
+    end
+
+    test "review stacks that are provisioning can fail" do
+      stack = review_stack(provision_status: :provisioning)
+
+      stack.provision_failure
+
+      assert_equal 'deprovisioned', stack.provision_status
+    end
+
+    test "review stacks are provisioned can be deprovisioned" do
+      stack = review_stack(provision_status: :provisioned)
+
+      stack.deprovision
+
+      assert 'deprovisioning', stack.provision_status
+    end
+
+    test "review stacks that are deprovisioning can succeed" do
+      stack = review_stack(provision_status: :deprovisioning)
+
+      stack.deprovision_success
+
+      assert_equal 'deprovisioned', stack.provision_status
+    end
+
+    test "review stacks that are deprovisioning can fail" do
+      stack = review_stack(provision_status: :deprovisioning)
+
+      stack.deprovision_failure
+
+      assert_equal 'provisioned', stack.provision_status
+    end
+
+    def review_stack(provision_status: :deprovisioned)
+      stack = shipit_stacks(:review_stack)
+      stack.provision_status = provision_status
+
+      stack.save!
+
+      stack
+    end
+  end
+end

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}

@@ -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
@@ -267,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
 
@@ -282,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
@@ -345,24 +362,35 @@ module Shipit
       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
@@ -920,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)