diff --git a/.rubocop.yml b/.rubocop.yml
index e3b46bc..3bbf957 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,13 +1,12 @@
-require: rubocop-rails
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/HashSyntax:
-  EnforcedStyle: hash_rockets
-
-Style/Documentation:
-  Enabled: false
+inherit_gem:
+  rubocop-github:
+  - config/default.yml # generic Ruby rules and cops
+  - config/rails.yml # Rails-specific rules and cops
 
 AllCops:
   NewCops: enable
+  Exclude:
+    - "test/dummy/db/schema.rb"
+    - "bin/*"
+    - "test/dummy/db/migrate/*_engine.rb"
+    - vendor/bundle/**/*
diff --git a/Gemfile b/Gemfile
index 147ce62..e0e872a 100644
--- a/Gemfile
+++ b/Gemfile
@@ -3,3 +3,20 @@ source "https://rubygems.org"
 gemspec
 
 gem "debug"
+
+group :development do
+  gem "rubocop-github", require: false
+  gem "rubocop-performance", require: false
+  gem "rubocop-rails", require: false
+  gem "ruby-lsp", require: false
+
+  gem "delayed_job_active_record",  "~> 4.0"
+  gem "mini_magick",  "~> 5.0.1"
+  gem "minitest-reporters", "~> 1.0"
+  gem "mocha",  "~> 2.0"
+  gem "pry",  "~> 0.10"
+  gem "simplecov",  "~> 0.8"
+  gem "spawnling",  "~> 2.1"
+  gem "sqlite3",  "~> 2.0"
+  gem "zencoder",  "~> 2.5"
+end
diff --git a/Rakefile b/Rakefile
index 92209e1..64c2c32 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,34 +1,31 @@
 begin
-  require 'bundler/setup'
+  require "bundler/setup"
 rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 
-require 'rdoc/task'
+require "rdoc/task"
 
 RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Fogged'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Fogged"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
-load 'rails/tasks/engine.rake'
-
-
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
 
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
   t.verbose = false
 end
 
-
 task default: :test
diff --git a/app/controllers/fogged/resources_controller.rb b/app/controllers/fogged/resources_controller.rb
index 0df2fc8..fbd214d 100644
--- a/app/controllers/fogged/resources_controller.rb
+++ b/app/controllers/fogged/resources_controller.rb
@@ -61,9 +61,9 @@
 # }
 module Fogged
   class ResourcesController < Fogged.parent_controller.constantize
-    before_action :select_resourceables, :only => :index
-    before_action :select_resource, :only => %i[confirm destroy show update]
-    skip_before_action :verify_authenticity_token, :only => :zencoder_notification
+    before_action :select_resourceables, only: :index
+    before_action :select_resource, only: %i[confirm destroy show update]
+    skip_before_action :verify_authenticity_token, only: :zencoder_notification
 
     # List all resources. Parameter type is mandatory. It indicates in which
     # "context" you want all resources. You can refine the search, using
@@ -89,10 +89,10 @@ def index
         resourceable.resources.search(params)
       end
 
-      render :json => paginate(resources.flatten.uniq),
-             :adapter => :json,
-             :meta => @meta,
-             :each_serializer => ResourceSerializer
+      render json: paginate(resources.flatten.uniq),
+             adapter: :json,
+             meta: @meta,
+             each_serializer: ResourceSerializer
     end
 
     # Get the resource.
@@ -107,9 +107,9 @@ def index
     # Raises 404 if the Resource is not found
     # Raises 500 if an error occurs
     def show
-      render :json => @resource,
-             :adapter => :json,
-             :serializer => ResourceSerializer
+      render json: @resource,
+             adapter: :json,
+             serializer: ResourceSerializer
     end
 
     # Create a new resource. You must provide a filename (example: foo.png)
@@ -137,12 +137,12 @@ def create
       resource_attributes = resource_params.except(:filename)
       resource_attributes[:extension] = extension(resource_params.require(:filename))
 
-      resource = Resource.create!(resource_attributes.merge(:uploading => true))
+      resource = Resource.create!(resource_attributes.merge(uploading: true))
 
-      render :json => resource,
-             :adapter => :json,
-             :serializer => ResourceSerializer,
-             :include_upload_url => true
+      render json: resource,
+             adapter: :json,
+             serializer: ResourceSerializer,
+             include_upload_url: true
     end
 
     # Update a Resource. You can update the name of a Resource or its context
@@ -183,7 +183,7 @@ def update
     # Raises 500 if a server errors occurs
     def confirm
       @resource.process!
-      @resource.update!(:uploading => false)
+      @resource.update!(uploading: false)
       show
     end
 
@@ -204,15 +204,15 @@ def destroy
     end
 
     def zencoder_notification
-      if (resource = Resource.find_by(:encoding_job_id => job_params[:id])) &&
+      if (resource = Resource.find_by(encoding_job_id: job_params[:id])) &&
          (file = params[:outputs].try(:first)) &&
          job_params[:state] == "finished"
 
         resource.update!(
-          :encoding_progress => 100,
-          :width => file[:width],
-          :height => file[:height],
-          :duration => file[:duration_in_ms].to_f / 1000.0
+          encoding_progress: 100,
+          width: file[:width],
+          height: file[:height],
+          duration: file[:duration_in_ms].to_f / 1000.0
         )
       end
 
@@ -225,7 +225,7 @@ def select_resourceables
       ids = params[:type_id] || params[:type_ids]
       ids = [ids] unless ids.respond_to?(:to_ary)
       @resourceables = resourceable_clazz.all
-      @resourceables = resourceable_clazz.where(:id => ids) if ids.try(:any?)
+      @resourceables = resourceable_clazz.where(id: ids) if ids.try(:any?)
     end
 
     def resourceable_clazz
@@ -259,9 +259,9 @@ def paginate(result)
       offset = (page - 1) * count
       total = result.size
       @meta = {
-        :pagination => {
-          :total => total,
-          :remaining => [total - offset - count, 0].max
+        pagination: {
+          total:,
+          remaining: [total - offset - count, 0].max
         }
       }
 
diff --git a/app/jobs/fogged/resources/awsthumbnailjob.rb b/app/jobs/fogged/resources/awsthumbnailjob.rb
index 03e34ae..0637373 100644
--- a/app/jobs/fogged/resources/awsthumbnailjob.rb
+++ b/app/jobs/fogged/resources/awsthumbnailjob.rb
@@ -6,7 +6,7 @@ def perform(resource)
 
         step = 100 / Fogged.thumbnail_sizes.size
         Fogged.thumbnail_sizes.each_with_index do |size, index|
-          Tempfile.open(source_from(resource.url), :binmode => true, :encoding => "ascii-8bit") do |source|
+          Tempfile.open(source_from(resource.url), binmode: true, encoding: "ascii-8bit") do |source|
             Tempfile.open(["thumbnail", ".png"]) do |t|
               source.write(URI.parse(resource.url).read)
               source.flush
@@ -18,17 +18,17 @@ def perform(resource)
               end
 
               Fogged.resources.files.create(
-                :key => resource.send(:fogged_name_for, :thumbnails, index),
-                :body => File.read(t.path),
-                :public => true,
-                :content_type => Mime[:png].to_s
+                key: resource.send(:fogged_name_for, :thumbnails, index),
+                body: File.read(t.path),
+                public: true,
+                content_type: Mime[:png].to_s
               )
             end
           end
 
           resource.increment!(:encoding_progress, step)
         end
-        resource.update!(:encoding_progress => 100)
+        resource.update!(encoding_progress: 100)
       end
 
       private
diff --git a/app/models/fogged/resource.rb b/app/models/fogged/resource.rb
index 46e9949..091e05f 100644
--- a/app/models/fogged/resource.rb
+++ b/app/models/fogged/resource.rb
@@ -1,6 +1,6 @@
 module Fogged
   class Resource < ActiveRecord::Base
-    validates :extension, :content_type, :name, :presence => true
+    validates :extension, :content_type, :name, presence: true
 
     before_save :ensure_token
     after_destroy :destroy_fogged_file
@@ -11,7 +11,7 @@ def self.search(params)
       if params[:query]
         results = results.where(
           "#{table_name}.name LIKE :query",
-          :query => "%#{params[:query].to_s.downcase}%"
+          query: "%#{params[:query].to_s.downcase}%"
         )
       end
 
@@ -34,28 +34,30 @@ def url
 
     def h264_url
       return unless video? && Fogged.zencoder_enabled
+
       url.gsub(fogged_name, fogged_name_for(:h264))
     end
 
     def mpeg_url
       return unless video? && Fogged.zencoder_enabled
+
       url.gsub(fogged_name, fogged_name_for(:mpeg))
     end
 
     def webm_url
       return unless video? && Fogged.zencoder_enabled
+
       url.gsub(fogged_name, fogged_name_for(:webm))
     end
 
     def thumbnail_urls
       return unless Fogged.active_job_enabled
 
-      case
-      when video? && Fogged.zencoder_enabled
+      if video? && Fogged.zencoder_enabled
         5.times.map do |n|
           url.gsub(fogged_name, fogged_name_for(:thumbnails, n))
         end
-      when image? && Fogged.minimagick_enabled
+      elsif image? && Fogged.minimagick_enabled
         Fogged.thumbnail_sizes.size.times.map do |n|
           url.gsub(fogged_name, fogged_name_for(:thumbnails, n))
         end
@@ -75,6 +77,7 @@ def encoding?
              (video? || (image? && Fogged.active_job_enabled))
         return
       end
+
       encoding_progress < 100
     end
 
@@ -97,9 +100,9 @@ def fogged_file
 
     def create_fogged_file(files)
       files.create(
-        :key => fogged_name,
-        :body => "",
-        :content_type => content_type
+        key: fogged_name,
+        body: "",
+        content_type:
       ).tap do |file|
         file.public = "public_read"
         file.save
@@ -109,15 +112,17 @@ def create_fogged_file(files)
     def find_size!
       if Fogged.test_enabled
         return update!(
-          :width => 800,
-          :height => 600
+          width: 800,
+          height: 600
         )
       end
       size = FastImage.size(url)
+      return if size.blank?
+
       update!(
-        :width => size.first,
-        :height => size.second
-      ) unless size.blank?
+        width: size.first,
+        height: size.second
+      )
     end
 
     def encode!(inline = false)
@@ -133,7 +138,7 @@ def ensure_token
     def generate_token
       loop do
         a_token = SecureRandom.hex(16)
-        break a_token unless Resource.find_by(:token => a_token)
+        break a_token unless Resource.find_by(token: a_token)
       end
     end
 
@@ -154,7 +159,7 @@ def fogged_name_for(type, number = 0)
       when :thumbnails
         "#{token}-thumbnail-#{number}.png"
       else
-        fail(ArgumentError, "Can't get fogged name of #{type}")
+        raise(ArgumentError, "Can't get fogged name of #{type}")
       end
     end
 
diff --git a/app/models/fogged/resources/awsencoder.rb b/app/models/fogged/resources/awsencoder.rb
index 8aa9535..5f2f44a 100644
--- a/app/models/fogged/resources/awsencoder.rb
+++ b/app/models/fogged/resources/awsencoder.rb
@@ -15,17 +15,19 @@ def encode!(inline = false)
       def encode_image(inline = false)
         return unless Fogged.active_job_enabled
         return unless Fogged.minimagick_enabled
+
         if inline
           AWSThumbnailJob.perform_now(@resource)
         else
           AWSThumbnailJob.perform_later(@resource)
         end
 
-        @resource.update!(:encoding_progress => 0)
+        @resource.update!(encoding_progress: 0)
       end
 
       def encode_video
         return unless Fogged.zencoder_enabled
+
         outputs = output
         if Fogged.zencoder_additional_outputs_block
           additional_outputs = Fogged.zencoder_additional_outputs_block.call(bucket, @resource)
@@ -34,47 +36,45 @@ def encode_video
         end
 
         params = {
-          :input => @resource.url,
-          :region => "europe",
-          :download_connections => 5,
-          :output => outputs
+          input: @resource.url,
+          region: "europe",
+          download_connections: 5,
+          output: outputs
         }
 
-        if Fogged.zencoder_notification_url
-          params[:notifications] = [Fogged.zencoder_notification_url]
-        end
+        params[:notifications] = [Fogged.zencoder_notification_url] if Fogged.zencoder_notification_url
 
         @resource.update!(
-          :encoding_job_id => Zencoder::Job.create(params).body["id"].to_s,
-          :encoding_progress => 0
+          encoding_job_id: Zencoder::Job.create(params).body["id"].to_s,
+          encoding_progress: 0
         )
       end
 
       def output
         [
           {
-            :url => "s3://#{bucket}/#{fogged_name_for(:h264)}",
-            :video_codec => "h264",
-            :public => 1,
-            :thumbnails => {
-              :number => 5,
-              :format => "png",
-              :base_url => "s3://#{bucket}",
-              :filename => "#{@resource.token}-thumbnail-{{number}}",
-              :public => 1,
-              :width => 1920,
-              :height => 1080
+            url: "s3://#{bucket}/#{fogged_name_for(:h264)}",
+            video_codec: "h264",
+            public: 1,
+            thumbnails: {
+              number: 5,
+              format: "png",
+              base_url: "s3://#{bucket}",
+              filename: "#{@resource.token}-thumbnail-{{number}}",
+              public: 1,
+              width: 1920,
+              height: 1080
             }
           },
           {
-            :url => "s3://#{bucket}/#{fogged_name_for(:mpeg)}",
-            :video_codec => "mpeg4",
-            :public => 1
+            url: "s3://#{bucket}/#{fogged_name_for(:mpeg)}",
+            video_codec: "mpeg4",
+            public: 1
           },
           {
-            :url => "s3://#{bucket}/#{fogged_name_for(:webm)}",
-            :video_codec => "vp8",
-            :public => 1
+            url: "s3://#{bucket}/#{fogged_name_for(:webm)}",
+            video_codec: "vp8",
+            public: 1
           }
         ]
       end
diff --git a/app/models/fogged/resources/encoder.rb b/app/models/fogged/resources/encoder.rb
index 9b69d54..baa41a2 100644
--- a/app/models/fogged/resources/encoder.rb
+++ b/app/models/fogged/resources/encoder.rb
@@ -6,7 +6,7 @@ def self.for(resource)
       end
 
       def self.provider
-        return :AWS if Fogged.provider == :aws
+        :AWS if Fogged.provider == :aws
       end
     end
   end
diff --git a/config/routes.rb b/config/routes.rb
index 6e0d465..3349d56 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -1,6 +1,6 @@
 Fogged::Engine.routes.draw do
   resources :resources do
-    put :confirm, :on => :member
-    post :zencoder_notification, :on => :collection
+    put :confirm, on: :member
+    post :zencoder_notification, on: :collection
   end
 end
diff --git a/db/migrate/20141103143408_create_fogged_resources.rb b/db/migrate/20141103143408_create_fogged_resources.rb
index 2169d80..f4dc7bd 100644
--- a/db/migrate/20141103143408_create_fogged_resources.rb
+++ b/db/migrate/20141103143408_create_fogged_resources.rb
@@ -1,13 +1,13 @@
 class CreateFoggedResources < ActiveRecord::Migration
   def change
     create_table :fogged_resources do |t|
-      t.string :name, :null => false
-      t.string :token, :null => false
+      t.string :name, null: false
+      t.string :token, null: false
       t.integer :width
       t.integer :height
-      t.string :extension, :null => false
+      t.string :extension, null: false
       t.boolean :uploading
-      t.string :content_type, :null => false
+      t.string :content_type, null: false
       t.integer :encoding_progress
       t.string :encoding_job_id
       t.integer :duration
diff --git a/fogged.gemspec b/fogged.gemspec
index d7c01c3..9924771 100644
--- a/fogged.gemspec
+++ b/fogged.gemspec
@@ -24,16 +24,5 @@ Gem::Specification.new do |s|
   s.add_dependency "mime-types", ">= 1.15.0"
   s.add_dependency "rails", ">= 5.0"
 
-  s.add_development_dependency "delayed_job_active_record", "~> 4.0"
-  s.add_development_dependency "mini_magick", "~> 5.0.1"
-  s.add_development_dependency "minitest-reporters", "~> 1.0"
-  s.add_development_dependency "mocha", "~> 2.0"
-  s.add_development_dependency "pry", "~> 0.10"
-  s.add_development_dependency "rubocop"
-  s.add_development_dependency "rubocop-rails"
-  s.add_development_dependency "simplecov", "~> 0.8"
-  s.add_development_dependency "spawnling", "~> 2.1"
-  s.add_development_dependency "sqlite3", "~> 2.0"
-  s.add_development_dependency "zencoder", "~> 2.5"
   s.metadata["rubygems_mfa_required"] = "true"
 end
diff --git a/lib/fogged.rb b/lib/fogged.rb
index d5fbe6f..5767582 100644
--- a/lib/fogged.rb
+++ b/lib/fogged.rb
@@ -27,7 +27,7 @@ module Fogged
 
   # zencoder
   mattr_accessor :zencoder_notification_url do
-    ENV["ZENCODER_NOTIFICATION_URL"]
+    ENV.fetch("ZENCODER_NOTIFICATION_URL", nil)
   end
 
   # thumbnail sizes
@@ -55,7 +55,7 @@ def self.resources
     when :aws
       Fogged._resources = aws_resources
     else
-      fail(ArgumentError, "Provider #{Fogged.provider} is not available!")
+      raise(ArgumentError, "Provider #{Fogged.provider} is not available!")
     end
   end
 
@@ -64,28 +64,26 @@ def self.test_mode!
     Fogged._resources = test_resources
   end
 
-  private
-
   def self.test_resources
     Fog.mock!
     Fogged.storage = Fog::Storage.new(
-      :provider => "AWS",
-      :aws_access_key_id => "XXX",
-      :aws_secret_access_key => "XXX"
+      provider: "AWS",
+      aws_access_key_id: "XXX",
+      aws_secret_access_key: "XXX"
     )
     Fogged.aws_key = "XXX"
     Fogged.aws_secret = "XXX"
     Fogged.aws_bucket = "test"
-    Fogged.storage.directories.create(:key => "test")
+    Fogged.storage.directories.create(key: "test")
   end
 
   def self.aws_resources
     storage_options = {
-      :provider => "AWS",
-      :aws_access_key_id => Fogged.aws_key,
-      :aws_secret_access_key => Fogged.aws_secret
+      provider: "AWS",
+      aws_access_key_id: Fogged.aws_key,
+      aws_secret_access_key: Fogged.aws_secret
     }
-    storage_options.merge!(:region => Fogged.aws_region) if Fogged.aws_region
+    storage_options.merge!(region: Fogged.aws_region) if Fogged.aws_region
     Fogged.storage = Fog::Storage.new(storage_options)
 
     Fogged.storage.directories.get(Fogged.aws_bucket)
@@ -94,11 +92,11 @@ def self.aws_resources
   def self.check_config
     case Fogged.provider
     when :aws
-      fail(ArgumentError, "AWS key is mandatory") unless Fogged.aws_key
-      fail(ArgumentError, "AWS secret is mandatory") unless Fogged.aws_secret
-      fail(ArgumentError, "AWS bucket is mandatory") unless Fogged.aws_bucket
+      raise(ArgumentError, "AWS key is mandatory") unless Fogged.aws_key
+      raise(ArgumentError, "AWS secret is mandatory") unless Fogged.aws_secret
+      raise(ArgumentError, "AWS bucket is mandatory") unless Fogged.aws_bucket
     else
-      fail(ArgumentError, "Provider #{Fogged.provider} is not available!")
+      raise(ArgumentError, "Provider #{Fogged.provider} is not available!")
     end
   end
 end
diff --git a/lib/fogged/has_many_resources.rb b/lib/fogged/has_many_resources.rb
index 24a79cd..41ebd6f 100644
--- a/lib/fogged/has_many_resources.rb
+++ b/lib/fogged/has_many_resources.rb
@@ -4,17 +4,16 @@ module HasManyResources
 
     module ClassMethods
       DEFAULT_OPTIONS = {
-        :dependent => :destroy,
-        :class_name => "Fogged::Resource"
+        dependent: :destroy,
+        class_name: "Fogged::Resource"
       }
 
       def has_many_resources(*args)
         options = args.extract_options!
-        unless options.include?(:through)
-          fail(ArgumentError, ":through option is mandatory")
-        end
+        raise(ArgumentError, ":through option is mandatory") unless options.include?(:through)
+
         has_many :resources, **DEFAULT_OPTIONS.merge(options)
-        validate :_check_resources, :unless => -> { resources.empty? }
+        validate :_check_resources, unless: -> { resources.empty? }
       end
     end
 
@@ -22,9 +21,10 @@ def has_many_resources(*args)
 
     def _check_resources
       return if resources.to_a.select(&:uploading).empty?
+
       errors.add(:resources, I18n.t("fogged.resources.still_uploading"))
     end
   end
 end
 
-ActiveRecord::Base.send(:include, Fogged::HasManyResources)
+ActiveRecord::Base.include Fogged::HasManyResources
diff --git a/lib/fogged/has_one_resource.rb b/lib/fogged/has_one_resource.rb
index d67460e..6f45a64 100644
--- a/lib/fogged/has_one_resource.rb
+++ b/lib/fogged/has_one_resource.rb
@@ -4,13 +4,13 @@ module HasOneResource
 
     module ClassMethods
       DEFAULT_OPTIONS = {
-        :dependent => :destroy,
-        :class_name => "Fogged::Resource"
+        dependent: :destroy,
+        class_name: "Fogged::Resource"
       }
 
       def has_one_resource(*args)
         belongs_to :resource, **DEFAULT_OPTIONS.merge(args.extract_options!)
-        validate :_check_resource, :unless => -> { resource.blank? }
+        validate :_check_resource, unless: -> { resource.blank? }
 
         define_method(:resource_id) do
           resource.try(:id)
@@ -26,9 +26,10 @@ def has_one_resource(*args)
 
     def _check_resource
       return unless resource.uploading
+
       errors.add(:resource, I18n.t("fogged.resource.still_uploading"))
     end
   end
 end
 
-ActiveRecord::Base.send(:include, Fogged::HasOneResource)
+ActiveRecord::Base.include Fogged::HasOneResource
diff --git a/lib/fogged/utils.rb b/lib/fogged/utils.rb
index 3c5c696..9860d20 100644
--- a/lib/fogged/utils.rb
+++ b/lib/fogged/utils.rb
@@ -2,9 +2,9 @@ module Fogged
   def self.directory_public_url(directory_name)
     case Fogged.provider
     when :aws
-      Fogged.storage.request_url(:bucket_name => directory_name)
+      Fogged.storage.request_url(bucket_name: directory_name)
     else
-      fail(ArgumentError, "Provider #{Fogged.provider} is not available!")
+      raise(ArgumentError, "Provider #{Fogged.provider} is not available!")
     end
   end
 
@@ -15,8 +15,8 @@ def self.resources_public_url
   def self.file_public_url(key, directory = Fogged.resources.key)
     Fogged.storage.try(
       :request_url,
-      :bucket_name => directory,
-      :object_name => key
+      bucket_name: directory,
+      object_name: key
     )
   end
 
diff --git a/test/controllers/concerns/json_test_helper.rb b/test/controllers/concerns/json_test_helper.rb
index 379773d..3aa6cea 100644
--- a/test/controllers/concerns/json_test_helper.rb
+++ b/test/controllers/concerns/json_test_helper.rb
@@ -20,20 +20,20 @@ def assert_json_objects(objects, json_objects, *fields)
   end
 
   def assert_json_object(object, json_object, *fields)
-    fail(ArgumentError, "fields can't be empty") if fields.blank?
+    raise(ArgumentError, "fields can't be empty") if fields.blank?
+
     fields.each do |field|
       expected_value = object.send(field)
 
-      case
-      when expected_value.is_a?(ActiveSupport::TimeWithZone)
+      if expected_value.is_a?(ActiveSupport::TimeWithZone)
         assert_equal expected_value.iso8601, json_object[field]
-      when expected_value.is_a?(Date)
+      elsif expected_value.is_a?(Date)
         assert_equal Oj.load(expected_value.to_json), json_object[field]
-      when expected_value.is_a?(Enumerable) && expected_value.all? { |e| e.is_a?(Hash) }
+      elsif expected_value.is_a?(Enumerable) && expected_value.all? { |e| e.is_a?(Hash) }
         assert_equal expected_value.map(&:symbolize_keys), json_object[field]
-      when expected_value.is_a?(Enumerable)
+      elsif expected_value.is_a?(Enumerable)
         assert_equal expected_value.sort, json_object[field].sort
-      when expected_value.is_a?(Symbol)
+      elsif expected_value.is_a?(Symbol)
         assert_equal expected_value.to_s, json_object[field]
       else
         assert_equal expected_value, json_object[field]
diff --git a/test/controllers/concerns/resource_test_helper.rb b/test/controllers/concerns/resource_test_helper.rb
index beea8e6..952196c 100644
--- a/test/controllers/concerns/resource_test_helper.rb
+++ b/test/controllers/concerns/resource_test_helper.rb
@@ -19,16 +19,15 @@ def assert_json_resources(resources, json_key = :resources)
     json = response_json[json_key]
     assert_json_objects(resources, json, :id, :url, :name)
     resources.zip([json].flatten).each do |resource, json_resource|
-      if json_resource[:upload_url]
-        assert_equal resource.upload_url.chop, json_resource[:upload_url].chop
-      end
+      assert_equal resource.upload_url.chop, json_resource[:upload_url].chop if json_resource[:upload_url]
 
       next unless resource.video?
-      [:h264_url, :mpeg_url, :webm_url, :thumbnail_urls].each do |field|
+
+      %i[h264_url mpeg_url webm_url thumbnail_urls].each do |field|
         if resource.send(field)
           assert_equal resource.send(field), json_resource[field]
         else
-          refute json_resource[field]
+          assert_not json_resource[field]
         end
       end
       assert_equal((resource.encoding_progress || 0), json_resource[:encoding_progress])
diff --git a/test/controllers/fogged/resources_controller/confirm_test.rb b/test/controllers/fogged/resources_controller/confirm_test.rb
index 3a7b065..75b2ea3 100644
--- a/test/controllers/fogged/resources_controller/confirm_test.rb
+++ b/test/controllers/fogged/resources_controller/confirm_test.rb
@@ -8,12 +8,12 @@ class ResourcesControllerConfirmTest < ActionController::TestCase
     test "should confirm resource" do
       resource = fogged_resources(:resource_png_1)
 
-      put :confirm, :params => { :id => resource.id }
+      put :confirm, params: { id: resource.id }
 
       assert_json_resource(resource.reload)
       assert_equal 800, resource.width
       assert_equal 600, resource.height
-      refute resource.encoding?
+      assert_not resource.encoding?
     end
 
     test "should confirm video resource with zencoder enabled" do
@@ -22,11 +22,11 @@ class ResourcesControllerConfirmTest < ActionController::TestCase
         Fogged.configure
 
         Zencoder::Job.expects(:create).returns(
-          OpenStruct.new(:body => create_output)
+          OpenStruct.new(body: create_output)
         )
         resource = fogged_resources(:resource_mov_1)
 
-        put :confirm, :params => { :id => resource.id }
+        put :confirm, params: { id: resource.id }
 
         assert_json_resource(resource.reload)
         assert resource.encoding_job_id
@@ -36,7 +36,7 @@ class ResourcesControllerConfirmTest < ActionController::TestCase
 
     test "should not confirm resource with invalid id" do
       assert_raise(ActiveRecord::RecordNotFound) do
-        put :confirm, :params => { :id => 123456 }
+        put :confirm, params: { id: 123_456 }
       end
     end
 
@@ -44,7 +44,7 @@ class ResourcesControllerConfirmTest < ActionController::TestCase
 
     def create_output
       {
-        :id => 1234567890
+        id: 1_234_567_890
       }.with_indifferent_access
     end
   end
diff --git a/test/controllers/fogged/resources_controller/create_test.rb b/test/controllers/fogged/resources_controller/create_test.rb
index 19def87..4d90c1b 100644
--- a/test/controllers/fogged/resources_controller/create_test.rb
+++ b/test/controllers/fogged/resources_controller/create_test.rb
@@ -8,15 +8,15 @@ class ResourcesControllerCreateTest < ActionController::TestCase
     def setup
       super
       @resource_params = {
-        :name => "Dummy",
-        :filename => "dummy.png",
-        :content_type => "image/png"
+        name: "Dummy",
+        filename: "dummy.png",
+        content_type: "image/png"
       }
     end
 
     test "should create resource" do
       assert_difference("Resource.count") do
-        post :create, :params => { :resource => @resource_params }
+        post :create, params: { resource: @resource_params }
       end
 
       assert_json_resource(Resource.last)
@@ -31,12 +31,12 @@ def setup
       end
     end
 
-    [:content_type, :name].each do |field|
+    %i[content_type name].each do |field|
       test "should not create resource without #{field}" do
         assert_no_difference("Resource.count") do
           assert_raise(ActiveRecord::RecordInvalid) do
             post :create,
-                 :params => { :resource => @resource_params.merge(field => "") }
+                 params: { resource: @resource_params.merge(field => "") }
           end
         end
       end
@@ -46,7 +46,7 @@ def setup
       assert_no_difference("Resource.count") do
         assert_raise(ActionController::ParameterMissing) do
           post :create,
-               :params => { :resource => @resource_params.except(:filename) }
+               params: { resource: @resource_params.except(:filename) }
         end
       end
     end
@@ -55,7 +55,7 @@ def setup
       assert_no_difference("Resource.count") do
         assert_raise(ActiveRecord::RecordInvalid) do
           post :create,
-               :params => { :resource => @resource_params.merge(:filename => "bar") }
+               params: { resource: @resource_params.merge(filename: "bar") }
         end
       end
     end
diff --git a/test/controllers/fogged/resources_controller/destroy_test.rb b/test/controllers/fogged/resources_controller/destroy_test.rb
index 1c87ca7..7032230 100644
--- a/test/controllers/fogged/resources_controller/destroy_test.rb
+++ b/test/controllers/fogged/resources_controller/destroy_test.rb
@@ -12,7 +12,7 @@ def setup
 
     test "should destroy resource" do
       assert_difference("Resource.count", -1) do
-        delete :destroy, :params => { :id => @resource }
+        delete :destroy, params: { id: @resource }
       end
 
       assert_response :no_content
@@ -22,7 +22,7 @@ def setup
     test "should not destroy resource with invalid id" do
       assert_no_difference("Resource.count") do
         assert_raise(ActiveRecord::RecordNotFound) do
-          delete :destroy, :params => { :id => 123456 }
+          delete :destroy, params: { id: 123_456 }
         end
       end
     end
diff --git a/test/controllers/fogged/resources_controller/show_test.rb b/test/controllers/fogged/resources_controller/show_test.rb
index e7c63f1..42e489e 100644
--- a/test/controllers/fogged/resources_controller/show_test.rb
+++ b/test/controllers/fogged/resources_controller/show_test.rb
@@ -7,26 +7,26 @@ class ResourcesControllerShowTest < ActionController::TestCase
 
     test "should show resource" do
       resource = fogged_resources(:resource_text_1)
-      get :show, :params => { :id => resource }
+      get :show, params: { id: resource }
       assert_json_resource(resource)
     end
 
     test "should show video resource" do
       resource = fogged_resources(:resource_mov_1)
-      get :show, :params => { :id => resource }
+      get :show, params: { id: resource }
       assert_json_resource(resource)
     end
 
     test "should show image resource" do
       resource = fogged_resources(:resource_png_1)
-      get :show, :params => { :id => resource }
+      get :show, params: { id: resource }
 
       assert_json_resource(resource)
     end
 
     test "should not show resource with invalid id" do
       assert_raise(ActiveRecord::RecordNotFound) do
-        get :show, :params => { :id => 1234567890 }
+        get :show, params: { id: 1_234_567_890 }
       end
     end
   end
diff --git a/test/controllers/fogged/resources_controller/update_test.rb b/test/controllers/fogged/resources_controller/update_test.rb
index 00fbc0c..cbcf5bf 100644
--- a/test/controllers/fogged/resources_controller/update_test.rb
+++ b/test/controllers/fogged/resources_controller/update_test.rb
@@ -12,9 +12,9 @@ def setup
 
     test "should update resource" do
       put :update,
-          :params => {
-            :id => @resource,
-            :resource => { :name => "Update" }
+          params: {
+            id: @resource,
+            resource: { name: "Update" }
           }
 
       assert_json_resource(@resource.reload)
@@ -23,9 +23,9 @@ def setup
     test "should not update resource with invalid id" do
       assert_raise(ActiveRecord::RecordNotFound) do
         put :update,
-            :params => {
-              :id => 1234567890,
-              :resource => { :name => "Update" }
+            params: {
+              id: 1_234_567_890,
+              resource: { name: "Update" }
             }
       end
     end
diff --git a/test/controllers/fogged/resources_controller/zencoder_notification_test.rb b/test/controllers/fogged/resources_controller/zencoder_notification_test.rb
index de8238d..26e4311 100644
--- a/test/controllers/fogged/resources_controller/zencoder_notification_test.rb
+++ b/test/controllers/fogged/resources_controller/zencoder_notification_test.rb
@@ -7,16 +7,16 @@ class ResourcesControllerZencoderNotificationTest < ActionController::TestCase
 
     setup do
       @resource = fogged_resources(:resource_mov_3)
-      @resource.update!(:encoding_job_id => 1234565434567890)
+      @resource.update!(encoding_job_id: 1_234_565_434_567_890)
     end
 
     test "should receive zencoder notification" do
-      refute @resource.encoding_progress
-      refute @resource.width
-      refute @resource.height
-      refute @resource.duration
+      assert_not @resource.encoding_progress
+      assert_not @resource.width
+      assert_not @resource.height
+      assert_not @resource.duration
 
-      post :zencoder_notification, :params => payload(@resource.encoding_job_id)
+      post :zencoder_notification, params: payload(@resource.encoding_job_id)
 
       assert @resource.reload.encoding_progress
       assert @resource.width
@@ -25,49 +25,49 @@ class ResourcesControllerZencoderNotificationTest < ActionController::TestCase
     end
 
     test "should receive zencoder notification with invalid id" do
-      post :zencoder_notification, :params => payload("foobar!")
+      post :zencoder_notification, params: payload("foobar!")
     end
 
     test "should receive zencoder notification with invalid payload" do
-      refute @resource.encoding_progress
-      refute @resource.width
-      refute @resource.height
-      refute @resource.duration
+      assert_not @resource.encoding_progress
+      assert_not @resource.width
+      assert_not @resource.height
+      assert_not @resource.duration
 
       post :zencoder_notification,
-           :params => payload(@resource.encoding_job_id).except(:outputs)
+           params: payload(@resource.encoding_job_id).except(:outputs)
 
-      refute @resource.reload.encoding_progress
-      refute @resource.width
-      refute @resource.height
-      refute @resource.duration
+      assert_not @resource.reload.encoding_progress
+      assert_not @resource.width
+      assert_not @resource.height
+      assert_not @resource.duration
     end
 
     test "should receive zencoder notification with failed job" do
-      refute @resource.encoding_progress
-      refute @resource.width
-      refute @resource.height
-      refute @resource.duration
+      assert_not @resource.encoding_progress
+      assert_not @resource.width
+      assert_not @resource.height
+      assert_not @resource.duration
 
       post :zencoder_notification,
-           :params => payload(@resource.encoding_job_id, "failed")
+           params: payload(@resource.encoding_job_id, "failed")
 
-      refute @resource.reload.encoding_progress
-      refute @resource.width
-      refute @resource.height
-      refute @resource.duration
+      assert_not @resource.reload.encoding_progress
+      assert_not @resource.width
+      assert_not @resource.height
+      assert_not @resource.duration
     end
 
     private
 
     def payload(encoding_job_id, state = "finished")
       {
-        :job => {
-          :id => encoding_job_id,
-          :state => state
+        job: {
+          id: encoding_job_id,
+          state:
         },
-        :outputs => [
-          { :duration_in_ms => 85600, :height => 480, :width => 640 }
+        outputs: [
+          { duration_in_ms: 85_600, height: 480, width: 640 }
         ]
       }
     end
diff --git a/test/dummy/Rakefile b/test/dummy/Rakefile
index ba6b733..08cc98f 100644
--- a/test/dummy/Rakefile
+++ b/test/dummy/Rakefile
@@ -1,6 +1,6 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
-require File.expand_path('../config/application', __FILE__)
+require File.expand_path("config/application", __dir__)
 
 Rails.application.load_tasks
diff --git a/test/dummy/app/controllers/images_controllers.rb b/test/dummy/app/controllers/images_controllers.rb
index 63b99d4..920a872 100644
--- a/test/dummy/app/controllers/images_controllers.rb
+++ b/test/dummy/app/controllers/images_controllers.rb
@@ -1,5 +1,5 @@
 class ImagesControllers < ApplicationController
   def index
-    render :json => Image.all
+    render json: Image.all
   end
 end
diff --git a/test/dummy/app/models/movie.rb b/test/dummy/app/models/movie.rb
index 1c7e391..898be1a 100644
--- a/test/dummy/app/models/movie.rb
+++ b/test/dummy/app/models/movie.rb
@@ -1,4 +1,4 @@
 class Movie < ActiveRecord::Base
   has_many :movie_fogged_resources
-  has_many_resources :through => :movie_fogged_resources
+  has_many_resources through: :movie_fogged_resources
 end
diff --git a/test/dummy/app/models/movie_fogged_resource.rb b/test/dummy/app/models/movie_fogged_resource.rb
index 13fe6e2..48c511d 100644
--- a/test/dummy/app/models/movie_fogged_resource.rb
+++ b/test/dummy/app/models/movie_fogged_resource.rb
@@ -1,4 +1,4 @@
 class MovieFoggedResource < ActiveRecord::Base
   belongs_to :movie
-  belongs_to :resource, :class_name => "Fogged::Resource"
+  belongs_to :resource, class_name: "Fogged::Resource"
 end
diff --git a/test/dummy/bin/bundle b/test/dummy/bin/bundle
index 66e9889..67efc37 100755
--- a/test/dummy/bin/bundle
+++ b/test/dummy/bin/bundle
@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-load Gem.bin_path('bundler', 'bundle')
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+load Gem.bin_path("bundler", "bundle")
diff --git a/test/dummy/bin/delayed_job b/test/dummy/bin/delayed_job
index edf1959..2eee759 100755
--- a/test/dummy/bin/delayed_job
+++ b/test/dummy/bin/delayed_job
@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
-require 'delayed/command'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "config", "environment"))
+require "delayed/command"
 Delayed::Command.new(ARGV).daemonize
diff --git a/test/dummy/bin/rails b/test/dummy/bin/rails
index 728cd85..efc0377 100755
--- a/test/dummy/bin/rails
+++ b/test/dummy/bin/rails
@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require_relative '../config/boot'
-require 'rails/commands'
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"
diff --git a/test/dummy/bin/rake b/test/dummy/bin/rake
index 1724048..4fbf10b 100755
--- a/test/dummy/bin/rake
+++ b/test/dummy/bin/rake
@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-require_relative '../config/boot'
-require 'rake'
+require_relative "../config/boot"
+require "rake"
 Rake.application.run
diff --git a/test/dummy/config.ru b/test/dummy/config.ru
index 5bc2a61..b3b2640 100644
--- a/test/dummy/config.ru
+++ b/test/dummy/config.ru
@@ -1,4 +1,4 @@
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path('../config/environment',  __FILE__)
+require File.expand_path("config/environment", __dir__)
 run Rails.application
diff --git a/test/dummy/config/application.rb b/test/dummy/config/application.rb
index 72b3b83..151a733 100644
--- a/test/dummy/config/application.rb
+++ b/test/dummy/config/application.rb
@@ -1,6 +1,6 @@
-require File.expand_path('../boot', __FILE__)
+require File.expand_path("boot", __dir__)
 
-require 'rails/all'
+require "rails/all"
 
 Bundler.require(*Rails.groups)
 require "fogged"
@@ -20,6 +20,6 @@ class Application < Rails::Application
     # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
     # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
     # config.i18n.default_locale = :de
-    config.autoload_paths += %W(#{Rails.root}/../controllers/concerns) if Rails.env.test?
+    config.autoload_paths += %W[#{Rails.root.join('../controllers/concerns')}] if Rails.env.test?
   end
 end
diff --git a/test/dummy/config/boot.rb b/test/dummy/config/boot.rb
index 6266cfc..116591a 100644
--- a/test/dummy/config/boot.rb
+++ b/test/dummy/config/boot.rb
@@ -1,5 +1,5 @@
 # Set up gems listed in the Gemfile.
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../Gemfile", __dir__)
 
-require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
-$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)
diff --git a/test/dummy/config/environment.rb b/test/dummy/config/environment.rb
index ee8d90d..e4429b4 100644
--- a/test/dummy/config/environment.rb
+++ b/test/dummy/config/environment.rb
@@ -1,5 +1,5 @@
 # Load the Rails application.
-require File.expand_path('../application', __FILE__)
+require File.expand_path("application", __dir__)
 
 # Initialize the Rails application.
 Rails.application.initialize!
diff --git a/test/dummy/config/environments/production.rb b/test/dummy/config/environments/production.rb
index 1d7f9c0..201e60d 100644
--- a/test/dummy/config/environments/production.rb
+++ b/test/dummy/config/environments/production.rb
@@ -59,7 +59,7 @@
   # config.autoflush_log = false
 
   # Use default logging formatter so that PID and timestamp are not suppressed.
-  config.log_formatter = ::Logger::Formatter.new
+  config.log_formatter = Logger::Formatter.new
 
   # Do not dump schema after migrations.
   config.active_record.dump_schema_after_migration = false
diff --git a/test/dummy/config/environments/test.rb b/test/dummy/config/environments/test.rb
index e6d126d..8c16f9f 100644
--- a/test/dummy/config/environments/test.rb
+++ b/test/dummy/config/environments/test.rb
@@ -14,7 +14,7 @@
   config.eager_load = false
 
   # Configure static asset server for tests with Cache-Control for performance.
-  config.public_file_server.enabled  = true
+  config.public_file_server.enabled = true
   config.public_file_server.headers = { "Cache-Control" => "public, max-age=3600" }
 
   # Show full error reports and disable caching.
diff --git a/test/dummy/config/initializers/cookies_serializer.rb b/test/dummy/config/initializers/cookies_serializer.rb
index 7a06a89..7f70458 100644
--- a/test/dummy/config/initializers/cookies_serializer.rb
+++ b/test/dummy/config/initializers/cookies_serializer.rb
@@ -1,3 +1,3 @@
 # Be sure to restart your server when you modify this file.
 
-Rails.application.config.action_dispatch.cookies_serializer = :json
\ No newline at end of file
+Rails.application.config.action_dispatch.cookies_serializer = :json
diff --git a/test/dummy/config/initializers/fogged.rb b/test/dummy/config/initializers/fogged.rb
index 2d7fad2..a41bad4 100644
--- a/test/dummy/config/initializers/fogged.rb
+++ b/test/dummy/config/initializers/fogged.rb
@@ -1,7 +1,7 @@
 Fogged.configure do |config|
   config.provider = :aws
-  config.aws_key = ENV["AWS_KEY"]
-  config.aws_secret = ENV["AWS_SECRET"]
-  config.aws_bucket = ENV["AWS_BUCKET"]
-  config.aws_region = ENV["AWS_REGION"]
+  config.aws_key = ENV.fetch("AWS_KEY", nil)
+  config.aws_secret = ENV.fetch("AWS_SECRET", nil)
+  config.aws_bucket = ENV.fetch("AWS_BUCKET", nil)
+  config.aws_region = ENV.fetch("AWS_REGION", nil)
 end
diff --git a/test/dummy/config/initializers/session_store.rb b/test/dummy/config/initializers/session_store.rb
index e766b67..7ee20e3 100644
--- a/test/dummy/config/initializers/session_store.rb
+++ b/test/dummy/config/initializers/session_store.rb
@@ -1,3 +1,3 @@
 # Be sure to restart your server when you modify this file.
 
-Rails.application.config.session_store :cookie_store, key: '_dummy_session'
+Rails.application.config.session_store :cookie_store, key: "_dummy_session"
diff --git a/test/dummy/config/routes.rb b/test/dummy/config/routes.rb
index 3c6f17b..5b937b7 100644
--- a/test/dummy/config/routes.rb
+++ b/test/dummy/config/routes.rb
@@ -1,4 +1,4 @@
 Rails.application.routes.draw do
-  resources :images, :only => :index
+  resources :images, only: :index
   mount Fogged::Engine => "/"
 end
diff --git a/test/dummy/db/migrate/20141104135257_create_images.rb b/test/dummy/db/migrate/20141104135257_create_images.rb
index 1b60d1f..510591b 100644
--- a/test/dummy/db/migrate/20141104135257_create_images.rb
+++ b/test/dummy/db/migrate/20141104135257_create_images.rb
@@ -1,6 +1,6 @@
 class CreateImages < ActiveRecord::Migration
   def change
-    create_table :images, :force => true do |t|
+    create_table :images, force: true do |t|
       t.string :name
       t.integer :resource_id
 
diff --git a/test/dummy/db/migrate/20141104152227_create_movies.rb b/test/dummy/db/migrate/20141104152227_create_movies.rb
index 43923f7..c691391 100644
--- a/test/dummy/db/migrate/20141104152227_create_movies.rb
+++ b/test/dummy/db/migrate/20141104152227_create_movies.rb
@@ -1,6 +1,6 @@
 class CreateMovies < ActiveRecord::Migration
   def change
-    create_table :movies, :force => true do |t|
+    create_table :movies, force: true do |t|
       t.string :name
 
       t.timestamps
diff --git a/test/dummy/db/migrate/20141104152345_create_movie_fogged_resources.rb b/test/dummy/db/migrate/20141104152345_create_movie_fogged_resources.rb
index c7e79d9..925d1b2 100644
--- a/test/dummy/db/migrate/20141104152345_create_movie_fogged_resources.rb
+++ b/test/dummy/db/migrate/20141104152345_create_movie_fogged_resources.rb
@@ -1,8 +1,8 @@
 class CreateMovieFoggedResources < ActiveRecord::Migration
   def change
-    create_table :movie_fogged_resources, :force => true do |t|
-      t.belongs_to :movie, :index => true
-      t.belongs_to :resource, :index => true
+    create_table :movie_fogged_resources, force: true do |t|
+      t.belongs_to :movie, index: true
+      t.belongs_to :resource, index: true
 
       t.timestamps
     end
diff --git a/test/dummy/db/migrate/20141105073909_create_delayed_jobs.rb b/test/dummy/db/migrate/20141105073909_create_delayed_jobs.rb
index f7de70b..167e61a 100644
--- a/test/dummy/db/migrate/20141105073909_create_delayed_jobs.rb
+++ b/test/dummy/db/migrate/20141105073909_create_delayed_jobs.rb
@@ -1,9 +1,9 @@
 class CreateDelayedJobs < ActiveRecord::Migration
   def self.up
-    create_table :delayed_jobs, :force => true do |table|
-      table.integer :priority, :default => 0, :null => false # Allows some jobs to jump to the front of the queue
-      table.integer :attempts, :default => 0, :null => false # Provides for retries, but still fail eventually.
-      table.text :handler, :null => false                    # YAML-encoded string of the object that will do work
+    create_table :delayed_jobs, force: true do |table|
+      table.integer :priority, default: 0, null: false # Allows some jobs to jump to the front of the queue
+      table.integer :attempts, default: 0, null: false # Provides for retries, but still fail eventually.
+      table.text :handler, null: false # YAML-encoded string of the object that will do work
       table.text :last_error                                 # reason for last failure (See Note below)
       table.datetime :run_at                                 # When to run. Could be Time.zone.now for immediately, or sometime in the future.
       table.datetime :locked_at                              # Set when a client is working on this object
@@ -13,7 +13,7 @@ def self.up
       table.timestamps
     end
 
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
   end
 
   def self.down
diff --git a/test/dummy/db/schema.rb b/test/dummy/db/schema.rb
index d59af70..98f1b8a 100644
--- a/test/dummy/db/schema.rb
+++ b/test/dummy/db/schema.rb
@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
@@ -11,62 +10,60 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20141105073909) do
-
-  create_table "delayed_jobs", force: :cascade do |t|
-    t.integer  "priority",   default: 0, null: false
-    t.integer  "attempts",   default: 0, null: false
-    t.text     "handler",                null: false
-    t.text     "last_error"
-    t.datetime "run_at"
-    t.datetime "locked_at"
-    t.datetime "failed_at"
-    t.string   "locked_by"
-    t.string   "queue"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+ActiveRecord::Schema.define(version: 20_141_105_073_909) do
+  create_table 'delayed_jobs', force: :cascade do |t|
+    t.integer  'priority',   default: 0, null: false
+    t.integer  'attempts',   default: 0, null: false
+    t.text     'handler',                null: false
+    t.text     'last_error'
+    t.datetime 'run_at'
+    t.datetime 'locked_at'
+    t.datetime 'failed_at'
+    t.string   'locked_by'
+    t.string   'queue'
+    t.datetime 'created_at'
+    t.datetime 'updated_at'
   end
 
-  add_index "delayed_jobs", ["priority", "run_at"], name: "delayed_jobs_priority"
+  add_index 'delayed_jobs', %w[priority run_at], name: 'delayed_jobs_priority'
 
-  create_table "fogged_resources", force: :cascade do |t|
-    t.string   "name",              null: false
-    t.string   "token",             null: false
-    t.integer  "width"
-    t.integer  "height"
-    t.string   "extension",         null: false
-    t.boolean  "uploading"
-    t.string   "content_type",      null: false
-    t.integer  "encoding_progress"
-    t.string   "encoding_job_id"
-    t.integer  "duration"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+  create_table 'fogged_resources', force: :cascade do |t|
+    t.string   'name',              null: false
+    t.string   'token',             null: false
+    t.integer  'width'
+    t.integer  'height'
+    t.string   'extension', null: false
+    t.boolean  'uploading'
+    t.string   'content_type', null: false
+    t.integer  'encoding_progress'
+    t.string   'encoding_job_id'
+    t.integer  'duration'
+    t.datetime 'created_at'
+    t.datetime 'updated_at'
   end
 
-  add_index "fogged_resources", ["token"], name: "index_fogged_resources_on_token"
+  add_index 'fogged_resources', ['token'], name: 'index_fogged_resources_on_token'
 
-  create_table "images", force: :cascade do |t|
-    t.string   "name"
-    t.integer  "resource_id"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+  create_table 'images', force: :cascade do |t|
+    t.string   'name'
+    t.integer  'resource_id'
+    t.datetime 'created_at'
+    t.datetime 'updated_at'
   end
 
-  create_table "movie_fogged_resources", force: :cascade do |t|
-    t.integer  "movie_id"
-    t.integer  "resource_id"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+  create_table 'movie_fogged_resources', force: :cascade do |t|
+    t.integer  'movie_id'
+    t.integer  'resource_id'
+    t.datetime 'created_at'
+    t.datetime 'updated_at'
   end
 
-  add_index "movie_fogged_resources", ["movie_id"], name: "index_movie_fogged_resources_on_movie_id"
-  add_index "movie_fogged_resources", ["resource_id"], name: "index_movie_fogged_resources_on_resource_id"
+  add_index 'movie_fogged_resources', ['movie_id'], name: 'index_movie_fogged_resources_on_movie_id'
+  add_index 'movie_fogged_resources', ['resource_id'], name: 'index_movie_fogged_resources_on_resource_id'
 
-  create_table "movies", force: :cascade do |t|
-    t.string   "name"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+  create_table 'movies', force: :cascade do |t|
+    t.string   'name'
+    t.datetime 'created_at'
+    t.datetime 'updated_at'
   end
-
 end
diff --git a/test/dummy/test/controllers/resources_controller/index_test.rb b/test/dummy/test/controllers/resources_controller/index_test.rb
index 7908a34..b6b6c96 100644
--- a/test/dummy/test/controllers/resources_controller/index_test.rb
+++ b/test/dummy/test/controllers/resources_controller/index_test.rb
@@ -10,13 +10,13 @@ def setup
   end
 
   test "should index all resources for movies" do
-    get :index, :params => { :type => "movie" }
+    get :index, params: { type: "movie" }
 
     assert_json_resources(Movie.all.map(&:resources).flatten)
   end
 
   test "should index resources for a movie" do
-    get :index, :params => { :type => "movie", :type_id => @movie.id }
+    get :index, params: { type: "movie", type_id: @movie.id }
 
     assert_json_resources(@movie.resources.to_a)
   end
@@ -24,9 +24,9 @@ def setup
   test "should index resources for movies" do
     resources = movies(:movie_one, :movie_two).map(&:resources).flatten
     get :index,
-        :params => {
-          :type => "movie",
-          :type_ids => movies(:movie_one, :movie_two).map(&:id)
+        params: {
+          type: "movie",
+          type_ids: movies(:movie_one, :movie_two).map(&:id)
         }
 
     assert_json_resources(resources)
@@ -34,17 +34,17 @@ def setup
 
   test "should index resources for a movie with search query on name" do
     res = Fogged::Resource.create(
-      :name => "footest barish",
-      :extension => "txt",
-      :content_type => "text/plain"
+      name: "footest barish",
+      extension: "txt",
+      content_type: "text/plain"
     )
     @movie.resources << res
 
     get :index,
-        :params => {
-          :type => "movie",
-          :type_id => @movie.id,
-          :query => "test"
+        params: {
+          type: "movie",
+          type_id: @movie.id,
+          query: "test"
         }
 
     assert_json_resources([res])
@@ -52,8 +52,8 @@ def setup
 
   test "should index resources with invalid movie id" do
     get :index,
-        :params => {
-          :type => "movie", :type_id => 1234567890
+        params: {
+          type: "movie", type_id: 1_234_567_890
         }
 
     assert_json_resources([])
diff --git a/test/dummy/test/models/image_test.rb b/test/dummy/test/models/image_test.rb
index 861f5a4..279afe3 100644
--- a/test/dummy/test/models/image_test.rb
+++ b/test/dummy/test/models/image_test.rb
@@ -3,7 +3,7 @@
 class ImageTest < ActiveSupport::TestCase
   def setup
     super
-    @image = Image.new(:name => "test")
+    @image = Image.new(name: "test")
   end
 
   test "should save image without resource" do
@@ -11,25 +11,24 @@ def setup
   end
 
   test "should save image with uploaded resource" do
-    assert @image.update(:resource => fogged_resources(:resource_text_1))
-
+    assert @image.update(resource: fogged_resources(:resource_text_1))
   end
 
   test "should not save image with uploading resource" do
     resource = fogged_resources(:resource_text_1)
-    resource.update!(:uploading => true)
+    resource.update!(uploading: true)
 
-    refute @image.update(:resource => resource)
+    assert_not @image.update(resource:)
   end
 
   test "image url changing the storage name" do
     d = "foobar"
-    @image.update!(:resource => fogged_resources(:resource_png_1))
-    Fogged.storage.directories.create(:key => d)
+    @image.update!(resource: fogged_resources(:resource_png_1))
+    Fogged.storage.directories.create(key: d)
 
     url = Fogged.with_directory(d) { @image.resource.url }
 
     assert url.include?(d)
-    refute @image.resource.url.include?(d)
+    assert_not @image.resource.url.include?(d)
   end
 end
diff --git a/test/dummy/test/models/movie_test.rb b/test/dummy/test/models/movie_test.rb
index 0103f82..f077319 100644
--- a/test/dummy/test/models/movie_test.rb
+++ b/test/dummy/test/models/movie_test.rb
@@ -2,7 +2,7 @@
 
 class MovieTest < ActiveSupport::TestCase
   def setup
-    @movie = Movie.new(:name => "test")
+    @movie = Movie.new(name: "test")
   end
 
   test "should save movie with no resources" do
@@ -18,9 +18,9 @@ def setup
   test "should not save movie with uploading resource" do
     @movie.resources = fogged_resources(:resource_text_1, :resource_text_2)
     resource = fogged_resources(:resource_text_4)
-    resource.update!(:uploading => true)
+    resource.update!(uploading: true)
     @movie.resources << resource
 
-    refute @movie.save
+    assert_not @movie.save
   end
 end
diff --git a/test/fogged_test.rb b/test/fogged_test.rb
index 32afd59..a972aed 100644
--- a/test/fogged_test.rb
+++ b/test/fogged_test.rb
@@ -14,12 +14,12 @@ class FoggedTest < ActiveSupport::TestCase
   end
 
   test "should check if file exists" do
-    refute Fogged.file_exists?("foobar")
+    assert_not Fogged.file_exists?("foobar")
 
     Fogged.resources.files.create(
-      :key => "foobar",
-      :body => "foo",
-      :public => true
+      key: "foobar",
+      body: "foo",
+      public: true
     )
 
     assert Fogged.file_exists?("foobar")
diff --git a/test/jobs/fogged/resources/aws_thumbnail_job_test.rb b/test/jobs/fogged/resources/aws_thumbnail_job_test.rb
index a01a753..aa49988 100644
--- a/test/jobs/fogged/resources/aws_thumbnail_job_test.rb
+++ b/test/jobs/fogged/resources/aws_thumbnail_job_test.rb
@@ -6,7 +6,7 @@ class AWSThumbnailJobTest < ActiveSupport::TestCase
       def setup
         super
         @resource = fogged_resources(:resource_thumbnail)
-        Fogged.thumbnail_sizes = %w(50x50 100x100)
+        Fogged.thumbnail_sizes = %w[50x50 100x100]
       end
 
       test "should thumbnail the image" do
@@ -19,7 +19,7 @@ def setup
 
           AWSThumbnailJob.perform_now(@resource)
 
-          %w(50x38 100x75).each_with_index do |size, index|
+          %w[50x38 100x75].each_with_index do |size, index|
             key = @resource.send(:fogged_name_for, :thumbnails, index)
             f = Fogged.resources.files.get(key)
             Tempfile.open(["thumbnail", ".png"]) do |t|
@@ -29,7 +29,7 @@ def setup
               assert_equal size, "#{output_size.first}x#{output_size.second}"
             end
           end
-          refute @resource.encoding?
+          assert_not @resource.encoding?
           assert_equal 100, @resource.reload.encoding_progress
         end
       end
diff --git a/test/models/fogged/resource_test.rb b/test/models/fogged/resource_test.rb
index 7363f2b..34766b4 100644
--- a/test/models/fogged/resource_test.rb
+++ b/test/models/fogged/resource_test.rb
@@ -5,10 +5,10 @@ class ResourceTest < ActiveSupport::TestCase
     def setup
       super
       @resource = Resource.new(
-        :extension => "txt",
-        :uploading => false,
-        :content_type => "text/plain",
-        :name => "Test"
+        extension: "txt",
+        uploading: false,
+        content_type: "text/plain",
+        name: "Test"
       )
     end
 
@@ -16,16 +16,16 @@ def setup
       assert @resource.save
     end
 
-    %w(extension content_type).each do |field|
+    %w[extension content_type].each do |field|
       test "resource without #{field} should not be saved" do
         @resource.send("#{field}=", nil)
 
-        refute @resource.save
+        assert_not @resource.save
       end
     end
 
     test "resource should have a token after being saved" do
-      refute @resource.token
+      assert_not @resource.token
       assert @resource.save
       assert @resource.token
     end
@@ -53,7 +53,7 @@ def setup
       @resource.process!
       assert_equal 800, @resource.width
       assert_equal 600, @resource.height
-      refute @resource.encoding?
+      assert_not @resource.encoding?
     end
 
     test "should process resource video" do
@@ -61,8 +61,8 @@ def setup
 
       @resource.process!
 
-      refute @resource.encoding?
-      refute @resource.encoding_job_id
+      assert_not @resource.encoding?
+      assert_not @resource.encoding_job_id
     end
 
     test "should process resource video with zencoder enabled" do
@@ -74,7 +74,7 @@ def setup
 
         @resource = fogged_resources(:resource_mov_1)
         Zencoder::Job.expects(:create).returns(
-          OpenStruct.new(:body => create_output)
+          OpenStruct.new(body: create_output)
         )
 
         @resource.process!
@@ -85,7 +85,7 @@ def setup
     end
 
     test "should generate a token before writing file" do
-      refute @resource.token
+      assert_not @resource.token
       @resource.write("foo")
       assert @resource.token
     end
@@ -94,7 +94,7 @@ def setup
 
     def create_output
       {
-        :id => 1234567890
+        id: 1_234_567_890
       }.with_indifferent_access
     end
   end
diff --git a/test/models/fogged/resources/aws_encoder_test.rb b/test/models/fogged/resources/aws_encoder_test.rb
index 6cb9a3a..4bd92e8 100644
--- a/test/models/fogged/resources/aws_encoder_test.rb
+++ b/test/models/fogged/resources/aws_encoder_test.rb
@@ -10,8 +10,8 @@ class AWSEncoderTest < ActiveSupport::TestCase
         in_a_fork do
           encoder.encode!
 
-          refute resource.encoding?
-          refute resource.encoding_job_id
+          assert_not resource.encoding?
+          assert_not resource.encoding_job_id
         end
       end
 
@@ -28,8 +28,8 @@ class AWSEncoderTest < ActiveSupport::TestCase
             encoder.encode!
           end
 
-          refute resource.encoding?
-          refute resource.encoding_job_id
+          assert_not resource.encoding?
+          assert_not resource.encoding_job_id
         end
       end
 
@@ -43,7 +43,7 @@ class AWSEncoderTest < ActiveSupport::TestCase
           Fogged.configure
 
           Zencoder::Job.expects(:create).returns(
-            OpenStruct.new(:body => create_output)
+            OpenStruct.new(body: create_output)
           )
           encoder.encode!
 
@@ -60,8 +60,8 @@ class AWSEncoderTest < ActiveSupport::TestCase
         in_a_fork do
           encoder.encode!
 
-          refute resource.encoding?
-          refute resource.encoding_job_id
+          assert_not resource.encoding?
+          assert_not resource.encoding_job_id
         end
       end
 
@@ -76,8 +76,8 @@ class AWSEncoderTest < ActiveSupport::TestCase
           assert_no_difference("Delayed::Job.count") do
             encoder.encode!
           end
-          refute resource.encoding?
-          refute resource.encoding_job_id
+          assert_not resource.encoding?
+          assert_not resource.encoding_job_id
         end
       end
 
@@ -90,7 +90,7 @@ class AWSEncoderTest < ActiveSupport::TestCase
           require "delayed_job_active_record"
           Rails.application.config.active_job.queue_adapter = :delayed_job
           Fogged.configure
-          Fogged.thumbnail_sizes = %w(50x50 60x60)
+          Fogged.thumbnail_sizes = %w[50x50 60x60]
 
           assert_difference("Delayed::Job.count") do
             encoder.encode!
@@ -109,7 +109,7 @@ class AWSEncoderTest < ActiveSupport::TestCase
           require "delayed_job_active_record"
           Rails.application.config.active_job.queue_adapter = :delayed_job
           Fogged.configure
-          Fogged.thumbnail_sizes = %w(50x50 60x60)
+          Fogged.thumbnail_sizes = %w[50x50 60x60]
 
           assert_no_difference("Delayed::Job.count") do
             encoder.encode!(true)
@@ -130,17 +130,17 @@ class AWSEncoderTest < ActiveSupport::TestCase
             config.zencoder_additional_outputs do |bucket, res|
               [
                 {
-                  :url => "s3://#{bucket}/#{res.token}-custom1.mp4",
-                  :video_codec => "mpeg4",
-                  :quality => 1,
-                  :public => 1
+                  url: "s3://#{bucket}/#{res.token}-custom1.mp4",
+                  video_codec: "mpeg4",
+                  quality: 1,
+                  public: 1
                 }
               ]
             end
           end
 
-          Zencoder::Job.expects(:create).with() { |options| assert_equal 4, options[:output].size }.returns(
-            OpenStruct.new(:body => create_output)
+          Zencoder::Job.expects(:create).with { |options| assert_equal 4, options[:output].size }.returns(
+            OpenStruct.new(body: create_output)
           )
           encoder.encode!
 
@@ -160,8 +160,8 @@ class AWSEncoderTest < ActiveSupport::TestCase
           Fogged.configure
           Fogged.stubs(:zencoder_notification_url).returns("http://test")
 
-          Zencoder::Job.expects(:create).with() { |options| assert options[:notifications] }.returns(
-            OpenStruct.new(:body => create_output)
+          Zencoder::Job.expects(:create).with { |options| assert options[:notifications] }.returns(
+            OpenStruct.new(body: create_output)
           )
 
           encoder.encode!
@@ -176,7 +176,7 @@ class AWSEncoderTest < ActiveSupport::TestCase
 
       def create_output
         {
-          :id => 1234567890
+          id: 1_234_567_890
         }.with_indifferent_access
       end
     end
diff --git a/test/test_helper.rb b/test/test_helper.rb
index 7de7282..b6b9516 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -7,9 +7,9 @@
 require "minitest/reporters"
 Minitest::Reporters.use!(Minitest::Reporters::DefaultReporter.new)
 
-require File.expand_path("../../test/dummy/config/environment.rb",  __FILE__)
-ActiveRecord::Migrator.migrations_paths = [File.expand_path("../../test/dummy/db/migrate", __FILE__)]
-ActiveRecord::Migrator.migrations_paths << File.expand_path('../../db/migrate', __FILE__)
+require File.expand_path("../test/dummy/config/environment.rb", __dir__)
+ActiveRecord::Migrator.migrations_paths = [File.expand_path("../test/dummy/db/migrate", __dir__)]
+ActiveRecord::Migrator.migrations_paths << File.expand_path("../db/migrate", __dir__)
 
 require "rails/test_help"
 require "minitest/unit"
@@ -35,7 +35,7 @@ class ActiveSupport::TestCase
   fixtures :all
 
   def response_json
-    @response_json ||= JSON.parse(response.body, :symbolize_names => true)
+    @response_json ||= JSON.parse(response.body, symbolize_names: true)
   end
 
   def in_a_fork