paperclip_jk 5.0.0.beta2

data/spec/paperclip/url_generator_spec.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Paperclip::UrlGenerator do
+  it "uses the given interpolator" do
+    expected = "the expected result"
+    mock_attachment = MockAttachment.new
+    mock_interpolator = MockInterpolator.new(result: expected)
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment,
+                                                { interpolator: mock_interpolator })
+    result = url_generator.for(:style_name, {})
+
+    assert_equal expected, result
+    assert mock_interpolator.has_interpolated_attachment?(mock_attachment)
+    assert mock_interpolator.has_interpolated_style_name?(:style_name)
+  end
+
+  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}
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+    url_generator.for(:style_name, {})
+
+    assert mock_interpolator.has_interpolated_pattern?(default_url),
+      "expected the interpolator to be passed #{default_url.inspect} but it wasn't"
+  end
+
+  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}
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+    url_generator.for(:style_name, {})
+
+    assert mock_interpolator.has_interpolated_pattern?("the MockAttachment default url"),
+      %{expected the interpolator to be passed "the MockAttachment default url", but it wasn't}
+  end
+
+  it "executes the method named by the symbol as the default URL when no file is assigned" do
+    mock_model = FakeModel.new
+    mock_attachment = MockAttachment.new(model: mock_model)
+    mock_interpolator = MockInterpolator.new
+    default_url = :to_s
+    options = { interpolator: mock_interpolator, default_url: default_url}
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+    url_generator.for(:style_name, {})
+
+    assert mock_interpolator.has_interpolated_pattern?(mock_model.to_s),
+      %{expected the interpolator to be passed #{mock_model.to_s}, but it wasn't}
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {escape: true})
+
+    assert_equal "the%20expected%20result", result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {escape: true})
+
+    assert_equal "the escaped result", result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {escape: false})
+
+    assert_equal "the expected result", result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {})
+
+    assert_equal "the expected result", result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {timestamp: true})
+
+    assert_equal expected, result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {timestamp: true})
+
+    assert_equal expected, result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {timestamp: true})
+
+    assert_equal "#{expected}?#{updated_at}", result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {timestamp: true})
+
+    assert_equal "#{expected}&#{updated_at}", result
+  end
+
+  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 }
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+
+    result = url_generator.for(:style_name, {timestamp: false})
+
+    assert_equal expected, result
+  end
+
+  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_interpolator = MockInterpolator.new
+    options = { interpolator: mock_interpolator, url: expected}
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+    url_generator.for(:style_name, {})
+
+    assert mock_interpolator.has_interpolated_pattern?(expected),
+      "expected the interpolator to be passed #{expected.inspect} but it wasn't"
+  end
+
+  describe "should be able to escape (, ), [, and ]." do
+    def generate(expected, updated_at=nil)
+      mock_attachment = MockAttachment.new(updated_at: updated_at)
+      mock_interpolator = MockInterpolator.new(result: expected)
+      options = { interpolator: mock_interpolator }
+      url_generator = Paperclip::UrlGenerator.new(mock_attachment, options)
+      def url_generator.respond_to(params)
+        false if params == :escape
+      end
+      url_generator.for(:style_name, {escape: true, timestamp: !!updated_at})
+    end
+
+    it "not timestamp" do
+      expected = "the(expected)result[]"
+      assert_equal "the%28expected%29result%5B%5D", generate(expected)
+    end
+
+    it "timestamp" do
+      expected = "the(expected)result[]"
+      updated_at = 1231231234
+      assert_equal "the%28expected%29result%5B%5D?#{updated_at}",
+        generate(expected, updated_at)
+    end
+  end
+end

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