paperclip 4.1.1 → 4.2.0

data/{test/url_generator_test.rb → spec/paperclip/url_generator_spec.rb}

@@ -1,15 +1,14 @@
 # encoding: utf-8
-require './test/helper'
-require 'paperclip/url_generator'
+require 'spec_helper'
 
-class UrlGeneratorTest < Test::Unit::TestCase
-  should "use the given interpolator" do
+describe Paperclip::UrlGenerator do
+  it "uses the given interpolator" do
     expected = "the expected result"
     mock_attachment = MockAttachment.new
-    mock_interpolator = MockInterpolator.new(:result => expected)
+    mock_interpolator = MockInterpolator.new(result: expected)
 
     url_generator = Paperclip::UrlGenerator.new(mock_attachment,
-                                                { :interpolator => mock_interpolator })
+                                                { interpolator: mock_interpolator })
     result = url_generator.for(:style_name, {})
 
     assert_equal expected, result
@@ -17,11 +16,11 @@ class UrlGeneratorTest < Test::Unit::TestCase
     assert mock_interpolator.has_interpolated_style_name?(:style_name)
   end
 
-  should "use the default URL when no file is assigned" do
+  it "uses the default URL when no file is assigned" do
     mock_attachment = MockAttachment.new
     mock_interpolator = MockInterpolator.new
     default_url = "the default url"
-    options = { :interpolator => mock_interpolator, :default_url => default_url}
+    options = { interpolator: mock_interpolator, default_url: default_url}
 
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
     url_generator.for(:style_name, {})
@@ -30,11 +29,11 @@ class UrlGeneratorTest < Test::Unit::TestCase
       "expected the interpolator to be passed #{default_url.inspect} but it wasn't"
   end
 
-  should "execute the default URL lambda when no file is assigned" do
+  it "executes the default URL lambda when no file is assigned" do
     mock_attachment = MockAttachment.new
     mock_interpolator = MockInterpolator.new
     default_url = lambda {|attachment| "the #{attachment.class.name} default url" }
-    options = { :interpolator => mock_interpolator, :default_url => default_url}
+    options = { interpolator: mock_interpolator, default_url: default_url}
 
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
     url_generator.for(:style_name, {})
@@ -43,12 +42,12 @@ class UrlGeneratorTest < Test::Unit::TestCase
       %{expected the interpolator to be passed "the MockAttachment default url", but it wasn't}
   end
 
-  should "execute the method named by the symbol as the default URL when no file is assigned" do
+  it "executes the method named by the symbol as the default URL when no file is assigned" do
     mock_model = MockModel.new
-    mock_attachment = MockAttachment.new(:model => mock_model)
+    mock_attachment = MockAttachment.new(model: mock_model)
     mock_interpolator = MockInterpolator.new
     default_url = :to_s
-    options = { :interpolator => mock_interpolator, :default_url => default_url}
+    options = { interpolator: mock_interpolator, default_url: default_url}
 
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
     url_generator.for(:style_name, {})
@@ -57,51 +56,51 @@ class UrlGeneratorTest < Test::Unit::TestCase
       %{expected the interpolator to be passed #{mock_model.to_s}, but it wasn't}
   end
 
-  should "URL-escape spaces if asked to" do
+  it "URL-escapes spaces if asked to" do
     expected = "the expected result"
     mock_attachment = MockAttachment.new
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:escape => true})
+    result = url_generator.for(:style_name, {escape: true})
 
     assert_equal "the%20expected%20result", result
   end
 
-  should "escape the result of the interpolator using a method on the object, if asked to escape" do
+  it "escapes the result of the interpolator using a method on the object, if asked to escape" do
     expected = Class.new do
       def escape
         "the escaped result"
       end
     end.new
     mock_attachment = MockAttachment.new
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:escape => true})
+    result = url_generator.for(:style_name, {escape: true})
 
     assert_equal "the escaped result", result
   end
 
-  should "leave spaces unescaped as asked to" do
+  it "leaves spaces unescaped as asked to" do
     expected = "the expected result"
     mock_attachment = MockAttachment.new
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:escape => false})
+    result = url_generator.for(:style_name, {escape: false})
 
     assert_equal "the expected result", result
   end
 
-  should "default to leaving spaces unescaped" do
+  it "defaults to leaving spaces unescaped" do
     expected = "the expected result"
     mock_attachment = MockAttachment.new
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
     result = url_generator.for(:style_name, {})
@@ -109,74 +108,74 @@ class UrlGeneratorTest < Test::Unit::TestCase
     assert_equal "the expected result", result
   end
 
-  should "produce URLs without the updated_at value when the object does not respond to updated_at" do
+  it "produces URLs without the updated_at value when the object does not respond to updated_at" do
     expected = "the expected result"
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    mock_attachment = MockAttachment.new(:responds_to_updated_at => false)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    mock_attachment = MockAttachment.new(responds_to_updated_at: false)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:timestamp => true})
+    result = url_generator.for(:style_name, {timestamp: true})
 
     assert_equal expected, result
   end
 
-  should "produce URLs without the updated_at value when the updated_at value is nil" do
+  it "produces URLs without the updated_at value when the updated_at value is nil" do
     expected = "the expected result"
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    mock_attachment = MockAttachment.new(:responds_to_updated_at => true, :updated_at => nil)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    mock_attachment = MockAttachment.new(responds_to_updated_at: true, updated_at: nil)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:timestamp => true})
+    result = url_generator.for(:style_name, {timestamp: true})
 
     assert_equal expected, result
   end
 
-  should "produce URLs with the updated_at when it exists" do
+  it "produces URLs with the updated_at when it exists" do
     expected = "the expected result"
     updated_at = 1231231234
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    mock_attachment = MockAttachment.new(:updated_at => updated_at)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    mock_attachment = MockAttachment.new(updated_at: updated_at)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:timestamp => true})
+    result = url_generator.for(:style_name, {timestamp: true})
 
     assert_equal "#{expected}?#{updated_at}", result
   end
 
-  should "produce URLs with the updated_at when it exists, separated with a & if a ? follow by = already exists" do
+  it "produces URLs with the updated_at when it exists, separated with a & if a ? follow by = already exists" do
     expected = "the?expected=result"
     updated_at = 1231231234
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    mock_attachment = MockAttachment.new(:updated_at => updated_at)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    mock_attachment = MockAttachment.new(updated_at: updated_at)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:timestamp => true})
+    result = url_generator.for(:style_name, {timestamp: true})
 
     assert_equal "#{expected}&#{updated_at}", result
   end
 
-  should "produce URLs without the updated_at when told to do as much" do
+  it "produces URLs without the updated_at when told to do as much" do
     expected = "the expected result"
     updated_at = 1231231234
-    mock_interpolator = MockInterpolator.new(:result => expected)
-    mock_attachment = MockAttachment.new(:updated_at => updated_at)
-    options = { :interpolator => mock_interpolator }
+    mock_interpolator = MockInterpolator.new(result: expected)
+    mock_attachment = MockAttachment.new(updated_at: updated_at)
+    options = { interpolator: mock_interpolator }
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
 
-    result = url_generator.for(:style_name, {:timestamp => false})
+    result = url_generator.for(:style_name, {timestamp: false})
 
     assert_equal expected, result
   end
 
-  should "produce the correct URL when the instance has a file name" do
+  it "produces the correct URL when the instance has a file name" do
     expected = "the expected result"
-    mock_attachment = MockAttachment.new(:original_filename => 'exists')
+    mock_attachment = MockAttachment.new(original_filename: 'exists')
     mock_interpolator = MockInterpolator.new
-    options = { :interpolator => mock_interpolator, :url => expected}
+    options = { interpolator: mock_interpolator, url: expected}
 
     url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
     url_generator.for(:style_name, {})

data/spec/paperclip/validators/attachment_content_type_validator_spec.rb

@@ -0,0 +1,322 @@
+require 'spec_helper'
+
+describe Paperclip::Validators::AttachmentContentTypeValidator do
+  before do
+    rebuild_model
+    @dummy = Dummy.new
+  end
+
+  def build_validator(options)
+    @validator = Paperclip::Validators::AttachmentContentTypeValidator.new(options.merge(
+      attributes: :avatar
+    ))
+  end
+
+  context "with a nil content type" do
+    before do
+      build_validator content_type: "image/jpg"
+      @dummy.stubs(avatar_content_type: nil)
+      @validator.validate(@dummy)
+    end
+
+    it "does not set an error message" do
+      assert @dummy.errors[:avatar_content_type].blank?
+    end
+  end
+
+  context "with :allow_nil option" do
+    context "as true" do
+      before do
+        build_validator content_type: "image/png", allow_nil: true
+        @dummy.stubs(avatar_content_type: nil)
+        @validator.validate(@dummy)
+      end
+
+      it "allows avatar_content_type as nil" do
+        assert @dummy.errors[:avatar_content_type].blank?
+      end
+    end
+
+    context "as false" do
+      before do
+        build_validator content_type: "image/png", allow_nil: false
+        @dummy.stubs(avatar_content_type: nil)
+        @validator.validate(@dummy)
+      end
+
+      it "does not allow avatar_content_type as nil" do
+        assert @dummy.errors[:avatar_content_type].present?
+      end
+    end
+  end
+
+  context "with a failing validation" do
+    before do
+      build_validator content_type: "image/png", allow_nil: false
+      @dummy.stubs(avatar_content_type: nil)
+      @validator.validate(@dummy)
+    end
+
+    it "adds error to the base object" do
+      assert @dummy.errors[:avatar].present?,
+        "Error not added to base attribute"
+    end
+
+    it "adds error to base object as a string" do
+      expect(@dummy.errors[:avatar].first).to be_a String
+    end
+  end
+
+  context "with a successful validation" do
+    before do
+      build_validator content_type: "image/png", allow_nil: false
+      @dummy.stubs(avatar_content_type: "image/png")
+      @validator.validate(@dummy)
+    end
+
+    it "does not add error to the base object" do
+      assert @dummy.errors[:avatar].blank?,
+        "Error was added to base attribute"
+    end
+  end
+
+  context "with :allow_blank option" do
+    context "as true" do
+      before do
+        build_validator content_type: "image/png", allow_blank: true
+        @dummy.stubs(avatar_content_type: "")
+        @validator.validate(@dummy)
+      end
+
+      it "allows avatar_content_type as blank" do
+        assert @dummy.errors[:avatar_content_type].blank?
+      end
+    end
+
+    context "as false" do
+      before do
+        build_validator content_type: "image/png", allow_blank: false
+        @dummy.stubs(avatar_content_type: "")
+        @validator.validate(@dummy)
+      end
+
+      it "does not allow avatar_content_type as blank" do
+        assert @dummy.errors[:avatar_content_type].present?
+      end
+    end
+  end
+
+  context "whitelist format" do
+    context "with an allowed type" do
+      context "as a string" do
+        before do
+          build_validator content_type: "image/jpg"
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "does not set an error message" do
+          assert @dummy.errors[:avatar_content_type].blank?
+        end
+      end
+
+      context "as an regexp" do
+        before do
+          build_validator content_type: /^image\/.*/
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "does not set an error message" do
+          assert @dummy.errors[:avatar_content_type].blank?
+        end
+      end
+
+      context "as a list" do
+        before do
+          build_validator content_type: ["image/png", "image/jpg", "image/jpeg"]
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "does not set an error message" do
+          assert @dummy.errors[:avatar_content_type].blank?
+        end
+      end
+    end
+
+    context "with a disallowed type" do
+      context "as a string" do
+        before do
+          build_validator content_type: "image/png"
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "sets a correct default error message" do
+          assert @dummy.errors[:avatar_content_type].present?
+          expect(@dummy.errors[:avatar_content_type]).to include "is invalid"
+        end
+      end
+
+      context "as a regexp" do
+        before do
+          build_validator content_type: /^text\/.*/
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "sets a correct default error message" do
+          assert @dummy.errors[:avatar_content_type].present?
+          expect(@dummy.errors[:avatar_content_type]).to include "is invalid"
+        end
+      end
+
+      context "with :message option" do
+        context "without interpolation" do
+          before do
+            build_validator content_type: "image/png", message: "should be a PNG image"
+            @dummy.stubs(avatar_content_type: "image/jpg")
+            @validator.validate(@dummy)
+          end
+
+          it "sets a correct error message" do
+            expect(@dummy.errors[:avatar_content_type]).to include "should be a PNG image"
+          end
+        end
+
+        context "with interpolation" do
+          before do
+            build_validator content_type: "image/png", message: "should have content type %{types}"
+            @dummy.stubs(avatar_content_type: "image/jpg")
+            @validator.validate(@dummy)
+          end
+
+          it "sets a correct error message" do
+            expect(@dummy.errors[:avatar_content_type]).to include "should have content type image/png"
+          end
+        end
+      end
+    end
+  end
+
+  context "blacklist format" do
+    context "with an allowed type" do
+      context "as a string" do
+        before do
+          build_validator not: "image/gif"
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "does not set an error message" do
+          assert @dummy.errors[:avatar_content_type].blank?
+        end
+      end
+
+      context "as an regexp" do
+        before do
+          build_validator not: /^text\/.*/
+          @dummy.stubs(avatar_content_type: "image/jpg")
+          @validator.validate(@dummy)
+        end
+
+        it "does not set an error message" do
+          assert @dummy.errors[:avatar_content_type].blank?
+        end
+      end
+
+      context "as a list" do
+        before do
+          build_validator not: ["image/png", "image/jpg", "image/jpeg"]
+          @dummy.stubs(avatar_content_type: "image/gif")
+          @validator.validate(@dummy)
+        end
+
+        it "does not set an error message" do
+          assert @dummy.errors[:avatar_content_type].blank?
+        end
+      end
+    end
+
+    context "with a disallowed type" do
+      context "as a string" do
+        before do
+          build_validator not: "image/png"
+          @dummy.stubs(avatar_content_type: "image/png")
+          @validator.validate(@dummy)
+        end
+
+        it "sets a correct default error message" do
+          assert @dummy.errors[:avatar_content_type].present?
+          expect(@dummy.errors[:avatar_content_type]).to include "is invalid"
+        end
+      end
+
+      context "as a regexp" do
+        before do
+          build_validator not: /^text\/.*/
+          @dummy.stubs(avatar_content_type: "text/plain")
+          @validator.validate(@dummy)
+        end
+
+        it "sets a correct default error message" do
+          assert @dummy.errors[:avatar_content_type].present?
+          expect(@dummy.errors[:avatar_content_type]).to include "is invalid"
+        end
+      end
+
+      context "with :message option" do
+        context "without interpolation" do
+          before do
+            build_validator not: "image/png", message: "should not be a PNG image"
+            @dummy.stubs(avatar_content_type: "image/png")
+            @validator.validate(@dummy)
+          end
+
+          it "sets a correct error message" do
+            expect(@dummy.errors[:avatar_content_type]).to include "should not be a PNG image"
+          end
+        end
+
+        context "with interpolation" do
+          before do
+            build_validator not: "image/png", message: "should not have content type %{types}"
+            @dummy.stubs(avatar_content_type: "image/png")
+            @validator.validate(@dummy)
+          end
+
+          it "sets a correct error message" do
+            expect(@dummy.errors[:avatar_content_type]).to include "should not have content type image/png"
+          end
+        end
+      end
+    end
+  end
+
+  context "using the helper" do
+    before do
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/jpg"
+    end
+
+    it "adds the validator to the class" do
+      assert Dummy.validators_on(:avatar).any?{ |validator| validator.kind == :attachment_content_type }
+    end
+  end
+
+  context "given options" do
+    it "raises argument error if no required argument was given" do
+      assert_raises(ArgumentError) do
+        build_validator message: "Some message"
+      end
+    end
+
+    it "does not raise argument error if :content_type was given" do
+      build_validator content_type: "image/jpg"
+    end
+
+    it "does not raise argument error if :not was given" do
+      build_validator not: "image/jpg"
+    end
+  end
+end