shipit-engine 0.38.0 → 0.40.0

data/test/models/shipit/check_run_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 
 module Shipit
@@ -33,14 +34,14 @@ module Shipit
       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)
+          github_check_run(conclusion: 'success', 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)
+          github_check_run(conclusion: nil, completed_at:)
         )
       end
 
@@ -50,9 +51,9 @@ module Shipit
           @stack.id,
           github_check_run(
             conclusion: 'action_required',
-            completed_at: completed_at,
-            started_at: completed_at + 1.minute,
-          ),
+            completed_at:,
+            started_at: completed_at + 1.minute
+          )
         )
       end
 
@@ -62,12 +63,12 @@ module Shipit
     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))
+        @commit.check_runs.create_or_update_from_github!(@stack.id, github_check_run(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))
+          @commit.check_runs.create_or_update_from_github!(@stack.id, github_check_run(completed_at:))
         end
       end
     end
@@ -77,7 +78,7 @@ module Shipit
       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)
+          github_check_run(conclusion: 'success', completed_at:)
         )
       end
 
@@ -109,7 +110,7 @@ module Shipit
       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)
+          github_check_run(conclusion: 'success', completed_at:)
         )
       end
 
@@ -143,10 +144,10 @@ module Shipit
       'neutral' => 'success',
       'cancelled' => 'failure',
       'timed_out' => 'error',
-      'action_required' => 'pending',
+      'action_required' => 'pending'
     }.each do |conclusion, expected_status|
       test "#state is #{expected_status.inspect} when conclusion is #{conclusion.inspect}" do
-        @check_run.update!(conclusion: conclusion)
+        @check_run.update!(conclusion:)
         assert_equal expected_status, @check_run.state
       end
     end
@@ -156,15 +157,15 @@ module Shipit
     def github_check_run(conclusion: 'success', completed_at: Time.now, started_at: Time.now - 1.minute)
       OpenStruct.new(
         id: 424_242,
-        conclusion: conclusion,
+        conclusion:,
         output: OpenStruct.new(
-          description: 'This is a description',
+          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,
+        completed_at:,
+        started_at:
       )
     end
   end

data/test/models/shipit/continuous_delivery_schedule_test.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Shipit
+  class ContinuousDeliveryScheduleTest < ActiveSupport::TestCase
+    test "defaults to all the time" do
+      stack = shipit_stacks(:shipit)
+      schedule = stack.build_continuous_delivery_schedule
+
+      assert(schedule.valid?)
+
+      Shipit::ContinuousDeliverySchedule::DAYS.each do |day|
+        assert(schedule.read_attribute("#{day}_enabled"))
+
+        day_start = schedule.read_attribute("#{day}_start")
+        assert_equal(day_start.at_beginning_of_day, day_start)
+
+        day_end = schedule.read_attribute("#{day}_end")
+        assert_equal(day_end.at_end_of_day.at_beginning_of_minute, day_end)
+      end
+    end
+
+    test "#get_deployment_window" do
+      schedule = Shipit::ContinuousDeliverySchedule.new(
+        monday_enabled: false,
+        monday_start: "09:15",
+        monday_end: "17:30"
+      )
+
+      monday = Date.current.monday
+
+      deployment_window = schedule.get_deployment_window(monday)
+
+      refute(deployment_window.enabled?)
+
+      starts_at = deployment_window.starts_at
+      assert_equal(monday, starts_at.to_date)
+      assert_equal(9, starts_at.hour)
+      assert_equal(15, starts_at.min)
+      assert_equal(starts_at.at_beginning_of_minute, starts_at)
+
+      ends_at = deployment_window.ends_at
+      assert_equal(monday, ends_at.to_date)
+      assert_equal(17, ends_at.hour)
+      assert_equal(30, ends_at.min)
+      assert_equal(ends_at.at_end_of_minute, ends_at)
+    end
+
+    test "#can_deploy? is false if the day is disabled" do
+      schedule = Shipit::ContinuousDeliverySchedule.new(
+        tuesday_enabled: false,
+        tuesday_start: "00:00",
+        tuesday_end: "23:59"
+      )
+
+      tuesday = Date.current.monday.advance(days: 1).beginning_of_day
+
+      refute(schedule.can_deploy?(tuesday))
+    end
+
+    test "#can_deploy? is true when the current time is within the window" do
+      schedule = Shipit::ContinuousDeliverySchedule.new(
+        wednesday_enabled: true,
+        wednesday_start: "09:15",
+        wednesday_end: "17:30"
+      )
+
+      wednesday = Date.current.monday.advance(days: 2).beginning_of_day
+
+      refute(schedule.can_deploy?(wednesday))
+      assert(schedule.can_deploy?(wednesday.advance(hours: 9, minutes: 15)))
+      assert(schedule.can_deploy?(wednesday.advance(hours: 12)))
+      assert(schedule.can_deploy?(wednesday.advance(hours: 17, minutes: 30).at_end_of_minute))
+      refute(schedule.can_deploy?(wednesday.advance(hours: 17, minutes: 31)))
+    end
+
+    test "validates that end times must come after start times" do
+      schedule = Shipit::ContinuousDeliverySchedule.new(
+        thursday_start: "15:00",
+        thursday_end: "14:00"
+      )
+
+      schedule.validate
+      assert(schedule.errors.include?(:thursday_end))
+      assert_equal(["must be after start (03:00 PM)"], schedule.errors.messages_for(:thursday_end))
+    end
+
+    test "validates `*_enabled` fields" do
+      schedule = Shipit::ContinuousDeliverySchedule.new(
+        friday_enabled: nil
+      )
+
+      schedule.validate
+      assert_equal(["is not included in the list"], schedule.errors.messages_for(:friday_enabled))
+    end
+
+    test "requires `_start` and `_end` fields" do
+      schedule = Shipit::ContinuousDeliverySchedule.new(
+        saturday_start: nil,
+        saturday_end: nil
+      )
+
+      schedule.validate
+      assert_equal(["can't be blank"], schedule.errors.messages_for(:saturday_start))
+      assert_equal(["can't be blank"], schedule.errors.messages_for(:saturday_end))
+    end
+  end
+end

data/test/models/shipit/deploy_spec/file_system_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 require 'tmpdir'
 
@@ -7,8 +8,9 @@ module Shipit
     class FileSystemTest < ActiveSupport::TestCase
       test 'deploy.pre calls "exit 1" if there is a bare shipit file and Shipit is configured to ignore' do
         Shipit.expects(:respect_bare_shipit_file?).returns(false).at_least_once
-        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, 'env')
-        deploy_spec.expects(:config_file_path).returns(Pathname.new(Dir.tmpdir) + '/shipit.yml').at_least_once
+        stack = shipit_stacks(:shipit)
+        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+        deploy_spec.expects(:config_file_path).returns("#{Pathname.new(Dir.tmpdir)}/shipit.yml").at_least_once
         deploy_spec.expects(:read_config).never
         pre_commands = deploy_spec.send(:config, 'deploy', 'pre')
         assert pre_commands.include?('exit 1')
@@ -18,8 +20,9 @@ module Shipit
 
       test 'deploy.pre does not call "exit 1" if Shipit is not configured to do so' do
         Shipit.expects(:respect_bare_shipit_file?).returns(true).at_least_once
-        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, 'env')
-        deploy_spec.expects(:config_file_path).returns(Pathname.new(Dir.tmpdir) + '/shipit.yml').at_least_once
+        stack = shipit_stacks(:shipit)
+        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+        deploy_spec.expects(:config_file_path).returns("#{Pathname.new(Dir.tmpdir)}/shipit.yml").at_least_once
         deploy_spec.expects(:read_config).returns(SafeYAML.load(deploy_spec_yaml))
         pre_commands = deploy_spec.send(:config, 'deploy', 'pre')
         refute pre_commands.include?('exit 1')
@@ -29,8 +32,9 @@ module Shipit
       test 'Shipit.respect_bare_shipit_file? has no effect if the file is not a bare file' do
         [true, false].each do |obey_val|
           Shipit.expects(:respect_bare_shipit_file?).returns(obey_val).at_least_once
-          deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, 'env')
-          deploy_spec.expects(:config_file_path).returns(Pathname.new(Dir.tmpdir) + '/shipit.env.yml').at_least_once
+          stack = shipit_stacks(:shipit)
+          deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+          deploy_spec.expects(:config_file_path).returns("#{Pathname.new(Dir.tmpdir)}/shipit.env.yml").at_least_once
           deploy_spec.expects(:read_config).returns(SafeYAML.load(deploy_spec_yaml))
           pre_commands = deploy_spec.send(:config, 'deploy', 'pre')
           refute pre_commands.include?('exit 1')
@@ -40,8 +44,9 @@ module Shipit
 
       test '#load_config does not error if the file is empty' do
         Shipit.expects(:respect_bare_shipit_file?).returns(true).at_least_once
-        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, 'env')
-        deploy_spec.expects(:config_file_path).returns(Pathname.new(Dir.tmpdir) + '/shipit.env.yml').at_least_once
+        stack = shipit_stacks(:shipit)
+        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+        deploy_spec.expects(:config_file_path).returns("#{Pathname.new(Dir.tmpdir)}/shipit.env.yml").at_least_once
         deploy_spec.expects(:read_config).at_least_once.returns(false)
         loaded_config = deploy_spec.send(:cacheable_config)
         refute loaded_config == false
@@ -49,8 +54,9 @@ module Shipit
 
       test '#load_config does not error if there is no "deploy" key' do
         Shipit.expects(:respect_bare_shipit_file?).returns(false).at_least_once
-        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, 'env')
-        deploy_spec.expects(:config_file_path).returns(Pathname.new(Dir.tmpdir) + '/shipit.yml').at_least_once
+        stack = shipit_stacks(:shipit)
+        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+        deploy_spec.expects(:config_file_path).returns("#{Pathname.new(Dir.tmpdir)}/shipit.yml").at_least_once
         deploy_spec.expects(:read_config).never
         loaded_config = deploy_spec.send(:load_config)
         assert loaded_config.key?("deploy")
@@ -58,6 +64,35 @@ module Shipit
         assert loaded_config["deploy"]["pre"].include?('exit 1')
       end
 
+      test '#load_config builds proper config if inherit_from is present' do
+        Shipit.expects(:respect_bare_shipit_file?).returns(true).at_least_once
+        stack = shipit_stacks(:shipit)
+        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+        deploy_spec.expects(:config_file_path).returns(Pathname.new("#{Dir.tmpdir}/shipit_1.yml")).at_least_once
+        deploy_spec.expects(:read_config).returns(SafeYAML.load(deploy_spec_inherit_from_yaml), SafeYAML.load(deploy_spec_yaml)).at_least_once
+        Pathname.any_instance.stubs(:exist?).returns(true)
+        loaded_config = deploy_spec.send(:load_config)
+        assert loaded_config.key?("deploy")
+        assert loaded_config["deploy"].key?("pre")
+        assert loaded_config["deploy"]["pre"].include?("test 2")
+        assert loaded_config["deploy"]["override"].include?("test 11")
+        assert_not loaded_config.include?(Shipit::DeploySpec::FileSystem::SHIPIT_CONFIG_INHERIT_FROM_KEY)
+      end
+
+      test '#load_config builds valid config if inherit_from path is missing' do
+        Shipit.expects(:respect_bare_shipit_file?).returns(true).at_least_once
+        stack = shipit_stacks(:shipit)
+        deploy_spec = Shipit::DeploySpec::FileSystem.new(Dir.tmpdir, stack)
+        deploy_spec.expects(:config_file_path).returns(Pathname.new("#{Dir.tmpdir}/shipit_1.yml")).at_least_once
+        deploy_spec.expects(:read_config).returns(SafeYAML.load(deploy_spec_inherit_from_yaml)).at_least_once
+        Pathname.any_instance.stubs(:exist?).returns(false)
+        loaded_config = deploy_spec.send(:load_config)
+        assert loaded_config.key?("deploy")
+        assert_not loaded_config["deploy"].include?("pre")
+        assert loaded_config["deploy"]["override"].include?("test 11")
+        assert_not loaded_config.include?(Shipit::DeploySpec::FileSystem::SHIPIT_CONFIG_INHERIT_FROM_KEY)
+      end
+
       def deploy_spec_yaml
         <<~EOYAML
           deploy:
@@ -68,6 +103,15 @@ module Shipit
         EOYAML
       end
 
+      def deploy_spec_inherit_from_yaml
+        <<~EOYAML
+          inherit_from: shipit.yml
+          deploy:
+            override:
+              - test 11
+        EOYAML
+      end
+
       def deploy_spec_missing_deploy_yaml
         <<~EOYAML
           production_platform:

data/test/models/shipit/pull_request_test.rb

@@ -8,28 +8,28 @@ module Shipit
       github_pull_request = resource(
         {
           url: "https://api.github.com/repos/Codertocat/Hello-World/pulls/2",
-          id: 279147437,
+          id: 279_147_437,
           number: 2,
           state: "open",
           additions: 100,
           deletions: 101,
           title: "Update the README with new information.",
           head: {
-            sha: "ec26c3e57ca3a959ca5aad62de7213c562f8c821",
+            sha: "ec26c3e57ca3a959ca5aad62de7213c562f8c821"
           },
           user: {
-            login: "Codertocat",
+            login: "Codertocat"
           },
           assignees: [
             {
-              login: "bob",
-            },
+              login: "bob"
+            }
           ],
           labels: [
             {
-              name: "deploy",
-            },
-          ],
+              name: "deploy"
+            }
+          ]
         }
       )
       stack = shipit_stacks(:review_stack)
@@ -37,7 +37,7 @@ module Shipit
 
       stack.pull_request.github_pull_request = github_pull_request
 
-      assert_equal 279147437, pull_request.github_id
+      assert_equal 279_147_437, 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

data/test/models/shipit/repository_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 
 module Shipit
@@ -23,7 +24,7 @@ module Shipit
         error = assert_raises(ActiveRecord::RecordInvalid) do
           Repository.create!(
             owner: @repository.owner.upcase,
-            name: @repository.name.upcase,
+            name: @repository.name.upcase
           )
         end
         assert_equal 'Validation failed: Name cannot be used more than once', error.message
@@ -71,7 +72,7 @@ module Shipit
       owner = "repository-owner"
       name = "repository-name"
       github_repo_name = [owner, name].join("/")
-      expected_repository = Repository.create(owner: owner, name: name)
+      expected_repository = Repository.create(owner:, name:)
 
       found_repository = Repository.from_github_repo_name(github_repo_name)
 

data/test/models/shipit/review_stack_provisioning_queue_test.rb

@@ -39,7 +39,7 @@ module Shipit
     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_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)
@@ -50,7 +50,7 @@ module Shipit
     def provisionable_review_stack
       review_stack = shipit_stacks(:review_stack)
       review_stack.update(
-        provision_status: :deprovisioned,
+        provision_status: :deprovisioned
       )
 
       review_stack

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 require 'securerandom'
 
 module Shipit
-  class StacksTest < ActiveSupport::TestCase
+  class StackTest < ActiveSupport::TestCase
     def setup
       @stack = shipit_stacks(:shipit)
       @expected_base_path = Rails.root.join('data', 'stacks', @stack.to_param).to_s
@@ -82,10 +83,10 @@ module Shipit
       last_commit = shipit_commits(:third)
       deploy = @stack.trigger_deploy(last_commit, AnonymousUser.new)
       assert_includes(FakeReceiver.hooks, [
-        :deploy,
-        @stack,
-        { deploy: deploy, status: "pending", stack: @stack },
-      ])
+                        :deploy,
+                        @stack,
+                        { deploy:, status: "pending", stack: @stack }
+                      ])
     ensure
       Shipit.internal_hook_receivers = original_receivers
     end
@@ -262,7 +263,7 @@ module Shipit
       stack = Stack.create!(
         repository: Repository.new(owner: "foo", name: "bar"),
         environment: 'production',
-        branch: 'main',
+        branch: 'main'
       )
       commit = shipit_commits(:first)
       stack.commits << commit
@@ -704,12 +705,12 @@ module Shipit
       assert_equal shipit_commits(:fifth), @stack.next_commit_to_deploy
     end
 
-    test "#next_commit_to_deploy respects the deploy.max_commits directive" do
+    test "#next_commit_to_deploy respects the deploy.max_commits directive given the commit is deployable" do
       @stack.tasks.destroy_all
 
-      fifth_commit = shipit_commits(:third)
-      fifth_commit.statuses.create!(stack_id: @stack.id, state: 'success', context: 'ci/travis')
-      assert_predicate fifth_commit, :deployable?
+      third_commit = shipit_commits(:third)
+      third_commit.statuses.create!(stack_id: @stack.id, state: 'success', context: 'ci/travis')
+      assert_predicate third_commit, :deployable?
 
       assert_equal shipit_commits(:third), @stack.next_commit_to_deploy
 
@@ -717,6 +718,19 @@ module Shipit
       assert_equal shipit_commits(:third), @stack.next_commit_to_deploy
     end
 
+    test "#next_commit_to_deploy deploys the first deployable commit when deploy.max_commits directive fails to find a deployable commit" do
+      @stack.tasks.destroy_all
+
+      third_commit = shipit_commits(:third)
+      third_commit.statuses.create!(stack_id: @stack.id, state: 'success', context: 'ci/travis')
+      assert_predicate third_commit, :deployable?
+
+      assert_equal shipit_commits(:third), @stack.next_commit_to_deploy
+
+      @stack.expects(:maximum_commits_per_deploy).returns(1).at_least_once
+      assert_equal shipit_commits(:third), @stack.next_commit_to_deploy
+    end
+
     test "setting #lock_reason also sets #locked_since" do
       assert_predicate @stack.locked_since, :nil?
 
@@ -802,7 +816,7 @@ module Shipit
       assert !commits.empty?
       commits.each { |c| refute_predicate c, :deployable? }
 
-      assert_nil @stack.next_expected_commit_to_deploy(commits: commits)
+      assert_nil @stack.next_expected_commit_to_deploy(commits:)
     end
 
     test "#next_expected_commit_to_deploy returns nil if all deployable commits are active" do
@@ -812,7 +826,7 @@ module Shipit
       assert !commits.empty?
       commits.each { |c| assert_predicate c, :active? }
 
-      assert_nil @stack.next_expected_commit_to_deploy(commits: commits)
+      assert_nil @stack.next_expected_commit_to_deploy(commits:)
     end
 
     test "#next_expected_commit_to_deploy returns nil if there are no commits" do
@@ -825,7 +839,7 @@ module Shipit
 
       assert !commits.empty?
 
-      most_recent_limited = @stack.next_expected_commit_to_deploy(commits: commits)
+      most_recent_limited = @stack.next_expected_commit_to_deploy(commits:)
       most_recent = commits.find { |c| !c.active? && c.deployable? }
 
       assert most_recent.id > most_recent_limited.id
@@ -844,16 +858,16 @@ module Shipit
     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)
+      generate_revert_commit(stack: @stack, reverted_commit:, author: revert_author)
       @stack.reload
 
       assert_equal(
         [
           ['Revert "whoami"', false, nil],
           ["whoami", false, nil],
-          ["fix all the things", false, nil],
+          ["fix all the things", false, nil]
         ],
-        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] }
       )
 
       @stack.lock_reverted_commits!
@@ -863,27 +877,27 @@ module Shipit
         [
           ['Revert "whoami"', false, nil],
           ["whoami", true, revert_author.id],
-          ["fix all the things", false, nil],
+          ["fix all the things", false, nil]
         ],
-        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+        @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)
+      generate_revert_commit(stack: @stack, reverted_commit:, author: revert_author)
       @stack.reload
 
       initial_state = [
         ['Revert "lets go"', false, nil],
         ["whoami", false, nil],
-        ["fix all the things", 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.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] }
       )
 
       @stack.lock_reverted_commits!
@@ -891,7 +905,7 @@ module Shipit
 
       assert_equal(
         initial_state,
-        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] }
       )
     end
 
@@ -909,9 +923,9 @@ module Shipit
           ['Revert "whoami"', false, nil],
           ['Revert "fix all the things"', false, nil],
           ["whoami", false, nil],
-          ["fix all the things", false, nil],
+          ["fix all the things", false, nil]
         ],
-        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] }
       )
 
       @stack.lock_reverted_commits!
@@ -922,9 +936,9 @@ module Shipit
           ['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],
+          ["fix all the things", true, first_revert_author.id]
         ],
-        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] },
+        @stack.undeployed_commits.map { |c| [c.message, c.locked, c.lock_author_id] }
       )
     end
 
@@ -949,16 +963,16 @@ module Shipit
       @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",
-        },
+          "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",
+          "monitoring" => "https://graphs.expected-repository-name.expected-environment.domain.com"
         },
-        @stack.links,
+        @stack.links
       )
     end
 
@@ -969,12 +983,12 @@ module Shipit
         'GITHUB_REPO_OWNER' => @stack.repository.owner,
         'GITHUB_REPO_NAME' => @stack.repository.name,
         'DEPLOY_URL' => @stack.deploy_url,
-        'BRANCH' => @stack.branch,
+        'BRANCH' => @stack.branch
       }
 
       assert_equal(
         @stack.env,
-        expected_environment,
+        expected_environment
       )
     end
 
@@ -1000,10 +1014,10 @@ module Shipit
       stack.commits.create(
         sha: SecureRandom.hex(20),
         message: "Revert \"#{reverted_commit.message_header}\"",
-        author: author,
+        author:,
         committer: author,
         authored_at: Time.zone.now,
-        committed_at: Time.zone.now,
+        committed_at: Time.zone.now
       )
     end