jr-paperclip 7.3.0

data/spec/paperclip/url_generator_spec.rb

@@ -0,0 +1,231 @@
+require "spec_helper"
+
+describe Paperclip::UrlGenerator do
+  it "uses the given interpolator" do
+    expected = "the expected result"
+    mock_interpolator = MockInterpolator.new(result: expected)
+    mock_attachment = MockAttachment.new(interpolator: mock_interpolator)
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+    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_interpolator = MockInterpolator.new
+    default_url = "the default url"
+    options = { interpolator: mock_interpolator, default_url: default_url }
+    mock_attachment = MockAttachment.new(options)
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+    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_interpolator = MockInterpolator.new
+    default_url = lambda { |attachment| "the #{attachment.class.name} default url" }
+    options = { interpolator: mock_interpolator, default_url: default_url }
+    mock_attachment = MockAttachment.new(options)
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+    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
+    default_url = :to_s
+    mock_interpolator = MockInterpolator.new
+    options = {
+      interpolator: mock_interpolator,
+      default_url: default_url,
+      model: mock_model,
+    }
+    mock_attachment = MockAttachment.new(options)
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+    url_generator.for(:style_name, {})
+
+    assert mock_interpolator.has_interpolated_pattern?(mock_model.to_s),
+           %{expected the interpolator to be passed #{mock_model}, but it wasn't}
+  end
+
+  it "URL-escapes spaces if asked to" do
+    expected = "the expected result"
+    mock_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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)
+    options = { interpolator: mock_interpolator, responds_to_updated_at: false }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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)
+    options = {
+      responds_to_updated_at: true,
+      updated_at: nil,
+      interpolator: mock_interpolator,
+    }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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)
+    options = { interpolator: mock_interpolator, updated_at: updated_at }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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)
+    options = { interpolator: mock_interpolator, updated_at: updated_at }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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)
+    options = { interpolator: mock_interpolator, updated_at: updated_at }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    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_interpolator = MockInterpolator.new
+    options = {
+      interpolator: mock_interpolator,
+      url: expected,
+      original_filename: "exists",
+    }
+    mock_attachment = MockAttachment.new(options)
+
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+    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
+
+  it "doesn't emit deprecation warnings" do
+    expected = "the expected result"
+    mock_interpolator = MockInterpolator.new(result: expected)
+    options = { interpolator: mock_interpolator }
+    mock_attachment = MockAttachment.new(options)
+    url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+
+    expect { url_generator.for(:style_name, escape: true) }.to_not(output(/URI\.(un)?escape is obsolete/).to_stderr)
+  end
+
+  describe "should be able to escape (, ), [, and ]." do
+    def generate(expected, updated_at = nil)
+      mock_interpolator = MockInterpolator.new(result: expected)
+      options = { interpolator: mock_interpolator, updated_at: updated_at }
+      mock_attachment = MockAttachment.new(options)
+      url_generator = Paperclip::UrlGenerator.new(mock_attachment)
+      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,410 @@
+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"
+      allow(@dummy).to receive_messages(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
+        allow(@dummy).to receive_messages(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
+        allow(@dummy).to receive_messages(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
+      allow(@dummy).to receive_messages(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 add_validation_errors_to not set (implicitly :both)" do
+    it "adds error to both attribute and base" do
+      build_validator content_type: "image/png", allow_nil: false
+      allow(@dummy).to receive_messages(avatar_content_type: nil)
+      @validator.validate(@dummy)
+
+      assert @dummy.errors[:avatar_content_type].present?,
+             "Error not added to attribute"
+
+      assert @dummy.errors[:avatar].present?,
+             "Error not added to base attribute"
+    end
+  end
+
+  context "with add_validation_errors_to set to :attribute globally" do
+    before do
+      Paperclip.options[:add_validation_errors_to] = :attribute
+    end
+
+    after do
+      Paperclip.options[:add_validation_errors_to] = :both
+    end
+
+    it "only adds error to attribute not base" do
+      build_validator content_type: "image/png", allow_nil: false
+      allow(@dummy).to receive_messages(avatar_content_type: nil)
+      @validator.validate(@dummy)
+
+      assert @dummy.errors[:avatar_content_type].present?,
+             "Error not added to attribute"
+
+      assert @dummy.errors[:avatar].blank?,
+             "Error added to base attribute"
+    end
+  end
+
+  context "with add_validation_errors_to set to :base globally" do
+    before do
+      Paperclip.options[:add_validation_errors_to] = :base
+    end
+
+    after do
+      Paperclip.options[:add_validation_errors_to] = :both
+    end
+
+    it "only adds error to base not attribute" do
+      build_validator content_type: "image/png", allow_nil: false
+      allow(@dummy).to receive_messages(avatar_content_type: nil)
+      @validator.validate(@dummy)
+
+      assert @dummy.errors[:avatar].present?,
+             "Error not added to base attribute"
+
+      assert @dummy.errors[:avatar_content_type].blank?,
+             "Error added to attribute"
+    end
+  end
+
+  context "with add_validation_errors_to set to :attribute" do
+    it "only adds error to attribute not base" do
+      build_validator content_type: "image/png", allow_nil: false,
+        add_validation_errors_to: :attribute
+      allow(@dummy).to receive_messages(avatar_content_type: nil)
+      @validator.validate(@dummy)
+
+      assert @dummy.errors[:avatar_content_type].present?,
+             "Error not added to attribute"
+
+      assert @dummy.errors[:avatar].blank?,
+             "Error added to base attribute"
+    end
+  end
+
+  context "with add_validation_errors_to set to :base" do
+    it "only adds error to base not attribute" do
+      build_validator content_type: "image/png", allow_nil: false,
+        add_validation_errors_to: :base
+      allow(@dummy).to receive_messages(avatar_content_type: nil)
+      @validator.validate(@dummy)
+
+      assert @dummy.errors[:avatar].present?,
+             "Error not added to base attribute"
+
+      assert @dummy.errors[:avatar_content_type].blank?,
+             "Error added to attribute"
+    end
+  end
+
+  context "with a successful validation" do
+    before do
+      build_validator content_type: "image/png", allow_nil: false
+      allow(@dummy).to receive_messages(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
+        allow(@dummy).to receive_messages(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
+        allow(@dummy).to receive_messages(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"
+          allow(@dummy).to receive_messages(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\/.*/
+          allow(@dummy).to receive_messages(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"]
+          allow(@dummy).to receive_messages(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"
+          allow(@dummy).to receive_messages(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\/.*/
+          allow(@dummy).to receive_messages(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"
+            allow(@dummy).to receive_messages(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}"
+            allow(@dummy).to receive_messages(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"
+          allow(@dummy).to receive_messages(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\/.*/
+          allow(@dummy).to receive_messages(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"]
+          allow(@dummy).to receive_messages(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"
+          allow(@dummy).to receive_messages(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\/.*/
+          allow(@dummy).to receive_messages(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"
+            allow(@dummy).to receive_messages(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}"
+            allow(@dummy).to receive_messages(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