shipit-engine 0.32.0 → 0.33.0

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,59 @@
+# 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
+      # 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
+    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
+  end
+end

data/test/models/{stacks_test.rb → shipit/stacks_test.rb}

@@ -267,8 +267,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 +283,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,12 +351,12 @@ 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

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

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Shipit
+  module Webhooks
+    module Handlers
+      module PullRequest
+        class ClosedHandlerTest < ActiveSupport::TestCase
+          test "validates payload" do
+            assert_raise(StandardError) { Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:invalid_pull_request)) }
+          end
+
+          test "ignores irrelevant PR actions" do
+            assert_no_difference -> { Shipit::Stack.not_archived.count } do
+              Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_opened).merge(action: "assigned")).process
+            end
+          end
+
+          test "does not error for repos that are not tracked" do
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_with_no_repo).merge(action: "closed")).process
+          end
+
+          test "archives stacks for repos that are tracked" do
+            create_stack
+            assert_difference -> { Shipit::Stack.not_archived.count }, -1 do
+              Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_closed)).process
+            end
+          end
+
+          test "ignored duplicate deliveries" do
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_opened)).process
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_closed)).process
+            assert_no_difference -> { Shipit::Stack.not_archived.count } do
+              Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_closed)).process
+            end
+          end
+
+          test "archives stacks for repos that allow_all" do
+            stack = create_stack
+            repository = shipit_repositories(:shipit)
+            configure_provisioning_behavior(
+              repository: repository,
+              behavior: :allow_all
+            )
+
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload_parsed(:pull_request_closed)).process
+
+            assert stack.reload.archived?, "Expected stack to be archived"
+          end
+
+          test "archives stacks for repos that allow_with_label when label is present" do
+            stack = create_stack
+            repository = shipit_repositories(:shipit)
+            configure_provisioning_behavior(
+              repository: repository,
+              behavior: :allow_with_label,
+              label: "pull-requests-label"
+            )
+            payload = payload_parsed(:pull_request_closed)
+            payload["pull_request"]["labels"] << { "name" => "pull-requests-label" }
+
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload).process
+
+            assert stack.reload.archived?, "Expected stack to be archived"
+          end
+
+          test "archives stacks for repos that allow_with_label when label is absent" do
+            stack = create_stack
+            repository = shipit_repositories(:shipit)
+            configure_provisioning_behavior(
+              repository: repository,
+              behavior: :allow_with_label,
+              label: "pull-requests-label"
+            )
+            payload = payload_parsed(:pull_request_closed)
+            payload["pull_request"]["labels"] = []
+
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload).process
+
+            assert stack.reload.archived?, "Expected stack to be archived"
+          end
+
+          test "archives stacks for repos that prevent_with_label when label is absent" do
+            stack = create_stack
+            repository = shipit_repositories(:shipit)
+            configure_provisioning_behavior(
+              repository: repository,
+              behavior: :prevent_with_label,
+              label: "pull-requests-label"
+            )
+            payload = payload_parsed(:pull_request_closed)
+            payload["pull_request"]["labels"] = []
+
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload).process
+
+            assert stack.reload.archived?, "Expected stack to be archived"
+          end
+
+          test "archives stacks for repos that prevent_with_label when label is present" do
+            stack = create_stack
+            repository = shipit_repositories(:shipit)
+            configure_provisioning_behavior(
+              repository: repository,
+              behavior: :prevent_with_label,
+              label: "pull-requests-label"
+            )
+            payload = payload_parsed(:pull_request_closed)
+            payload["pull_request"]["labels"] << { "name" => "pull-requests-label" }
+
+            Shipit::Webhooks::Handlers::PullRequest::ClosedHandler.new(payload).process
+
+            assert stack.reload.archived?, "Expected stack to be archived"
+          end
+
+          def configure_provisioning_behavior(repository:, provisioning_enabled: true, behavior: :allow_all, label: nil)
+            repository.review_stacks_enabled = provisioning_enabled
+            repository.provisioning_behavior = behavior
+            repository.provisioning_label_name = label
+            repository.save!
+
+            repository
+          end
+
+          def create_archived_stack
+            stack = create_stack
+            stack.archive!(shipit_users(:codertocat))
+
+            stack
+          end
+
+          def create_stack
+            repository = shipit_repositories(:shipit)
+            repository.provisioning_behavior = :allow_all
+            repository.save!
+
+            payload = payload_parsed(:pull_request_labeled)
+            payload["action"] = "opened"
+
+            OpenedHandler.new(payload).process
+
+            stack = repository.stacks.last
+            stack.update(provision_status: :provisioned)
+            complete_active_tasks(stack)
+
+            stack
+          end
+
+          def complete_active_tasks(stack)
+            active_tasks = stack
+              .tasks
+              .active
+
+            active_tasks.map(&:run)
+            active_tasks.reload
+            active_tasks.map(&:complete)
+          end
+
+          setup do
+            Shipit.github.api.stubs(:commit)
+              .with("shopify/shipit-engine", "ec26c3e57ca3a959ca5aad62de7213c562f8c821")
+              .returns(
+                resource(
+                  {
+                    sha: "ec26c3e57ca3a959ca5aad62de7213c562f8c821",
+                    commit: {
+                      author: {
+                        name: "Codertocat",
+                        email: "21031067+Codertocat@users.noreply.github.com",
+                        date: "2019-05-15 15:20:30",
+                      },
+                      committer: {
+                        name: "Codertocat",
+                        email: "21031067+Codertocat@users.noreply.github.com",
+                        date: "2019-05-15 15:20:30",
+                      },
+                      message: "Update README.md",
+                    },
+                    stats: {
+                      total: 2,
+                      additions: 1,
+                      deletions: 1,
+                    },
+                  }
+                )
+              )
+          end
+        end
+      end
+    end
+  end
+end