paperclip 4.1.1 → 4.2.0

data/lib/paperclip/storage/filesystem.rb

@@ -69,7 +69,7 @@ module Paperclip
             while(true)
               path = File.dirname(path)
               FileUtils.rmdir(path)
-              break if File.exists?(path) # Ruby 1.9.2 does not raise if the removal failed.
+              break if File.exist?(path) # Ruby 1.9.2 does not raise if the removal failed.
             end
           rescue Errno::EEXIST, Errno::ENOTEMPTY, Errno::ENOENT, Errno::EINVAL, Errno::ENOTDIR, Errno::EACCES
             # Stop trying to remove parent directories

data/lib/paperclip/storage/s3.rb

@@ -26,7 +26,7 @@ module Paperclip
     #   put your bucket name in this file, instead of adding it to the code directly.
     #   This is useful when you want the same account but a different bucket for
     #   development versus production.
-    #   When using a Proc it provides a single parameter which is the attachment itself. A  
+    #   When using a Proc it provides a single parameter which is the attachment itself. A
     #   method #instance is available on the attachment which will take you back to your
     #   code. eg.
     #     class User
@@ -51,7 +51,7 @@ module Paperclip
     #     :s3_permissions => :private
     #
     # * +s3_protocol+: The protocol for the URLs generated to your S3 assets. Can be either
-    #   'http', 'https', or an empty string to generate scheme-less URLs. Defaults to 'http'
+    #   'http', 'https', or an empty string to generate protocol-relative URLs. Defaults to 'http'
     #   when your :s3_permissions are :public_read (the default), and 'https' when your
     #   :s3_permissions are anything else.
     # * +s3_headers+: A hash of headers or a Proc. You may specify a hash such as
@@ -102,6 +102,14 @@ module Paperclip
     #   Redundancy Storage.  RRS enables customers to reduce their
     #   costs by storing non-critical, reproducible data at lower
     #   levels of redundancy than Amazon S3's standard storage.
+    #
+    #   You can set storage class on a per style bases by doing the following:
+    #     :s3_storage_class => {
+    #       :thumb => :reduced_reduncancy
+    #     }
+    #   Or globally:
+    #     :s3_storage_class => :reduced_redundancy
+
     module S3
       def self.extended base
         begin
@@ -139,14 +147,14 @@ module Paperclip
           @s3_headers = {}
           merge_s3_headers(@options[:s3_headers], @s3_headers, @s3_metadata)
 
-          @s3_headers[:storage_class] = @options[:s3_storage_class] if @options[:s3_storage_class]
+          @s3_storage_class = set_storage_class(@options[:s3_storage_class])
 
           @s3_server_side_encryption = :aes256
           if @options[:s3_server_side_encryption].blank?
             @s3_server_side_encryption = false
           end
           if @s3_server_side_encryption
-            @s3_server_side_encryption = @options[:s3_server_side_encryption].to_s.upcase
+            @s3_server_side_encryption = @options[:s3_server_side_encryption]
           end
 
           unless @options[:url].to_s.match(/\A:s3.*url\Z/) || @options[:url] == ":asset_host"
@@ -272,6 +280,11 @@ module Paperclip
         permissions.merge :default => (permissions[:default] || :public_read)
       end
 
+      def set_storage_class(storage_class)
+        storage_class = {:default => storage_class} unless storage_class.respond_to?(:merge)
+        storage_class
+      end
+
       def parse_credentials creds
         creds = creds.respond_to?('call') ? creds.call(self) : creds
         creds = find_credentials(creds).stringify_keys
@@ -295,6 +308,10 @@ module Paperclip
         s3_permissions
       end
 
+      def s3_storage_class(style = default_style)
+        @s3_storage_class[style] || @s3_storage_class[:default]
+      end
+
       def s3_protocol(style = default_style, with_colon = false)
         protocol = @s3_protocol
         protocol = protocol.call(style, self) if protocol.respond_to?(:call)
@@ -320,6 +337,11 @@ module Paperclip
               :content_type => file.content_type,
               :acl => acl
             }
+
+            # add storage class for this style if defined
+            storage_class = s3_storage_class(style)
+            write_options.merge!(:storage_class => storage_class) if storage_class
+
             if @s3_server_side_encryption
               write_options[:server_side_encryption] = @s3_server_side_encryption
             end

data/lib/paperclip/style.rb

@@ -71,7 +71,7 @@ module Paperclip
     # Arguments other than the standard geometry, format etc are just passed through from
     # initialization and any procs are called here, just before post-processing.
     def processor_options
-      args = {}
+      args = {:style => name}
       @other_args.each do |k,v|
         args[k] = v.respond_to?(:call) ? v.call(attachment) : v
       end

data/lib/paperclip/thumbnail.rb

@@ -28,17 +28,17 @@ module Paperclip
     def initialize(file, options = {}, attachment = nil)
       super
 
-      geometry             = options[:geometry] # this is not an option
+      geometry             = options[:geometry].to_s
       @file                = file
       @crop                = geometry[-1,1] == '#'
-      @target_geometry     = (options[:string_geometry_parser] || Geometry).parse(geometry)
-      @current_geometry    = (options[:file_geometry_parser] || Geometry).from_file(@file)
+      @target_geometry     = options.fetch(:string_geometry_parser, Geometry).parse(geometry)
+      @current_geometry    = options.fetch(:file_geometry_parser, Geometry).from_file(@file)
       @source_file_options = options[:source_file_options]
       @convert_options     = options[:convert_options]
-      @whiny               = options[:whiny].nil? ? true : options[:whiny]
+      @whiny               = options.fetch(:whiny, true)
       @format              = options[:format]
-      @animated            = options[:animated].nil? ? true : options[:animated]
-      @auto_orient         = options[:auto_orient].nil? ? true : options[:auto_orient]
+      @animated            = options.fetch(:animated, true)
+      @auto_orient         = options.fetch(:auto_orient, true)
       if @auto_orient && @current_geometry.respond_to?(:auto_orient)
         @current_geometry.auto_orient
       end

data/lib/paperclip/validators.rb

@@ -1,5 +1,6 @@
 require 'active_model'
 require 'active_support/concern'
+require 'active_support/core_ext/array/wrap'
 require 'paperclip/validators/attachment_content_type_validator'
 require 'paperclip/validators/attachment_file_name_validator'
 require 'paperclip/validators/attachment_presence_validator'
@@ -41,10 +42,11 @@ module Paperclip
             if options.has_key?(validator_kind)
               validator_options = options.delete(validator_kind)
               validator_options = {} if validator_options == true
-              local_options = attributes + [validator_options]
               conditional_options = options.slice(:if, :unless)
-              local_options.last.merge!(conditional_options)
-              send(Paperclip::Validators.const_get(constant.to_s).helper_method_name, *local_options)
+              Array.wrap(validator_options).each do |local_options|
+                method_name = Paperclip::Validators.const_get(constant.to_s).helper_method_name
+                send(method_name, attributes, local_options.merge(conditional_options))
+              end
             end
           end
         end

data/lib/paperclip/validators/attachment_size_validator.rb

@@ -71,9 +71,13 @@ module Paperclip
       end
 
       def human_size(size)
-        storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
-        unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => size.to_i, :raise => true)
-        storage_units_format.gsub(/%n/, size.to_i.to_s).gsub(/%u/, unit).html_safe
+        if defined?(ActiveSupport::NumberHelper) # Rails 4.0+
+          ActiveSupport::NumberHelper.number_to_human_size(size)
+        else
+          storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+          unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => size.to_i, :raise => true)
+          storage_units_format.gsub(/%n/, size.to_i.to_s).gsub(/%u/, unit).html_safe
+        end
       end
 
       def min_value_in_human_size(record)

data/lib/paperclip/version.rb

@@ -1,3 +1,3 @@
 module Paperclip
-  VERSION = "4.1.1" unless defined? Paperclip::VERSION
+  VERSION = "4.2.0" unless defined? Paperclip::VERSION
 end

data/lib/tasks/paperclip.rake

@@ -78,8 +78,7 @@ namespace :paperclip do
 
     desc "Regenerates missing thumbnail styles for all classes using Paperclip."
     task :missing_styles => :environment do
-      # Force loading all model classes to never miss any has_attached_file declaration:
-      Dir[Rails.root + 'app/models/**/*.rb'].each { |path| load path }
+      Rails.application.eager_load!
       Paperclip.missing_attachments_styles.each do |klass, attachment_definitions|
         attachment_definitions.each do |attachment_name, missing_styles|
           puts "Regenerating #{klass} -> #{attachment_name} -> #{missing_styles.inspect}"

data/paperclip.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "paperclip"
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
@@ -29,12 +29,12 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency('activerecord', '>= 3.0.0')
   s.add_development_dependency('shoulda')
+  s.add_development_dependency('rspec')
   s.add_development_dependency('appraisal')
   s.add_development_dependency('mocha')
   s.add_development_dependency('aws-sdk', '>= 1.5.7')
   s.add_development_dependency('bourne')
-  s.add_development_dependency('sqlite3', '~> 1.3.4')
-  s.add_development_dependency('cucumber', '~> 1.2.1')
+  s.add_development_dependency('cucumber', '~> 1.3.11')
   s.add_development_dependency('aruba')
   s.add_development_dependency('nokogiri')
   # Ruby version < 1.9.3 can't install capybara > 2.0.3.
@@ -46,4 +46,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency('fakeweb')
   s.add_development_dependency('railties')
   s.add_development_dependency('actionmailer', '>= 3.0.0')
+  s.add_development_dependency('generator_spec')
+  s.add_development_dependency('timecop')
 end

data/shoulda_macros/paperclip.rb

@@ -132,4 +132,3 @@ elsif defined?(Test)
     extend Paperclip::Shoulda
   end
 end
-

data/spec/paperclip/attachment_definitions_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "Attachment Definitions" do
+  it 'returns all of the attachments on the class' do
+    reset_class "Dummy"
+    Dummy.has_attached_file :avatar, {path: "abc"}
+    Dummy.has_attached_file :other_attachment, {url: "123"}
+    Dummy.do_not_validate_attachment_file_type :avatar
+    expected = {avatar: {path: "abc"}, other_attachment: {url: "123"}}
+
+    assert_equal expected, Dummy.attachment_definitions
+  end
+end

data/{test/attachment_processing_test.rb → spec/paperclip/attachment_processing_spec.rb}

@@ -1,16 +1,15 @@
 # encoding: utf-8
-require './test/helper'
-require 'paperclip/attachment'
-
-class AttachmentProcessingTest < Test::Unit::TestCase
-  def setup
-    rebuild_model
-  end
+require 'spec_helper'
 
+describe 'Attachment Processing' do
   context 'using validates_attachment_content_type' do
-    should 'process attachments given a valid assignment' do
+    before do
+      rebuild_class
+    end
+
+    it 'processes attachments given a valid assignment' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :content_type => "image/png"
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/png"
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles)
@@ -18,9 +17,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :not' do
+    it 'does not process attachments given an invalid assignment with :not' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :not => "image/png"
+      Dummy.validates_attachment_content_type :avatar, not: "image/png"
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never
@@ -28,9 +27,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :content_type' do
+    it 'does not process attachments given an invalid assignment with :content_type' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :content_type => "image/tiff"
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/tiff"
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never
@@ -38,9 +37,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'when validation :if clause returns false, allow what would be an invalid assignment' do
+    it 'allows what would be an invalid assignment when validation :if clause returns false' do
       invalid_assignment = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :content_type => "image/tiff", :if => lambda{false}
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/tiff", if: lambda{false}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles)
@@ -50,9 +49,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
   end
 
   context 'using validates_attachment' do
-    should 'process attachments given a valid assignment' do
+    it 'processes attachments given a valid assignment' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment :avatar, :content_type => {:content_type => "image/png"}
+      Dummy.validates_attachment :avatar, content_type: {content_type: "image/png"}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles)
@@ -60,9 +59,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :not' do
+    it 'does not process attachments given an invalid assignment with :not' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment :avatar, :content_type => {:not => "image/png"}
+      Dummy.validates_attachment :avatar, content_type: {not: "image/png"}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never
@@ -70,9 +69,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :content_type' do
+    it 'does not process attachments given an invalid assignment with :content_type' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment :avatar, :content_type => {:content_type => "image/tiff"}
+      Dummy.validates_attachment :avatar, content_type: {content_type: "image/tiff"}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never

data/{test/attachment_registry_test.rb → spec/paperclip/attachment_registry_spec.rb}

@@ -1,20 +1,19 @@
-require './test/helper'
-require 'paperclip/attachment_registry'
+require 'spec_helper'
 
-class AttachmentRegistryTest < Test::Unit::TestCase
-  def setup
+describe 'Attachment Registry' do
+  before do
     Paperclip::AttachmentRegistry.clear
   end
 
   context '.names_for' do
-    should 'include attachment names for the given class' do
+    it 'includes attachment names for the given class' do
       foo = Class.new
       Paperclip::AttachmentRegistry.register(foo, :avatar, {})
 
       assert_equal [:avatar], Paperclip::AttachmentRegistry.names_for(foo)
     end
 
-    should 'not include attachment names for other classes' do
+    it 'does not include attachment names for other classes' do
       foo = Class.new
       bar = Class.new
       Paperclip::AttachmentRegistry.register(foo, :avatar, {})
@@ -23,13 +22,13 @@ class AttachmentRegistryTest < Test::Unit::TestCase
       assert_equal [:lover], Paperclip::AttachmentRegistry.names_for(bar)
     end
 
-    should 'produce the empty array for a missing key' do
+    it 'produces the empty array for a missing key' do
       assert_empty Paperclip::AttachmentRegistry.names_for(Class.new)
     end
   end
 
   context '.each_definition' do
-    should 'call the block with the class, attachment name, and options' do
+    it 'calls the block with the class, attachment name, and options' do
       foo = Class.new
       expected_accumulations = [
         [foo, :avatar, { yo: 'greeting' }],
@@ -49,7 +48,7 @@ class AttachmentRegistryTest < Test::Unit::TestCase
   end
 
   context '.definitions_for' do
-    should 'produce the attachment name and options' do
+    it 'produces the attachment name and options' do
       expected_definitions = {
         avatar: { yo: 'greeting' },
         greeter: { ciao: 'greeting' }
@@ -63,7 +62,7 @@ class AttachmentRegistryTest < Test::Unit::TestCase
       assert_equal expected_definitions, definitions
     end
 
-    should "produce defintions for subclasses" do
+    it "produces defintions for subclasses" do
       expected_definitions = { avatar: { yo: 'greeting' } }
       Foo = Class.new
       Bar = Class.new(Foo)
@@ -76,7 +75,7 @@ class AttachmentRegistryTest < Test::Unit::TestCase
   end
 
   context '.clear' do
-    should 'remove all of the existing attachment definitions' do
+    it 'removes all of the existing attachment definitions' do
       foo = Class.new
       Paperclip::AttachmentRegistry.register(foo, :greeter, { ciao: 'greeting' })
 

data/{test/attachment_test.rb → spec/paperclip/attachment_spec.rb}

@@ -1,205 +1,196 @@
 # encoding: utf-8
-require './test/helper'
-require 'paperclip/attachment'
+require 'spec_helper'
 
-class Dummy; end
+describe Paperclip::Attachment do
 
-class AttachmentTest < Test::Unit::TestCase
-
-  context "presence" do
-    setup do
-      rebuild_class
-      @dummy = Dummy.new
-    end
-
-    context "when file not set" do
-      should "not be present" do
-        assert @dummy.avatar.blank?
-        refute @dummy.avatar.present?
-      end
-    end
-
-    context "when file set" do
-      setup { @dummy.avatar = File.new(fixture_file("50x50.png"), "rb") }
+  it "is not present when file not set" do
+    rebuild_class
+    dummy = Dummy.new
+    expect(dummy.avatar).to be_blank
+    expect(dummy.avatar).to_not be_present
+  end
 
-      should "be present" do
-        refute @dummy.avatar.blank?
-        assert @dummy.avatar.present?
-      end
-    end
+  it "is present when the file is set" do
+    rebuild_class
+    dummy = Dummy.new
+    dummy.avatar = File.new(fixture_file("50x50.png"), "rb") 
+    expect(dummy.avatar).to_not be_blank
+    expect(dummy.avatar).to be_present
   end
 
-  should "process :original style first" do
+  it "processes :original style first" do
     file = File.new(fixture_file("50x50.png"), 'rb')
-    rebuild_class :styles => { :small => '100x>', :original => '42x42#' }
+    rebuild_class styles: { small: '100x>', original: '42x42#' }
     dummy = Dummy.new
     dummy.avatar = file
     dummy.save
 
     # :small avatar should be 42px wide (processed original), not 50px (preprocessed original)
-    assert_equal `identify -format "%w" "#{dummy.avatar.path(:small)}"`.strip, "42"
+    expect(`identify -format "%w" "#{dummy.avatar.path(:small)}"`.strip).to eq "42"
 
     file.close
   end
 
-  should "not delete styles that don't get reprocessed" do
+  it "does not delete styles that don't get reprocessed" do
     file = File.new(fixture_file("50x50.png"), 'rb')
-    rebuild_class :styles => { :small => '100x>',
-                               :large => '500x>',
-                               :original => '42x42#' }
+    rebuild_class styles: {
+      small: '100x>',
+      large: '500x>',
+      original: '42x42#' 
+    }
+
     dummy = Dummy.new
     dummy.avatar = file
     dummy.save
 
-    assert_file_exists(dummy.avatar.path(:small))
-    assert_file_exists(dummy.avatar.path(:large))
-    assert_file_exists(dummy.avatar.path(:original))
+    expect(dummy.avatar.path(:small)).to exist
+    expect(dummy.avatar.path(:large)).to exist
+    expect(dummy.avatar.path(:original)).to exist
 
     dummy.avatar.reprocess!(:small)
 
-    assert_file_exists(dummy.avatar.path(:small))
-    assert_file_exists(dummy.avatar.path(:large))
-    assert_file_exists(dummy.avatar.path(:original))
+    expect(dummy.avatar.path(:small)).to exist
+    expect(dummy.avatar.path(:large)).to exist
+    expect(dummy.avatar.path(:original)).to exist
   end
 
   context "having a not empty hash as a default option" do
-    setup do
+    before do
       @old_default_options = Paperclip::Attachment.default_options.dup
-      @new_default_options = { :convert_options => { :all => "-background white" } }
+      @new_default_options = { convert_options: { all: "-background white" } }
       Paperclip::Attachment.default_options.merge!(@new_default_options)
     end
 
-    teardown do
+    after do
       Paperclip::Attachment.default_options.merge!(@old_default_options)
     end
 
-    should "deep merge when it is overridden" do
-      new_options = { :convert_options => { :thumb => "-thumbnailize" } }
+    it "deep merges when it is overridden" do
+      new_options = { convert_options: { thumb: "-thumbnailize" } }
       attachment = Paperclip::Attachment.new(:name, :instance, new_options)
 
-      assert_equal Paperclip::Attachment.default_options.deep_merge(new_options),
-                   attachment.instance_variable_get("@options")
+      expect(Paperclip::Attachment.default_options.deep_merge(new_options)).to eq attachment.instance_variable_get("@options")
     end
   end
 
-  should "handle a boolean second argument to #url" do
+  it "handles a boolean second argument to #url" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
-    attachment = Paperclip::Attachment.new(:name, :instance, :url_generator => mock_url_generator_builder)
+    attachment = Paperclip::Attachment.new(:name, :instance, url_generator: mock_url_generator_builder)
 
     attachment.url(:style_name, true)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:timestamp => true, :escape => true)
+    expect(mock_url_generator_builder.has_generated_url_with_options?(timestamp: true, escape: true)).to eq true
 
     attachment.url(:style_name, false)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:timestamp => false, :escape => true)
+    expect(mock_url_generator_builder.has_generated_url_with_options?(timestamp: false, escape: true)).to eq true
   end
 
-  should "pass the style and options through to the URL generator on #url" do
+  it "passes the style and options through to the URL generator on #url" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
-    attachment = Paperclip::Attachment.new(:name, :instance, :url_generator => mock_url_generator_builder)
+    attachment = Paperclip::Attachment.new(:name, :instance, url_generator: mock_url_generator_builder)
 
-    attachment.url(:style_name, :options => :values)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:options => :values)
+    attachment.url(:style_name, options: :values)
+    expect(mock_url_generator_builder.has_generated_url_with_options?(options: :values)).to eq true
   end
 
-  should "pass default options through when #url is given one argument" do
+  it "passes default options through when #url is given one argument" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :url_generator => mock_url_generator_builder,
-                                           :use_timestamp => true)
+                                           url_generator: mock_url_generator_builder,
+                                           use_timestamp: true)
 
     attachment.url(:style_name)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => true, :timestamp => true)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: true, timestamp: true)
   end
 
-  should "pass default style and options through when #url is given no arguments" do
+  it "passes default style and options through when #url is given no arguments" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :default_style => 'default style',
-                                           :url_generator => mock_url_generator_builder,
-                                           :use_timestamp => true)
+                                           default_style: 'default style',
+                                           url_generator: mock_url_generator_builder,
+                                           use_timestamp: true)
 
     attachment.url
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => true, :timestamp => true)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: true, timestamp: true)
     assert mock_url_generator_builder.has_generated_url_with_style_name?('default style')
   end
 
-  should "pass the option :timestamp => true if :use_timestamp is true and :timestamp is not passed" do
+  it "passes the option timestamp: true if :use_timestamp is true and :timestamp is not passed" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :url_generator => mock_url_generator_builder,
-                                           :use_timestamp => true)
+                                           url_generator: mock_url_generator_builder,
+                                           use_timestamp: true)
 
     attachment.url(:style_name)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => true, :timestamp => true)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: true, timestamp: true)
   end
 
-  should "pass the option :timestamp => false if :use_timestamp is false and :timestamp is not passed" do
+  it "passes the option timestamp: false if :use_timestamp is false and :timestamp is not passed" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :url_generator => mock_url_generator_builder,
-                                           :use_timestamp => false)
+                                           url_generator: mock_url_generator_builder,
+                                           use_timestamp: false)
 
     attachment.url(:style_name)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => true, :timestamp => false)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: true, timestamp: false)
   end
 
-  should "not change the :timestamp if :timestamp is passed" do
+  it "does not change the :timestamp if :timestamp is passed" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :url_generator => mock_url_generator_builder,
-                                           :use_timestamp => false)
+                                           url_generator: mock_url_generator_builder,
+                                           use_timestamp: false)
 
-    attachment.url(:style_name, :timestamp => true)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => true, :timestamp => true)
+    attachment.url(:style_name, timestamp: true)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: true, timestamp: true)
   end
 
-  should "render JSON as default style" do
+  it "renders JSON as default style" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :default_style => 'default style',
-                                           :url_generator => mock_url_generator_builder)
+                                           default_style: 'default style',
+                                           url_generator: mock_url_generator_builder)
 
     attachment.as_json
     assert mock_url_generator_builder.has_generated_url_with_style_name?('default style')
   end
 
-  should "pass the option :escape => true if :escape_url is true and :escape is not passed" do
+  it "passes the option escape: true if :escape_url is true and :escape is not passed" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :url_generator => mock_url_generator_builder,
-                                           :escape_url => true)
+                                           url_generator: mock_url_generator_builder,
+                                           escape_url: true)
 
     attachment.url(:style_name)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => true)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: true)
   end
 
-  should "pass the option :escape => false if :escape_url is false and :escape is not passed" do
+  it "passes the option escape: false if :escape_url is false and :escape is not passed" do
     mock_url_generator_builder = MockUrlGeneratorBuilder.new
     attachment = Paperclip::Attachment.new(:name,
                                            :instance,
-                                           :url_generator => mock_url_generator_builder,
-                                           :escape_url => false)
+                                           url_generator: mock_url_generator_builder,
+                                           escape_url: false)
 
     attachment.url(:style_name)
-    assert mock_url_generator_builder.has_generated_url_with_options?(:escape => false)
+    assert mock_url_generator_builder.has_generated_url_with_options?(escape: false)
   end
 
-  should "return the path based on the url by default" do
-    @attachment = attachment :url => "/:class/:id/:basename"
+  it "returns the path based on the url by default" do
+    @attachment = attachment url: "/:class/:id/:basename"
     @model = @attachment.instance
     @model.id = 1234
     @model.avatar_file_name = "fake.jpg"
     assert_equal "#{Rails.root}/public/fake_models/1234/fake", @attachment.path
   end
 
-  should "default to a path that scales" do
+  it "defaults to a path that scales" do
     avatar_attachment = attachment
     model = avatar_attachment.instance
     model.id = 1234
@@ -208,7 +199,7 @@ class AttachmentTest < Test::Unit::TestCase
     assert_equal expected_path, avatar_attachment.path
   end
 
-  should "render JSON as the URL to the attachment" do
+  it "renders JSON as the URL to the attachment" do
     avatar_attachment = attachment
     model = avatar_attachment.instance
     model.id = 1234
@@ -216,7 +207,7 @@ class AttachmentTest < Test::Unit::TestCase
     assert_equal attachment.url, attachment.as_json
   end
 
-  should "render JSON from the model when requested by :methods" do
+  it "renders JSON from the model when requested by :methods" do
     rebuild_model
     dummy = Dummy.new
     dummy.id = 1234
@@ -226,25 +217,25 @@ class AttachmentTest < Test::Unit::TestCase
       expected_string = %({"dummy":#{expected_string}})
     end
     # active_model pre-3.2 checks only by calling any? on it, thus it doesn't work if it is empty
-    assert_equal expected_string, dummy.to_json(:only => [:dummy_key_for_old_active_model], :methods => [:avatar])
+    assert_equal expected_string, dummy.to_json(only: [:dummy_key_for_old_active_model], methods: [:avatar])
   end
 
   context "Attachment default_options" do
-    setup do
+    before do
       rebuild_model
       @old_default_options = Paperclip::Attachment.default_options.dup
       @new_default_options = @old_default_options.merge({
-        :path => "argle/bargle",
-        :url => "fooferon",
-        :default_url => "not here.png"
+        path: "argle/bargle",
+        url: "fooferon",
+        default_url: "not here.png"
       })
     end
 
-    teardown do
+    after do
       Paperclip::Attachment.default_options.merge! @old_default_options
     end
 
-    should "be overrideable" do
+    it "is overrideable" do
       Paperclip::Attachment.default_options.merge!(@new_default_options)
       @new_default_options.keys.each do |key|
         assert_equal @new_default_options[key],
@@ -253,41 +244,41 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "without an Attachment" do
-      setup do
+      before do
         @dummy = Dummy.new
       end
 
-      should "return false when asked exists?" do
+      it "returns false when asked exists?" do
         assert !@dummy.avatar.exists?
       end
     end
 
     context "on an Attachment" do
-      setup do
+      before do
         @dummy = Dummy.new
         @attachment = @dummy.avatar
       end
 
       Paperclip::Attachment.default_options.keys.each do |key|
-        should "be the default_options for #{key}" do
+        it "is the default_options for #{key}" do
           assert_equal @old_default_options[key],
                        @attachment.instance_variable_get("@options")[key],
-                       key
+                       key.to_s
         end
       end
 
       context "when redefined" do
-        setup do
+        before do
           Paperclip::Attachment.default_options.merge!(@new_default_options)
           @dummy = Dummy.new
           @attachment = @dummy.avatar
         end
 
         Paperclip::Attachment.default_options.keys.each do |key|
-          should "be the new default_options for #{key}" do
+          it "is the new default_options for #{key}" do
             assert_equal @new_default_options[key],
                          @attachment.instance_variable_get("@options")[key],
-                         key
+                         key.to_s
           end
         end
       end
@@ -295,23 +286,23 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "An attachment with similarly named interpolations" do
-    setup do
-      rebuild_model :path => ":id.omg/:id-bbq/:idwhat/:id_partition.wtf"
+    before do
+      rebuild_model path: ":id.omg/:id-bbq/:idwhat/:id_partition.wtf"
       @dummy = Dummy.new
       @dummy.stubs(:id).returns(1024)
       @file = File.new(fixture_file("5k.png"), 'rb')
       @dummy.avatar = @file
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "make sure that they are interpolated correctly" do
+    it "makes sure that they are interpolated correctly" do
       assert_equal "1024.omg/1024-bbq/1024what/000/001/024.wtf", @dummy.avatar.path
     end
   end
 
   context "An attachment with :timestamp interpolations" do
-    setup do
+    before do
       @file = StringIO.new("...")
       @zone = 'UTC'
       Time.stubs(:zone).returns(@zone)
@@ -320,73 +311,77 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "using default time zone" do
-      setup do
-        rebuild_model :path => ":timestamp", :use_default_time_zone => true
+      before do
+        rebuild_model path: ":timestamp", use_default_time_zone: true
         @dummy = Dummy.new
         @dummy.avatar = @file
       end
 
-      should "return a time in the default zone" do
+      it "returns a time in the default zone" do
         assert_equal @dummy.avatar_updated_at.in_time_zone(@zone_default).to_s, @dummy.avatar.path
       end
     end
 
     context "using per-thread time zone" do
-      setup do
-        rebuild_model :path => ":timestamp", :use_default_time_zone => false
+      before do
+        rebuild_model path: ":timestamp", use_default_time_zone: false
         @dummy = Dummy.new
         @dummy.avatar = @file
       end
 
-      should "return a time in the per-thread zone" do
+      it "returns a time in the per-thread zone" do
         assert_equal @dummy.avatar_updated_at.in_time_zone(@zone).to_s, @dummy.avatar.path
       end
     end
   end
 
   context "An attachment with :hash interpolations" do
-    setup do
-      @file = StringIO.new("...\n")
+    before do
+      @file = File.open(fixture_file("5k.png"))
+    end
+
+    after do
+      @file.close
     end
 
-    should "raise if no secret is provided" do
-      rebuild_model :path => ":hash"
+    it "raises if no secret is provided" do
+      rebuild_model path: ":hash"
       @attachment = Dummy.new.avatar
       @attachment.assign @file
 
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         @attachment.path
       end
     end
 
     context "when secret is set" do
-      setup do
-        rebuild_model :path => ":hash",
-          :hash_secret => "w00t",
-          :hash_data => ":class/:attachment/:style/:filename"
+      before do
+        rebuild_model path: ":hash",
+          hash_secret: "w00t",
+          hash_data: ":class/:attachment/:style/:filename"
         @attachment = Dummy.new.avatar
         @attachment.assign @file
       end
 
-      should "result in the correct interpolation" do
-        assert_equal "dummies/avatars/original/data.txt",
+      it "results in the correct interpolation" do
+        assert_equal "dummies/avatars/original/5k.png",
           @attachment.send(:interpolate, @attachment.options[:hash_data])
-        assert_equal "dummies/avatars/thumb/data.txt",
+        assert_equal "dummies/avatars/thumb/5k.png",
           @attachment.send(:interpolate, @attachment.options[:hash_data], :thumb)
       end
 
-      should "result in a correct hash" do
-        assert_equal "e1079a5c34ddbd197ebd0280d07952d98a57fb30", @attachment.path
-        assert_equal "d740189bd3e49ef226fab84c8d45f7ae4126d043", @attachment.path(:thumb)
+      it "results in a correct hash" do
+        assert_equal "0a59e9142bba11576de1d353d8747b1acad5ad34", @attachment.path
+        assert_equal "b39a062c1e62e85a6c785ed00cf3bebf5f850e2b", @attachment.path(:thumb)
       end
     end
   end
 
   context "An attachment with a :rails_env interpolation" do
-    setup do
+    before do
       @rails_env = "blah"
       @id = 1024
-      rebuild_model :path => ":rails_env/:id.png"
+      rebuild_model path: ":rails_env/:id.png"
       @dummy = Dummy.new
       @dummy.stubs(:id).returns(@id)
       @file = StringIO.new(".")
@@ -394,84 +389,84 @@ class AttachmentTest < Test::Unit::TestCase
       Rails.stubs(:env).returns(@rails_env)
     end
 
-    should "return the proper path" do
+    it "returns the proper path" do
       assert_equal "#{@rails_env}/#{@id}.png", @dummy.avatar.path
     end
   end
 
   context "An attachment with a default style and an extension interpolation" do
-    setup do
-      rebuild_model :path => ":basename.:extension",
-        :styles => { :default => ["100x100", :jpg] },
-        :default_style => :default
+    before do
+      rebuild_model path: ":basename.:extension",
+        styles: { default: ["100x100", :jpg] },
+        default_style: :default
       @attachment = Dummy.new.avatar
       @file = File.open(fixture_file("5k.png"))
       @file.stubs(:original_filename).returns("file.png")
     end
-    should "return the right extension for the path" do
+    it "returns the right extension for the path" do
       @attachment.assign(@file)
       assert_equal "file.jpg", @attachment.path
     end
   end
 
   context "An attachment with :convert_options" do
-    setup do
-      rebuild_model :styles => {
-                      :thumb => "100x100",
-                      :large => "400x400"
+    before do
+      rebuild_model styles: {
+                      thumb: "100x100",
+                      large: "400x400"
                     },
-                    :convert_options => {
-                      :all => "-do_stuff",
-                      :thumb => "-thumbnailize"
+                    convert_options: {
+                      all: "-do_stuff",
+                      thumb: "-thumbnailize"
                     }
       @dummy = Dummy.new
       @dummy.avatar
     end
 
-    should "report the correct options when sent #extra_options_for(:thumb)" do
+    it "reports the correct options when sent #extra_options_for(:thumb)" do
       assert_equal "-thumbnailize -do_stuff", @dummy.avatar.send(:extra_options_for, :thumb), @dummy.avatar.convert_options.inspect
     end
 
-    should "report the correct options when sent #extra_options_for(:large)" do
+    it "reports the correct options when sent #extra_options_for(:large)" do
       assert_equal "-do_stuff", @dummy.avatar.send(:extra_options_for, :large)
     end
   end
 
   context "An attachment with :source_file_options" do
-    setup do
-      rebuild_model :styles => {
-                      :thumb => "100x100",
-                      :large => "400x400"
+    before do
+      rebuild_model styles: {
+                      thumb: "100x100",
+                      large: "400x400"
                     },
-                    :source_file_options => {
-                      :all => "-density 400",
-                      :thumb => "-depth 8"
+                    source_file_options: {
+                      all: "-density 400",
+                      thumb: "-depth 8"
                     }
       @dummy = Dummy.new
       @dummy.avatar
     end
 
-    should "report the correct options when sent #extra_source_file_options_for(:thumb)" do
+    it "reports the correct options when sent #extra_source_file_options_for(:thumb)" do
       assert_equal "-depth 8 -density 400", @dummy.avatar.send(:extra_source_file_options_for, :thumb), @dummy.avatar.source_file_options.inspect
     end
 
-    should "report the correct options when sent #extra_source_file_options_for(:large)" do
+    it "reports the correct options when sent #extra_source_file_options_for(:large)" do
       assert_equal "-density 400", @dummy.avatar.send(:extra_source_file_options_for, :large)
     end
   end
 
   context "An attachment with :only_process" do
-    setup do
-      rebuild_model :styles => {
-                      :thumb => "100x100",
-                      :large => "400x400"
+    before do
+      rebuild_model styles: {
+                      thumb: "100x100",
+                      large: "400x400"
                     },
-                    :only_process => [:thumb]
+                    only_process: [:thumb]
       @file = StringIO.new("...")
       @attachment = Dummy.new.avatar
     end
 
-    should "only process the provided style" do
+    it "only processes the provided style" do
       @attachment.expects(:post_process).with(:thumb)
       @attachment.expects(:post_process).with(:large).never
       @attachment.assign(@file)
@@ -479,18 +474,18 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "An attachment with :only_process that is a proc" do
-    setup do
-      rebuild_model :styles => {
-                      :thumb => "100x100",
-                      :large => "400x400"
+    before do
+      rebuild_model styles: {
+                      thumb: "100x100",
+                      large: "400x400"
                     },
-                    :only_process => lambda { |attachment| [:thumb] }
+                    only_process: lambda { |attachment| [:thumb] }
 
       @file = StringIO.new("...")
       @attachment = Dummy.new.avatar
     end
 
-    should "only process the provided style" do
+    it "only processes the provided style" do
       @attachment.expects(:post_process).with(:thumb)
       @attachment.expects(:post_process).with(:large).never
       @attachment.assign(@file)
@@ -498,14 +493,14 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "An attachment with :convert_options that is a proc" do
-    setup do
-      rebuild_model :styles => {
-                      :thumb => "100x100",
-                      :large => "400x400"
+    before do
+      rebuild_model styles: {
+                      thumb: "100x100",
+                      large: "400x400"
                     },
-                    :convert_options => {
-                      :all => lambda{|i| i.all },
-                      :thumb => lambda{|i| i.thumb }
+                    convert_options: {
+                      all: lambda{|i| i.all },
+                      thumb: lambda{|i| i.thumb }
                     }
       Dummy.class_eval do
         def all;   "-all";   end
@@ -515,54 +510,54 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar
     end
 
-    should "report the correct options when sent #extra_options_for(:thumb)" do
+    it "reports the correct options when sent #extra_options_for(:thumb)" do
       assert_equal "-thumb -all", @dummy.avatar.send(:extra_options_for, :thumb), @dummy.avatar.convert_options.inspect
     end
 
-    should "report the correct options when sent #extra_options_for(:large)" do
+    it "reports the correct options when sent #extra_options_for(:large)" do
       assert_equal "-all", @dummy.avatar.send(:extra_options_for, :large)
     end
   end
 
   context "An attachment with :path that is a proc" do
-    setup do
-      rebuild_model :path => lambda{ |attachment| "path/#{attachment.instance.other}.:extension" }
+    before do
+      rebuild_model path: lambda{ |attachment| "path/#{attachment.instance.other}.:extension" }
 
       @file = File.new(fixture_file("5k.png"), 'rb')
-      @dummyA = Dummy.new(:other => 'a')
+      @dummyA = Dummy.new(other: 'a')
       @dummyA.avatar = @file
-      @dummyB = Dummy.new(:other => 'b')
+      @dummyB = Dummy.new(other: 'b')
       @dummyB.avatar = @file
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "return correct path" do
+    it "returns correct path" do
       assert_equal "path/a.png", @dummyA.avatar.path
       assert_equal "path/b.png", @dummyB.avatar.path
     end
   end
 
   context "An attachment with :styles that is a proc" do
-    setup do
-      rebuild_model :styles => lambda{ |attachment| {:thumb => "50x50#", :large => "400x400"} }
+    before do
+      rebuild_model styles: lambda{ |attachment| {thumb: "50x50#", large: "400x400"} }
 
       @attachment = Dummy.new.avatar
     end
 
-    should "have the correct geometry" do
+    it "has the correct geometry" do
       assert_equal "50x50#", @attachment.styles[:thumb][:geometry]
     end
   end
 
   context "An attachment with conditional :styles that is a proc" do
-    setup do
-      rebuild_model :styles => lambda{ |attachment| attachment.instance.other == 'a' ? {:thumb => "50x50#"} : {:large => "400x400"} }
+    before do
+      rebuild_model styles: lambda{ |attachment| attachment.instance.other == 'a' ? {thumb: "50x50#"} : {large: "400x400"} }
 
-      @dummy = Dummy.new(:other => 'a')
+      @dummy = Dummy.new(other: 'a')
     end
 
-    should "have the correct styles for the assigned instance values" do
+    it "has the correct styles for the assigned instance values" do
       assert_equal "50x50#", @dummy.avatar.styles[:thumb][:geometry]
       assert_nil @dummy.avatar.styles[:large]
 
@@ -576,22 +571,22 @@ class AttachmentTest < Test::Unit::TestCase
   geometry_specs = [
     [ lambda{|z| "50x50#" }, :png ],
     lambda{|z| "50x50#" },
-    { :geometry => lambda{|z| "50x50#" } }
+    { geometry: lambda{|z| "50x50#" } }
   ]
   geometry_specs.each do |geometry_spec|
     context "An attachment geometry like #{geometry_spec}" do
-      setup do
-        rebuild_model :styles => { :normal => geometry_spec }
+      before do
+        rebuild_model styles: { normal: geometry_spec }
         @attachment = Dummy.new.avatar
       end
 
       context "when assigned" do
-        setup do
+        before do
           @file = StringIO.new(".")
           @attachment.assign(@file)
         end
 
-        should "have the correct geometry" do
+        it "has the correct geometry" do
           assert_equal "50x50#", @attachment.styles[:normal][:geometry]
         end
       end
@@ -599,46 +594,46 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "An attachment with both 'normal' and hash-style styles" do
-    setup do
-      rebuild_model :styles => {
-                      :normal => ["50x50#", :png],
-                      :hash => { :geometry => "50x50#", :format => :png }
+    before do
+      rebuild_model styles: {
+                      normal: ["50x50#", :png],
+                      hash: { geometry: "50x50#", format: :png }
                     }
       @dummy = Dummy.new
       @attachment = @dummy.avatar
     end
 
     [:processors, :whiny, :convert_options, :geometry, :format].each do |field|
-      should "have the same #{field} field" do
+      it "has the same #{field} field" do
         assert_equal @attachment.styles[:normal][field], @attachment.styles[:hash][field]
       end
     end
   end
 
   context "An attachment with :processors that is a proc" do
-    setup do
+    before do
       class Paperclip::Test < Paperclip::Processor; end
       @file = StringIO.new("...")
       Paperclip::Test.stubs(:make).returns(@file)
 
-      rebuild_model :styles => { :normal => '' }, :processors => lambda { |a| [ :test ] }
+      rebuild_model styles: { normal: '' }, processors: lambda { |a| [ :test ] }
       @attachment = Dummy.new.avatar
     end
 
     context "when assigned" do
-      setup do
+      before do
         @attachment.assign(StringIO.new("."))
       end
 
-      should "have the correct processors" do
+      it "has the correct processors" do
         assert_equal [ :test ], @attachment.styles[:normal][:processors]
       end
     end
   end
 
   context "An attachment with erroring processor" do
-    setup do
-      rebuild_model :processor => [:thumbnail], :styles => { :small => '' }, :whiny_thumbnails => true
+    before do
+      rebuild_model processor: [:thumbnail], styles: { small: '' }, whiny_thumbnails: true
       @dummy = Dummy.new
       Paperclip::Thumbnail.expects(:make).raises(Paperclip::Error, "cannot be processed.")
       @file = StringIO.new("...")
@@ -646,17 +641,17 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
-    should "correctly forward processing error message to the instance" do
+    it "correctly forwards processing error message to the instance" do
       @dummy.valid?
       assert_contains @dummy.errors.full_messages, "Avatar cannot be processed."
     end
   end
 
   context "An attachment with multiple processors" do
-    setup do
+    before do
       class Paperclip::Test < Paperclip::Processor; end
-      @style_params = { :once => {:one => 1, :two => 2} }
-      rebuild_model :processors => [:thumbnail, :test], :styles => @style_params
+      @style_params = { once: {one: 1, two: 2} }
+      rebuild_model processors: [:thumbnail, :test], styles: @style_params
       @dummy = Dummy.new
       @file = StringIO.new("...")
       @file.stubs(:close)
@@ -665,56 +660,67 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "when assigned" do
-      setup { @dummy.avatar = @file }
+      it "calls #make on all specified processors" do
+        Paperclip::Thumbnail.stubs(:make).with(any_parameters).returns(@file)
+        Paperclip::Test.stubs(:make).with(any_parameters).returns(@file)
 
-      before_should "call #make on all specified processors" do
-        Paperclip::Thumbnail.expects(:make).with(any_parameters).returns(@file)
-        Paperclip::Test.expects(:make).with(any_parameters).returns(@file)
+        @dummy.avatar = @file
+
+        expect(Paperclip::Thumbnail).to have_received(:make)
+        expect(Paperclip::Test).to have_received(:make)
       end
 
-      before_should "call #make with the right parameters passed as second argument" do
+      it "calls #make with the right parameters passed as second argument" do
         expected_params = @style_params[:once].merge({
-          :processors => [:thumbnail, :test],
-          :whiny => true,
-          :convert_options => "",
-          :source_file_options => ""
+          style: :once,
+          processors: [:thumbnail, :test],
+          whiny: true,
+          convert_options: "",
+          source_file_options: ""
         })
-        Paperclip::Thumbnail.expects(:make).with(anything, expected_params, anything).returns(@file)
+        Paperclip::Thumbnail.stubs(:make).returns(@file)
+
+        @dummy.avatar = @file
+
+        expect(Paperclip::Thumbnail).to have_received(:make).with(anything, expected_params, anything)
       end
 
-      before_should "call #make with attachment passed as third argument" do
-        Paperclip::Test.expects(:make).with(anything, anything, @dummy.avatar).returns(@file)
+      it "calls #make with attachment passed as third argument" do
+        Paperclip::Test.expects(:make).returns(@file)
+
+        @dummy.avatar = @file
+
+        expect(Paperclip::Test).to have_received(:make).with(anything, anything, @dummy.avatar)
       end
     end
   end
 
-  should "include the filesystem module when loading the filesystem storage" do
-    rebuild_model :storage => :filesystem
+  it "includes the filesystem module when loading the filesystem storage" do
+    rebuild_model storage: :filesystem
     @dummy = Dummy.new
     assert @dummy.avatar.is_a?(Paperclip::Storage::Filesystem)
   end
 
-  should "include the filesystem module even if capitalization is wrong" do
-    rebuild_model :storage => :FileSystem
+  it "includes the filesystem module even if capitalization is wrong" do
+    rebuild_model storage: :FileSystem
     @dummy = Dummy.new
     assert @dummy.avatar.is_a?(Paperclip::Storage::Filesystem)
 
-    rebuild_model :storage => :Filesystem
+    rebuild_model storage: :Filesystem
     @dummy = Dummy.new
     assert @dummy.avatar.is_a?(Paperclip::Storage::Filesystem)
   end
 
-  should "convert underscored storage name to camelcase" do
-    rebuild_model :storage => :not_here
+  it "converts underscored storage name to camelcase" do
+    rebuild_model storage: :not_here
     @dummy = Dummy.new
-    exception = assert_raises(Paperclip::Errors::StorageMethodNotFound) do
+    exception = assert_raises(Paperclip::Errors::StorageMethodNotFound, /NotHere/) do
       @dummy.avatar
     end
-    assert exception.message.include?("NotHere")
   end
 
-  should "raise an error if you try to include a storage module that doesn't exist" do
-    rebuild_model :storage => :not_here
+  it "raises an error if you try to include a storage module that doesn't exist" do
+    rebuild_model storage: :not_here
     @dummy = Dummy.new
     assert_raises(Paperclip::Errors::StorageMethodNotFound) do
       @dummy.avatar
@@ -722,30 +728,30 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "An attachment with styles but no processors defined" do
-    setup do
-      rebuild_model :processors => [], :styles => {:something => '1'}
+    before do
+      rebuild_model processors: [], styles: {something: '1'}
       @dummy = Dummy.new
       @file = StringIO.new("...")
     end
-    should "raise when assigned to" do
+    it "raises when assigned to" do
       assert_raises(RuntimeError){ @dummy.avatar = @file }
     end
   end
 
   context "An attachment without styles and with no processors defined" do
-    setup do
-      rebuild_model :processors => [], :styles => {}
+    before do
+      rebuild_model processors: [], styles: {}
       @dummy = Dummy.new
       @file = StringIO.new("...")
     end
-    should "not raise when assigned to" do
+    it "does not raise when assigned to" do
       @dummy.avatar = @file
     end
   end
 
   context "Assigning an attachment with post_process hooks" do
-    setup do
-      rebuild_class :styles => { :something => "100x100#" }
+    before do
+      rebuild_class styles: { something: "100x100#" }
       Dummy.class_eval do
         before_avatar_post_process :do_before_avatar
         after_avatar_post_process :do_after_avatar
@@ -763,7 +769,7 @@ class AttachmentTest < Test::Unit::TestCase
       @attachment = @dummy.avatar
     end
 
-    should "call the defined callbacks when assigned" do
+    it "calls the defined callbacks when assigned" do
       @dummy.expects(:do_before_avatar).with()
       @dummy.expects(:do_after_avatar).with()
       @dummy.expects(:do_before_all).with()
@@ -772,7 +778,7 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
-    should "not cancel the processing if a before_post_process returns nil" do
+    it "does not cancel the processing if a before_post_process returns nil" do
       @dummy.expects(:do_before_avatar).with().returns(nil)
       @dummy.expects(:do_after_avatar).with()
       @dummy.expects(:do_before_all).with().returns(nil)
@@ -781,7 +787,7 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
-    should "cancel the processing if a before_post_process returns false" do
+    it "cancels the processing if a before_post_process returns false" do
       @dummy.expects(:do_before_avatar).never
       @dummy.expects(:do_after_avatar).never
       @dummy.expects(:do_before_all).with().returns(false)
@@ -790,7 +796,7 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
-    should "cancel the processing if a before_avatar_post_process returns false" do
+    it "cancels the processing if a before_avatar_post_process returns false" do
       @dummy.expects(:do_before_avatar).with().returns(false)
       @dummy.expects(:do_after_avatar)
       @dummy.expects(:do_before_all).with().returns(true)
@@ -801,37 +807,37 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "Assigning an attachment" do
-    setup do
-      rebuild_model :styles => { :something => "100x100#" }
+    before do
+      rebuild_model styles: { something: "100x100#" }
       @file = File.new(fixture_file("5k.png"), "rb")
       @dummy = Dummy.new
       @dummy.avatar = @file
     end
 
-    should "strip whitespace from original_filename field" do
+    it "strips whitespace from original_filename field" do
       assert_equal "5k.png", @dummy.avatar.original_filename
     end
 
-    should "strip whitespace from content_type field" do
+    it "strips whitespace from content_type field" do
       assert_equal "image/png", @dummy.avatar.instance.avatar_content_type
     end
   end
 
   context "Assigning an attachment" do
-    setup do
-      rebuild_model :styles => { :something => "100x100#" }
+    before do
+      rebuild_model styles: { something: "100x100#" }
       @file = File.new(fixture_file("5k.png"), "rb")
       @dummy = Dummy.new
       @dummy.avatar = @file
     end
 
-    should "make sure the content_type is a string" do
+    it "makes sure the content_type is a string" do
       assert_equal "image/png", @dummy.avatar.instance.avatar_content_type
     end
   end
 
   context "Attachment with strange letters" do
-    setup do
+    before do
       rebuild_model
       @file = File.new(fixture_file("5k.png"), "rb")
       @file.stubs(:original_filename).returns("sheep_say_bæ.png")
@@ -839,18 +845,18 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
-    should "not remove strange letters" do
+    it "does not remove strange letters" do
       assert_equal "sheep_say_bæ.png", @dummy.avatar.original_filename
     end
   end
 
   context "Attachment with reserved filename" do
-    setup do
+    before do
       rebuild_model
       @file = Tempfile.new(["filename","png"])
     end
 
-    teardown do
+    after do
       @file.unlink
     end
 
@@ -859,37 +865,37 @@ class AttachmentTest < Test::Unit::TestCase
         context "with character #{character}" do
 
           context "at beginning of filename" do
-            setup do
+            before do
               @file.stubs(:original_filename).returns("#{character}filename.png")
               @dummy = Dummy.new
               @dummy.avatar = @file
             end
 
-            should "convert special character into underscore" do
+            it "converts special character into underscore" do
               assert_equal "_filename.png", @dummy.avatar.original_filename
             end
           end
 
           context "at end of filename" do
-            setup do
+            before do
               @file.stubs(:original_filename).returns("filename.png#{character}")
               @dummy = Dummy.new
               @dummy.avatar = @file
             end
 
-            should "convert special character into underscore" do
+            it "converts special character into underscore" do
               assert_equal "filename.png_", @dummy.avatar.original_filename
             end
           end
 
           context "in the middle of filename" do
-            setup do
+            before do
               @file.stubs(:original_filename).returns("file#{character}name.png")
               @dummy = Dummy.new
               @dummy.avatar = @file
             end
 
-            should "convert special character into underscore" do
+            it "converts special character into underscore" do
               assert_equal "file_name.png", @dummy.avatar.original_filename
             end
           end
@@ -899,53 +905,53 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "with specified regexp replacement" do
-      setup do
+      before do
         @old_defaults = Paperclip::Attachment.default_options.dup
       end
 
-      teardown do
+      after do
         Paperclip::Attachment.default_options.merge! @old_defaults
       end
 
       context 'as another regexp' do
-        setup do
-          Paperclip::Attachment.default_options.merge! :restricted_characters => /o/
+        before do
+          Paperclip::Attachment.default_options.merge! restricted_characters: /o/
 
           @file.stubs(:original_filename).returns("goood.png")
           @dummy = Dummy.new
           @dummy.avatar = @file
         end
 
-        should "match and convert that character" do
+        it "matches and converts that character" do
           assert_equal "g___d.png", @dummy.avatar.original_filename
         end
       end
 
       context 'as nil' do
-        setup do
-          Paperclip::Attachment.default_options.merge! :restricted_characters => nil
+        before do
+          Paperclip::Attachment.default_options.merge! restricted_characters: nil
 
           @file.stubs(:original_filename).returns("goood.png")
           @dummy = Dummy.new
           @dummy.avatar = @file
         end
 
-        should "ignore and return the original file name" do
+        it "ignores and returns the original file name" do
           assert_equal "goood.png", @dummy.avatar.original_filename
         end
       end
     end
 
     context 'with specified cleaner' do
-      setup do
+      before do
         @old_defaults = Paperclip::Attachment.default_options.dup
       end
 
-      teardown do
+      after do
         Paperclip::Attachment.default_options.merge! @old_defaults
       end
 
-      should 'call the given proc and take the result as cleaned filename' do
+      it 'calls the given proc and take the result as cleaned filename' do
         Paperclip::Attachment.default_options[:filename_cleaner] = lambda do |str|
           "from_proc_#{str}"
         end
@@ -956,7 +962,7 @@ class AttachmentTest < Test::Unit::TestCase
         assert_equal "from_proc_goood.png", @dummy.avatar.original_filename
       end
 
-      should 'call the given object and take the result as the cleaned filename' do
+      it 'calls the given object and take the result as the cleaned filename' do
         class MyCleaner
           def call(filename)
             "foo"
@@ -973,16 +979,16 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "Attachment with uppercase extension and a default style" do
-    setup do
+    before do
       @old_defaults = Paperclip::Attachment.default_options.dup
       Paperclip::Attachment.default_options.merge!({
-        :path => ":rails_root/:attachment/:class/:style/:id/:basename.:extension"
+        path: ":rails_root/:attachment/:class/:style/:id/:basename.:extension"
       })
       FileUtils.rm_rf("tmp")
-      rebuild_model :styles => { :large  => ["400x400", :jpg],
-                             :medium => ["100x100", :jpg],
-                             :small => ["32x32#", :jpg]},
-                    :default_style => :small
+      rebuild_model styles: { large: ["400x400", :jpg],
+                             medium: ["100x100", :jpg],
+                             small: ["32x32#", :jpg]},
+                    default_style: :small
       @instance = Dummy.new
       @instance.stubs(:id).returns 123
       @file = File.new(fixture_file("uppercase.PNG"), 'rb')
@@ -995,26 +1001,26 @@ class AttachmentTest < Test::Unit::TestCase
       @attachment.save
     end
 
-    teardown do
+    after do
       @file.close
       Paperclip::Attachment.default_options.merge!(@old_defaults)
     end
 
-    should "should have matching to_s and url methods" do
-      assert_match @attachment.to_s, @attachment.url
-      assert_match @attachment.to_s(:small), @attachment.url(:small)
+    it "has matching to_s and url methods" do
+      assert_equal @attachment.to_s, @attachment.url
+      assert_equal @attachment.to_s(:small), @attachment.url(:small)
     end
 
-    should "have matching expiring_url and url methods when using the filesystem storage" do
-      assert_match @attachment.expiring_url, @attachment.url
+    it "has matching expiring_url and url methods when using the filesystem storage" do
+      assert_equal @attachment.expiring_url, @attachment.url
     end
   end
 
   context "An attachment" do
-    setup do
+    before do
       @old_defaults = Paperclip::Attachment.default_options.dup
       Paperclip::Attachment.default_options.merge!({
-        :path => ":rails_root/:attachment/:class/:style/:id/:basename.:extension"
+        path: ":rails_root/:attachment/:class/:style/:id/:basename.:extension"
       })
       FileUtils.rm_rf("tmp")
       rebuild_model
@@ -1025,39 +1031,39 @@ class AttachmentTest < Test::Unit::TestCase
       @file = File.new(fixture_file("5k.png"), 'rb')
     end
 
-    teardown do
+    after do
       @file.close
       Paperclip::Attachment.default_options.merge!(@old_defaults)
     end
 
-    should "raise if there are not the correct columns when you try to assign" do
+    it "raises if there are not the correct columns when you try to assign" do
       @other_attachment = Paperclip::Attachment.new(:not_here, @instance)
       assert_raises(Paperclip::Error) do
         @other_attachment.assign(@file)
       end
     end
 
-    should 'clear out the previous assignment when assigned nil' do
+    it 'clears out the previous assignment when assigned nil' do
       @attachment.assign(@file)
       @attachment.queued_for_write[:original]
       @attachment.assign(nil)
       assert_nil @attachment.queued_for_write[:original]
     end
 
-    should 'not do anything when it is assigned an empty string' do
+    it 'does not do anything when it is assigned an empty string' do
       @attachment.assign(@file)
       original_file = @attachment.queued_for_write[:original]
       @attachment.assign("")
       assert_equal original_file, @attachment.queued_for_write[:original]
     end
 
-    should "return nil as path when no file assigned" do
+    it "returns nil as path when no file assigned" do
       assert_equal nil, @attachment.path
       assert_equal nil, @attachment.path(:blah)
     end
 
     context "with a file assigned but not saved yet" do
-      should "clear out any attached files" do
+      it "clears out any attached files" do
         @attachment.assign(@file)
         assert !@attachment.queued_for_write.blank?
         @attachment.clear
@@ -1066,7 +1072,7 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "with a file assigned in the database" do
-      setup do
+      before do
         @attachment.stubs(:instance_read).with(:file_name).returns("5k.png")
         @attachment.stubs(:instance_read).with(:content_type).returns("image/png")
         @attachment.stubs(:instance_read).with(:file_size).returns(12345)
@@ -1076,21 +1082,21 @@ class AttachmentTest < Test::Unit::TestCase
         @attachment.stubs(:instance_read).with(:updated_at).returns(dtnow)
       end
 
-      should "return the proper path when filename has a single .'s" do
+      it "returns the proper path when filename has a single .'s" do
         assert_equal File.expand_path("tmp/avatars/dummies/original/#{@instance.id}/5k.png"), File.expand_path(@attachment.path)
       end
 
-      should "return the proper path when filename has multiple .'s" do
+      it "returns the proper path when filename has multiple .'s" do
         @attachment.stubs(:instance_read).with(:file_name).returns("5k.old.png")
         assert_equal File.expand_path("tmp/avatars/dummies/original/#{@instance.id}/5k.old.png"), File.expand_path(@attachment.path)
       end
 
       context "when expecting three styles" do
-        setup do
-          rebuild_class :styles => {
-            :large  => ["400x400", :png],
-            :medium => ["100x100", :gif],
-            :small => ["32x32#", :jpg]
+        before do
+          rebuild_class styles: {
+            large: ["400x400", :png],
+            medium: ["100x100", :gif],
+            small: ["32x32#", :jpg]
           }
           @instance = Dummy.new
           @instance.stubs(:id).returns 123
@@ -1099,28 +1105,28 @@ class AttachmentTest < Test::Unit::TestCase
         end
 
         context "and assigned a file" do
-          setup do
+          before do
             now = Time.now
             Time.stubs(:now).returns(now)
             @attachment.assign(@file)
           end
 
-          should "be dirty" do
+          it "is dirty" do
             assert @attachment.dirty?
           end
 
           context "and saved" do
-            setup do
+            before do
               @attachment.save
             end
 
-            should "commit the files to disk" do
+            it "commits the files to disk" do
               [:large, :medium, :small].each do |style|
-                assert_file_exists(@attachment.path(style))
+                expect(@attachment.path(style)).to exist
               end
             end
 
-            should "save the files as the right formats and sizes" do
+            it "saves the files as the right formats and sizes" do
               [[:large, 400, 61, "PNG"],
                [:medium, 100, 15, "GIF"],
                [:small, 32, 32, "JPEG"]].each do |style|
@@ -1134,13 +1140,13 @@ class AttachmentTest < Test::Unit::TestCase
             end
 
             context "and trying to delete" do
-              setup do
+              before do
                 @existing_names = @attachment.styles.keys.collect do |style|
                   @attachment.path(style)
                 end
               end
 
-              should "delete the files after assigning nil" do
+              it "deletes the files after assigning nil" do
                 @attachment.expects(:instance_write).with(:file_name, nil)
                 @attachment.expects(:instance_write).with(:content_type, nil)
                 @attachment.expects(:instance_write).with(:file_size, nil)
@@ -1151,7 +1157,7 @@ class AttachmentTest < Test::Unit::TestCase
                 @existing_names.each{|f| assert_file_not_exists(f) }
               end
 
-              should "delete the files when you call #clear and #save" do
+              it "deletes the files when you call #clear and #save" do
                 @attachment.expects(:instance_write).with(:file_name, nil)
                 @attachment.expects(:instance_write).with(:content_type, nil)
                 @attachment.expects(:instance_write).with(:file_size, nil)
@@ -1162,7 +1168,7 @@ class AttachmentTest < Test::Unit::TestCase
                 @existing_names.each{|f| assert_file_not_exists(f) }
               end
 
-              should "delete the files when you call #delete" do
+              it "deletes the files when you call #delete" do
                 @attachment.expects(:instance_write).with(:file_name, nil)
                 @attachment.expects(:instance_write).with(:content_type, nil)
                 @attachment.expects(:instance_write).with(:file_size, nil)
@@ -1173,11 +1179,11 @@ class AttachmentTest < Test::Unit::TestCase
               end
 
               context "when keeping old files" do
-                setup do
+                before do
                   @attachment.options[:keep_old_files] = true
                 end
 
-                should "keep the files after assigning nil" do
+                it "keeps the files after assigning nil" do
                   @attachment.expects(:instance_write).with(:file_name, nil)
                   @attachment.expects(:instance_write).with(:content_type, nil)
                   @attachment.expects(:instance_write).with(:file_size, nil)
@@ -1188,7 +1194,7 @@ class AttachmentTest < Test::Unit::TestCase
                   @existing_names.each{|f| assert_file_exists(f) }
                 end
 
-                should "keep the files when you call #clear and #save" do
+                it "keeps the files when you call #clear and #save" do
                   @attachment.expects(:instance_write).with(:file_name, nil)
                   @attachment.expects(:instance_write).with(:content_type, nil)
                   @attachment.expects(:instance_write).with(:file_size, nil)
@@ -1199,7 +1205,7 @@ class AttachmentTest < Test::Unit::TestCase
                   @existing_names.each{|f| assert_file_exists(f) }
                 end
 
-                should "keep the files when you call #delete" do
+                it "keeps the files when you call #delete" do
                   @attachment.expects(:instance_write).with(:file_name, nil)
                   @attachment.expects(:instance_write).with(:content_type, nil)
                   @attachment.expects(:instance_write).with(:file_size, nil)
@@ -1216,19 +1222,19 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "when trying a nonexistant storage type" do
-      setup do
-        rebuild_model :storage => :not_here
+      before do
+        rebuild_model storage: :not_here
       end
 
-      should "not be able to find the module" do
-        assert_raise(Paperclip::Errors::StorageMethodNotFound){ Dummy.new.avatar }
+      it "is not able to find the module" do
+        assert_raises(Paperclip::Errors::StorageMethodNotFound){ Dummy.new.avatar }
       end
     end
   end
 
   context "An attachment with only a avatar_file_name column" do
-    setup do
-      ActiveRecord::Base.connection.create_table :dummies, :force => true do |table|
+    before do
+      ActiveRecord::Base.connection.create_table :dummies, force: true do |table|
         table.column :avatar_file_name, :string
       end
       rebuild_class
@@ -1236,41 +1242,41 @@ class AttachmentTest < Test::Unit::TestCase
       @file = File.new(fixture_file("5k.png"), 'rb')
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "not error when assigned an attachment" do
+    it "does not error when assigned an attachment" do
       assert_nothing_raised { @dummy.avatar = @file }
     end
 
-    should "not return the time when sent #avatar_updated_at" do
+    it "does not return the time when sent #avatar_updated_at" do
       @dummy.avatar = @file
       assert_nil @dummy.avatar.updated_at
     end
 
-    should "return the right value when sent #avatar_file_size" do
+    it "returns the right value when sent #avatar_file_size" do
       @dummy.avatar = @file
       assert_equal File.size(@file), @dummy.avatar.size
     end
 
     context "and avatar_created_at column" do
-      setup do
+      before do
         ActiveRecord::Base.connection.add_column :dummies, :avatar_created_at, :timestamp
         rebuild_class
         @dummy = Dummy.new
       end
 
-      should "not error when assigned an attachment" do
+      it "does not error when assigned an attachment" do
         assert_nothing_raised { @dummy.avatar = @file }
       end
 
-      should "return the creation time when sent #avatar_created_at" do
+      it "returns the creation time when sent #avatar_created_at" do
         now = Time.now
         Time.stubs(:now).returns(now)
         @dummy.avatar = @file
         assert_equal now.to_i, @dummy.avatar.created_at
       end
 
-      should "return the creation time when sent #avatar_created_at and the entry has been updated" do
+      it "returns the creation time when sent #avatar_created_at and the entry has been updated" do
         creation = 2.hours.ago
         now = Time.now
         Time.stubs(:now).returns(creation)
@@ -1281,7 +1287,7 @@ class AttachmentTest < Test::Unit::TestCase
         assert_not_equal now.to_i, @dummy.avatar.created_at
       end
 
-      should "set changed? to true on attachment assignment" do
+      it "sets changed? to true on attachment assignment" do
         @dummy.avatar = @file
         @dummy.save!
         @dummy.avatar = @file
@@ -1290,17 +1296,17 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "and avatar_updated_at column" do
-      setup do
+      before do
         ActiveRecord::Base.connection.add_column :dummies, :avatar_updated_at, :timestamp
         rebuild_class
         @dummy = Dummy.new
       end
 
-      should "not error when assigned an attachment" do
+      it "does not error when assigned an attachment" do
         assert_nothing_raised { @dummy.avatar = @file }
       end
 
-      should "return the right value when sent #avatar_updated_at" do
+      it "returns the right value when sent #avatar_updated_at" do
         now = Time.now
         Time.stubs(:now).returns(now)
         @dummy.avatar = @file
@@ -1308,45 +1314,45 @@ class AttachmentTest < Test::Unit::TestCase
       end
     end
 
-    should "not calculate fingerprint" do
+    it "does not calculate fingerprint" do
       @dummy.avatar = @file
       assert_nil @dummy.avatar.fingerprint
     end
 
     context "and avatar_content_type column" do
-      setup do
+      before do
         ActiveRecord::Base.connection.add_column :dummies, :avatar_content_type, :string
         rebuild_class
         @dummy = Dummy.new
       end
 
-      should "not error when assigned an attachment" do
+      it "does not error when assigned an attachment" do
         assert_nothing_raised { @dummy.avatar = @file }
       end
 
-      should "return the right value when sent #avatar_content_type" do
+      it "returns the right value when sent #avatar_content_type" do
         @dummy.avatar = @file
         assert_equal "image/png", @dummy.avatar.content_type
       end
     end
 
     context "and avatar_file_size column" do
-      setup do
+      before do
         ActiveRecord::Base.connection.add_column :dummies, :avatar_file_size, :integer
         rebuild_class
         @dummy = Dummy.new
       end
 
-      should "not error when assigned an attachment" do
+      it "does not error when assigned an attachment" do
         assert_nothing_raised { @dummy.avatar = @file }
       end
 
-      should "return the right value when sent #avatar_file_size" do
+      it "returns the right value when sent #avatar_file_size" do
         @dummy.avatar = @file
         assert_equal File.size(@file), @dummy.avatar.size
       end
 
-      should "return the right value when saved, reloaded, and sent #avatar_file_size" do
+      it "returns the right value when saved, reloaded, and sent #avatar_file_size" do
         @dummy.avatar = @file
         @dummy.save
         @dummy = Dummy.find(@dummy.id)
@@ -1355,22 +1361,22 @@ class AttachmentTest < Test::Unit::TestCase
     end
 
     context "and avatar_fingerprint column" do
-      setup do
+      before do
         ActiveRecord::Base.connection.add_column :dummies, :avatar_fingerprint, :string
         rebuild_class
         @dummy = Dummy.new
       end
 
-      should "not error when assigned an attachment" do
+      it "does not error when assigned an attachment" do
         assert_nothing_raised { @dummy.avatar = @file }
       end
 
-      should "return the right value when sent #avatar_fingerprint" do
+      it "returns the right value when sent #avatar_fingerprint" do
         @dummy.avatar = @file
         assert_equal 'aec488126c3b33c08a10c3fa303acf27', @dummy.avatar_fingerprint
       end
 
-      should "return the right value when saved, reloaded, and sent #avatar_fingerprint" do
+      it "returns the right value when saved, reloaded, and sent #avatar_fingerprint" do
         @dummy.avatar = @file
         @dummy.save
         @dummy = Dummy.find(@dummy.id)
@@ -1380,8 +1386,8 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
   context "an attachment with delete_file option set to false" do
-    setup do
-      rebuild_model :preserve_files => true
+    before do
+      rebuild_model preserve_files: true
       @dummy = Dummy.new
       @file = File.new(fixture_file("5k.png"), 'rb')
       @dummy.avatar = @file
@@ -1390,27 +1396,27 @@ class AttachmentTest < Test::Unit::TestCase
       @path = @attachment.path
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "not delete the files from storage when attachment is destroyed" do
+    it "does not delete the files from storage when attachment is destroyed" do
       @attachment.destroy
       assert_file_exists(@path)
     end
 
-    should "clear out attachment data when attachment is destroyed" do
+    it "clears out attachment data when attachment is destroyed" do
       @attachment.destroy
       assert !@attachment.exists?
       assert_nil @dummy.avatar_file_name
     end
 
-    should "not delete the file when model is destroyed" do
+    it "does not delete the file when model is destroyed" do
       @dummy.destroy
       assert_file_exists(@path)
     end
   end
 
   context "An attached file" do
-    setup do
+    before do
       rebuild_model
       @dummy = Dummy.new
       @file = File.new(fixture_file("5k.png"), 'rb')
@@ -1420,24 +1426,24 @@ class AttachmentTest < Test::Unit::TestCase
       @path = @attachment.path
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "not be deleted when the model fails to destroy" do
+    it "is not deleted when the model fails to destroy" do
       @dummy.stubs(:destroy).raises(Exception)
 
-      assert_raise Exception do
+      assert_raises Exception do
         @dummy.destroy
       end
 
       assert_file_exists(@path)
     end
 
-    should "be deleted when the model is destroyed" do
+    it "is deleted when the model is destroyed" do
       @dummy.destroy
       assert_file_not_exists(@path)
     end
 
-    should "not be deleted when transaction rollbacks after model is destroyed" do
+    it "is not deleted when transaction rollbacks after model is destroyed" do
       ActiveRecord::Base.transaction do
         @dummy.destroy
         raise ActiveRecord::Rollback
@@ -1448,3 +1454,4 @@ class AttachmentTest < Test::Unit::TestCase
   end
 
 end
+