diff --git a/.rspec b/.rspec
index 5f16476..2559e39 100644
--- a/.rspec
+++ b/.rspec
@@ -1,2 +1,3 @@
 --color
 --format progress
+--require spec_helper
diff --git a/.rubocop.yml b/.rubocop.yml
new file mode 100644
index 0000000..8ab82ba
--- /dev/null
+++ b/.rubocop.yml
@@ -0,0 +1,8 @@
+inherit_gem:
+  salsify_rubocop: conf/rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.3
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
diff --git a/.travis.yml b/.travis.yml
index 4aae537..fe03cf0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,14 @@
 language: ruby
 sudo: false
 gemfile:
-- gemfiles/rails_4.2.gemfile
-- gemfiles/rails_5.0.gemfile
-- gemfiles/rails_5.1.gemfile
-- gemfiles/rails_5.2.gemfile
+  - gemfiles/rails_4.2.gemfile
+  - gemfiles/rails_5.0.gemfile
+  - gemfiles/rails_5.1.gemfile
+  - gemfiles/rails_5.2.gemfile
 rvm:
-- 2.3.8
-- 2.4.5
-- 2.5.3
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+script:
+  - bundle exec rspec
+  - bundle exec rubocop
diff --git a/Gemfile b/Gemfile
index fa75df1..7f4f5e9 100644
--- a/Gemfile
+++ b/Gemfile
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
diff --git a/Rakefile b/Rakefile
index bfefa30..666e72b 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
diff --git a/delayed_job_groups.gemspec b/delayed_job_groups.gemspec
index 0b4d53e..02b5f03 100644
--- a/delayed_job_groups.gemspec
+++ b/delayed_job_groups.gemspec
@@ -1,4 +1,6 @@
-# encoding: UTF-8
+
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'delayed/job_groups/version'
@@ -8,12 +10,12 @@ Gem::Specification.new do |spec|
   spec.version       = Delayed::JobGroups::VERSION
   spec.authors       = ['Joel Turkel', 'Randy Burkes']
   spec.email         = ['jturkel@salsify.com', 'rlburkes@gmail.com']
-  spec.description   = %q{Aggregates Delayed::Job jobs into groups with group level management and lifecycle callbacks}
-  spec.summary       = %q{Delayed::Job job groups plugin}
+  spec.description   = 'Aggregates Delayed::Job jobs into groups with group level management and lifecycle callbacks'
+  spec.summary       = 'Delayed::Job job groups plugin'
   spec.homepage      = 'https://github.com/salsify/delayed_job_groups_plugin'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.test_files    = Dir.glob('spec/**/*')
   spec.require_paths = ['lib']
 
@@ -28,11 +30,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activerecord', '>= 4.2', '< 5.3'
   spec.add_development_dependency 'coveralls'
   spec.add_development_dependency 'database_cleaner', '>= 1.2'
+  spec.add_development_dependency 'mime-types'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'rspec-its'
+  spec.add_development_dependency 'salsify_rubocop', '0.52.1.1'
   spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'timecop'
-  spec.add_development_dependency 'mime-types'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'timecop'
 end
diff --git a/lib/delayed/job_groups/compatibility.rb b/lib/delayed/job_groups/compatibility.rb
index cf6dfeb..cd13450 100644
--- a/lib/delayed/job_groups/compatibility.rb
+++ b/lib/delayed/job_groups/compatibility.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require 'active_support/version'
 require 'active_record/version'
@@ -8,7 +8,7 @@ module JobGroups
     module Compatibility
 
       def self.mass_assignment_security_enabled?
-        ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity)
+        defined?(::ActiveRecord::MassAssignmentSecurity)
       end
 
     end
diff --git a/lib/delayed/job_groups/job_extensions.rb b/lib/delayed/job_groups/job_extensions.rb
index 83a6f19..bc26241 100644
--- a/lib/delayed/job_groups/job_extensions.rb
+++ b/lib/delayed/job_groups/job_extensions.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Delayed
   module JobGroups
diff --git a/lib/delayed/job_groups/job_group.rb b/lib/delayed/job_groups/job_group.rb
index 890b021..3670ba3 100644
--- a/lib/delayed/job_groups/job_group.rb
+++ b/lib/delayed/job_groups/job_group.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Delayed
   module JobGroups
@@ -18,22 +18,12 @@ class JobGroup < ActiveRecord::Base
 
       validates :queueing_complete, :blocked, :failure_cancels_group, inclusion: [true, false]
 
-      if ActiveRecord::VERSION::MAJOR >= 4
-        has_many :active_jobs, -> { where(failed_at: nil) }, class_name: '::Delayed::Job'
-      else
-        has_many :active_jobs, class_name: Job, conditions: {failed_at: nil}
-      end
-
+      has_many :active_jobs, -> { where(failed_at: nil) }, class_name: '::Delayed::Job'
 
       # Only delete dependent jobs that are unlocked so we can determine if there are in-flight jobs
       # for canceled job groups
-      if ActiveRecord::VERSION::MAJOR >= 4
-        has_many :queued_jobs, -> { where(failed_at: nil, locked_by: nil) }, class_name: '::Delayed::Job',
-                 dependent: :delete_all
-      else
-        has_many :queued_jobs, class_name: Job, conditions: {failed_at: nil, locked_by: nil},
-                 dependent: :delete_all
-      end
+      has_many :queued_jobs, -> { where(failed_at: nil, locked_by: nil) }, class_name: '::Delayed::Job',
+                dependent: :delete_all
 
       def mark_queueing_complete
         with_lock do
@@ -78,7 +68,7 @@ def self.check_for_completion(job_group_id)
         end
       end
 
-      def self.has_pending_jobs?(job_group_ids)
+      def self.has_pending_jobs?(job_group_ids) # rubocop:disable Naming/PredicateName
         job_group_ids = Array(job_group_ids)
         return false if job_group_ids.empty?
         Delayed::Job.where(job_group_id: job_group_ids, failed_at: nil).exists?
diff --git a/lib/delayed/job_groups/plugin.rb b/lib/delayed/job_groups/plugin.rb
index 2177584..70ad6dd 100644
--- a/lib/delayed/job_groups/plugin.rb
+++ b/lib/delayed/job_groups/plugin.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require 'delayed_job'
 require 'set'
@@ -8,7 +8,7 @@ module JobGroups
     class Plugin < Delayed::Plugin
 
       callbacks do |lifecycle|
-        lifecycle.before(:error) do |worker, job|
+        lifecycle.before(:error) do |_worker, job|
           # If the job group has been cancelled then don't let the job be retried
           if job.in_job_group? && job_group_cancelled?(job.job_group_id)
             def job.max_attempts
@@ -17,7 +17,7 @@ def job.max_attempts
           end
         end
 
-        lifecycle.before(:failure) do |worker, job|
+        lifecycle.before(:failure) do |_worker, job|
           # If a job in the job group fails, then cancel the whole job group.
           # Need to check that the job group is present since another
           # job may have concurrently cancelled it.
@@ -26,7 +26,7 @@ def job.max_attempts
           end
         end
 
-        lifecycle.after(:perform) do |worker, job|
+        lifecycle.after(:perform) do |_worker, job|
           # Make sure we only check to see if the job group is complete
           # if the job succeeded
           if job.in_job_group? && job_completed?(job)
@@ -35,8 +35,6 @@ def job.max_attempts
         end
       end
 
-      private
-
       def self.job_group_cancelled?(job_group_id)
         !JobGroup.exists?(job_group_id)
       end
@@ -49,4 +47,3 @@ def self.job_completed?(job)
     end
   end
 end
-
diff --git a/lib/delayed/job_groups/version.rb b/lib/delayed/job_groups/version.rb
index 5e99cdc..d1478e1 100644
--- a/lib/delayed/job_groups/version.rb
+++ b/lib/delayed/job_groups/version.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Delayed
   module JobGroups
diff --git a/lib/delayed_job_groups_plugin.rb b/lib/delayed_job_groups_plugin.rb
index 207cf90..709d9e1 100644
--- a/lib/delayed_job_groups_plugin.rb
+++ b/lib/delayed_job_groups_plugin.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require 'active_support'
 require 'active_record'
diff --git a/lib/generators/delayed_job_groups_plugin/install_generator.rb b/lib/generators/delayed_job_groups_plugin/install_generator.rb
index ebed39c..7a1c456 100644
--- a/lib/generators/delayed_job_groups_plugin/install_generator.rb
+++ b/lib/generators/delayed_job_groups_plugin/install_generator.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require 'rails/generators'
 require 'rails/generators/migration'
@@ -8,7 +8,7 @@ module DelayedJobGroupsPlugin
   class InstallGenerator < Rails::Generators::Base
     include Rails::Generators::Migration
 
-    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+    source_paths << File.join(File.dirname(__FILE__), 'templates')
 
     def create_migration_file
       migration_template('migration.rb', 'db/migrate/create_delayed_job_groups.rb')
diff --git a/lib/generators/delayed_job_groups_plugin/templates/migration.rb b/lib/generators/delayed_job_groups_plugin/templates/migration.rb
index d6bf419..76b547f 100644
--- a/lib/generators/delayed_job_groups_plugin/templates/migration.rb
+++ b/lib/generators/delayed_job_groups_plugin/templates/migration.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 class CreateDelayedJobGroups < ActiveRecord::Migration
 
diff --git a/spec/db/schema.rb b/spec/db/schema.rb
index b73ab90..aea1948 100644
--- a/spec/db/schema.rb
+++ b/spec/db/schema.rb
@@ -1,6 +1,6 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
-ActiveRecord::Schema.define(:version => 0) do
+ActiveRecord::Schema.define(version: 0) do
 
   create_table(:delayed_jobs, force: true) do |t|
     t.integer :priority, default: 0
diff --git a/spec/delayed/job_groups/job_group_spec.rb b/spec/delayed/job_groups/job_group_spec.rb
index 4600ed4..e9a4b72 100644
--- a/spec/delayed/job_groups/job_group_spec.rb
+++ b/spec/delayed/job_groups/job_group_spec.rb
@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Delayed::JobGroups::JobGroup do
 
@@ -19,7 +17,7 @@
 
   before do
     Timecop.freeze(current_time)
-    Delayed::Job.stub(:enqueue)
+    allow(Delayed::Job).to receive(:enqueue)
   end
 
   after do
@@ -28,21 +26,21 @@
 
   shared_examples "the job group was completed" do
     it "queues the completion job" do
-      Delayed::Job.should have_received(:enqueue).with(on_completion_job, on_completion_job_options)
+      expect(Delayed::Job).to have_received(:enqueue).with(on_completion_job, on_completion_job_options)
     end
 
     it "destroys the job group" do
-      job_group.should have_been_destroyed
+      expect(job_group).to have_been_destroyed
     end
   end
 
   shared_examples "the job group was not completed" do
     it "does not queue the completion job" do
-      Delayed::Job.should_not have_received(:enqueue)
+      expect(Delayed::Job).not_to have_received(:enqueue)
     end
 
     it "does not destroy the job group" do
-      job_group.should_not have_been_destroyed
+      expect(job_group).not_to have_been_destroyed
     end
   end
 
@@ -51,15 +49,16 @@
     context "when no jobs exist" do
       before { job_group.mark_queueing_complete }
 
-      it { should be_queueing_complete }
+      it { is_expected.to be_queueing_complete }
       it_behaves_like "the job group was completed"
     end
 
     context "when no jobs exist but the job group is blocked" do
       let(:blocked) { true }
+
       before { job_group.mark_queueing_complete }
 
-      it { should be_queueing_complete }
+      it { is_expected.to be_queueing_complete }
       it_behaves_like "the job group was not completed"
     end
 
@@ -69,7 +68,7 @@
         job_group.mark_queueing_complete
       end
 
-      it { should be_queueing_complete }
+      it { is_expected.to be_queueing_complete }
       it_behaves_like "the job group was not completed"
     end
   end
@@ -117,11 +116,11 @@
       include_context "complete job and check job group complete"
 
       it "queues the completion job with empty options" do
-        Delayed::Job.should have_received(:enqueue).with(on_completion_job, {})
+        expect(Delayed::Job).to have_received(:enqueue).with(on_completion_job, {})
       end
 
       it "destroys the job group" do
-        job_group.should have_been_destroyed
+        expect(job_group).to have_been_destroyed
       end
     end
 
@@ -131,11 +130,11 @@
       include_context "complete job and check job group complete"
 
       it "doesn't queues the non-existent completion job" do
-        Delayed::Job.should_not have_received(:enqueue)
+        expect(Delayed::Job).not_to have_received(:enqueue)
       end
 
       it "destroys the job group" do
-        job_group.should have_been_destroyed
+        expect(job_group).to have_been_destroyed
       end
     end
   end
@@ -149,7 +148,7 @@
 
     shared_examples "it enqueues the job in the correct blocked state" do
       it "enqueues the job in the same blocked state as the job group" do
-        Delayed::Job.should have_received(:enqueue).with(job, job_group_id: job_group.id, blocked: blocked)
+        expect(Delayed::Job).to have_received(:enqueue).with(job, job_group_id: job_group.id, blocked: blocked)
       end
     end
 
@@ -169,7 +168,7 @@
         job_group.unblock
       end
 
-      its(:blocked?) { should be(false) }
+      its(:blocked?) { is_expected.to be(false) }
     end
 
     context "when the JobGroup is blocked" do
@@ -184,10 +183,10 @@
           Timecop.freeze(unblock_time) { job_group.unblock }
         end
 
-        its(:blocked?) { should be(false) }
+        its(:blocked?) { is_expected.to be(false) }
 
         it "sets the job's run_at to the unblocked time" do
-          job.reload.run_at.should eq unblock_time
+          expect(job.reload.run_at).to eq unblock_time
         end
 
         it_behaves_like "the job group was not completed"
@@ -199,7 +198,7 @@
           job_group.unblock
         end
 
-        its(:blocked?) { should be(false) }
+        its(:blocked?) { is_expected.to be(false) }
         it_behaves_like "the job group was completed"
       end
     end
@@ -214,15 +213,15 @@
     end
 
     it "destroys the job group" do
-      job_group.should have_been_destroyed
+      expect(job_group).to have_been_destroyed
     end
 
     it "destroys queued jobs" do
-      queued_job.should have_been_destroyed
+      expect(queued_job).to have_been_destroyed
     end
 
     it "does not destroy running jobs" do
-      running_job.should_not have_been_destroyed
+      expect(running_job).not_to have_been_destroyed
     end
   end
 
diff --git a/spec/delayed/job_groups/plugin_spec.rb b/spec/delayed/job_groups/plugin_spec.rb
index 9811b8b..3e81080 100644
--- a/spec/delayed/job_groups/plugin_spec.rb
+++ b/spec/delayed/job_groups/plugin_spec.rb
@@ -1,77 +1,72 @@
-# encoding: UTF-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Delayed::JobGroups::Plugin do
-
-  before(:all) do
+  before do
     @old_max_attempts = Delayed::Worker.max_attempts
     Delayed::Worker.max_attempts = 2
-  end
 
-  after(:all) do
-    Delayed::Worker.max_attempts = @old_max_attempts
-  end
-
-  before(:each) do
     CompletionJob.invoked = false
     CancellationJob.invoked = false
   end
 
+  after do
+    Delayed::Worker.max_attempts = @old_max_attempts
+  end
+
   let!(:job_group) { Delayed::JobGroups::JobGroup.create!(on_completion_job: CompletionJob.new) }
 
   it "runs the completion job after completing other jobs" do
     job_group.enqueue(NoOpJob.new)
     job_group.enqueue(NoOpJob.new)
     job_group.mark_queueing_complete
-    job_group_count.should eq 1
-    queued_job_count.should eq 2
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 2
 
     # Run our first job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(false)
-    job_group_count.should eq 1
-    queued_job_count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 1
 
     # Run our second job which should enqueue the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(false)
-    job_group_count.should eq 0
-    queued_job_count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 0
+    expect(queued_job_count).to eq 1
 
     # Now we should run the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(true)
-    queued_job_count.should eq 0
+    expect(CompletionJob.invoked).to be(true)
+    expect(queued_job_count).to eq 0
   end
 
   it "only runs the completion job after queueing is completed" do
     job_group.enqueue(NoOpJob.new)
     job_group.enqueue(NoOpJob.new)
-    job_group_count.should eq 1
-    queued_job_count.should eq 2
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 2
 
     # Run our first job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(false)
-    job_group_count.should eq 1
-    queued_job_count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 1
 
     # Run our second job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(false)
-    job_group_count.should eq 1
-    queued_job_count.should eq 0
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 0
 
     # Mark queueing complete which should queue the completion job
     job_group.mark_queueing_complete
-    job_group_count.should eq 0
-    queued_job_count.should eq 1
+    expect(job_group_count).to eq 0
+    expect(queued_job_count).to eq 1
 
     # Now we should run the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(true)
-    queued_job_count.should eq 0
+    expect(CompletionJob.invoked).to be(true)
+    expect(queued_job_count).to eq 0
   end
 
   describe "job failures" do
@@ -83,15 +78,15 @@
         job_group.enqueue(FailingJob.new)
         job_group.enqueue(NoOpJob.new)
         job_group.mark_queueing_complete
-        queued_job_count.should eq 2
-        job_group_count.should eq 1
+        expect(queued_job_count).to eq 2
+        expect(job_group_count).to eq 1
 
         # Run the job which should fail and cancel the JobGroup
         Delayed::Worker.new.work_off(1)
-        CompletionJob.invoked.should be(false)
-        failed_job_count.should eq 1
-        queued_job_count.should eq 0
-        job_group_count.should eq 0
+        expect(CompletionJob.invoked).to be(false)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 0
+        expect(job_group_count).to eq 0
       end
     end
 
@@ -105,15 +100,15 @@
         job_group.enqueue(FailingJob.new)
         job_group.enqueue(NoOpJob.new)
         job_group.mark_queueing_complete
-        queued_job_count.should eq 2
-        job_group_count.should eq 1
+        expect(queued_job_count).to eq 2
+        expect(job_group_count).to eq 1
 
         # Run the job which should fail don't cancel the JobGroup
         Delayed::Worker.new.work_off(1)
-        CancellationJob.invoked.should be(false)
-        failed_job_count.should eq 1
-        queued_job_count.should eq 1
-        job_group_count.should eq 1
+        expect(CancellationJob.invoked).to be(false)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 1
+        expect(job_group_count).to eq 1
       end
     end
   end
@@ -121,12 +116,12 @@
   it "doesn't retry failed jobs if the job group has been canceled" do
     job_group.cancel
     Delayed::Job.enqueue(FailingJob.new, job_group_id: job_group.id)
-    queued_job_count.should eq 1
+    expect(queued_job_count).to eq 1
 
     # Run the job which should fail and should not queue a retry
     Delayed::Worker.new.work_off(1)
-    failed_job_count.should eq 1
-    queued_job_count.should eq 0
+    expect(failed_job_count).to eq 1
+    expect(queued_job_count).to eq 0
   end
 
   it "doesn't run jobs until they're unblocked" do
@@ -136,32 +131,32 @@
     job_group.enqueue(NoOpJob.new)
     job_group.enqueue(NoOpJob.new)
     job_group.mark_queueing_complete
-    Delayed::Job.count.should eq 2
+    expect(Delayed::Job.count).to eq 2
 
     # No jobs should run because they're blocked
     (successes, failures) = Delayed::Worker.new.work_off
-    successes.should eq 0
-    failures.should eq 0
-    Delayed::Job.count.should eq 2
+    expect(successes).to eq 0
+    expect(failures).to eq 0
+    expect(Delayed::Job.count).to eq 2
 
     job_group.unblock
 
     # Run our first job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(false)
-    job_group_count.should eq 1
-    Delayed::Job.count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(Delayed::Job.count).to eq 1
 
     # Run our second job which should enqueue the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(false)
-    job_group_count.should eq 0
-    Delayed::Job.count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 0
+    expect(Delayed::Job.count).to eq 1
 
     # Now we should run the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be(true)
-    Delayed::Job.count.should eq 0
+    expect(CompletionJob.invoked).to be(true)
+    expect(Delayed::Job.count).to eq 0
   end
 
   context "when a cancellation job is provided" do
@@ -176,23 +171,23 @@
       job_group.enqueue(FailingJob.new)
       job_group.enqueue(NoOpJob.new)
       job_group.mark_queueing_complete
-      queued_job_count.should eq 2
-      job_group_count.should eq 1
+      expect(queued_job_count).to eq 2
+      expect(job_group_count).to eq 1
 
       # Run the job which should fail and cancel the JobGroup
       Delayed::Worker.new.work_off(1)
-      CompletionJob.invoked.should be(false)
-      CancellationJob.invoked.should be(false)
-      failed_job_count.should eq 1
+      expect(CompletionJob.invoked).to be(false)
+      expect(CancellationJob.invoked).to be(false)
+      expect(failed_job_count).to eq 1
 
-      queued_job_count.should eq 1
-      job_group_count.should eq 0
+      expect(queued_job_count).to eq 1
+      expect(job_group_count).to eq 0
 
       # Now we should run the cancellation job
       Delayed::Worker.new.work_off(1)
-      CompletionJob.invoked.should be(false)
-      CancellationJob.invoked.should be(true)
-      queued_job_count.should eq 0
+      expect(CompletionJob.invoked).to be(false)
+      expect(CancellationJob.invoked).to be(true)
+      expect(queued_job_count).to eq 0
     end
 
     it "runs the cancellation job after the job group is cancelled" do
@@ -201,14 +196,14 @@
       job_group.mark_queueing_complete
       job_group.cancel
 
-      #cancellation job should be queued
-      queued_job_count.should eq 1
-      CancellationJob.invoked.should be(false)
+      # cancellation job should be queued
+      expect(queued_job_count).to eq 1
+      expect(CancellationJob.invoked).to be(false)
 
       # Run the cancellation job
       Delayed::Worker.new.work_off(1)
-      CancellationJob.invoked.should be(true)
-      queued_job_count.should eq 0
+      expect(CancellationJob.invoked).to be(true)
+      expect(queued_job_count).to eq 0
     end
   end
 
@@ -219,21 +214,21 @@
       job_group.enqueue(NoOpJob.new)
       job_group.enqueue(NoOpJob.new)
       job_group.mark_queueing_complete
-      job_group_count.should eq 1
-      queued_job_count.should eq 2
-      failed_job_count.should eq 0
+      expect(job_group_count).to eq 1
+      expect(queued_job_count).to eq 2
+      expect(failed_job_count).to eq 0
 
       # Run our first job
       Delayed::Worker.new.work_off(1)
-      job_group_count.should eq 1
-      queued_job_count.should eq 1
-      failed_job_count.should eq 0
+      expect(job_group_count).to eq 1
+      expect(queued_job_count).to eq 1
+      expect(failed_job_count).to eq 0
 
       # Run our second job which should delete the job group
       Delayed::Worker.new.work_off(1)
-      job_group_count.should eq 0
-      queued_job_count.should eq 0
-      failed_job_count.should eq 0
+      expect(job_group_count).to eq 0
+      expect(queued_job_count).to eq 0
+      expect(failed_job_count).to eq 0
     end
   end
 
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index b7dcd18..6ff298c 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,14 +1,14 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require 'simplecov'
 require 'coveralls'
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+)
+
 SimpleCov.start do
- add_filter 'spec'
+  add_filter 'spec'
 end
 
 require 'rspec/its'
@@ -31,8 +31,8 @@
 ActiveRecord::Migration.verbose = false
 
 db_adapter = ENV.fetch('ADAPTER', 'sqlite3')
-config = YAML.load(File.read('spec/db/database.yml'))
-ActiveRecord::Base.establish_connection(config[db_adapter])
+db_config = YAML.safe_load(File.read('spec/db/database.yml'))
+ActiveRecord::Base.establish_connection(db_config[db_adapter])
 require 'db/schema'
 
 RSpec.configure do |config|
@@ -42,15 +42,15 @@
     DatabaseCleaner.clean_with(:truncation)
   end
 
-  config.before(:each) do
+  config.before do
     DatabaseCleaner.strategy = :transaction
   end
 
-  config.before(:each) do
+  config.before do
     DatabaseCleaner.start
   end
 
-  config.after(:each) do
+  config.after do
     DatabaseCleaner.clean
   end
 end
diff --git a/spec/support/destroyed_model.rb b/spec/support/destroyed_model.rb
index 19a4f44..9852437 100644
--- a/spec/support/destroyed_model.rb
+++ b/spec/support/destroyed_model.rb
@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 RSpec::Matchers.define :have_been_destroyed do
   match do |actual|
@@ -6,10 +6,10 @@
   end
 
   description do
-    "model should have been destroyed"
+    'model should have been destroyed'
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected #{actual.class}(id: #{actual.id}) to have been destroyed"
   end
 end