kt-paperclip 5.4.0 → 7.1.1

data/spec/paperclip/interpolations_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Paperclip::Interpolations do
   it "returns all methods but the infrastructure when sent #all" do
     methods = Paperclip::Interpolations.all
-    assert ! methods.include?(:[])
-    assert ! methods.include?(:[]=)
-    assert ! methods.include?(:all)
+    assert !methods.include?(:[])
+    assert !methods.include?(:[]=)
+    assert !methods.include?(:all)
     methods.each do |m|
       assert Paperclip::Interpolations.respond_to?(m)
     end
@@ -24,138 +24,146 @@ describe Paperclip::Interpolations do
   end
 
   it "returns the class of the instance" do
-    class Thing ; end
-    attachment = mock
-    attachment.expects(:instance).returns(attachment)
-    attachment.expects(:class).returns(Thing)
+    class Thing; end
+    attachment = spy
+    expect(attachment).to receive(:instance).and_return(attachment)
+    expect(attachment).to receive(:class).and_return(Thing)
     assert_equal "things", Paperclip::Interpolations.class(attachment, :style)
   end
 
   it "returns the basename of the file" do
-    attachment = mock
-    attachment.expects(:original_filename).returns("one.jpg").times(1)
+    attachment = spy
+    expect(attachment).to receive(:original_filename).and_return("one.jpg")
     assert_equal "one", Paperclip::Interpolations.basename(attachment, :style)
   end
 
   it "returns the extension of the file" do
-    attachment = mock
-    attachment.expects(:original_filename).returns("one.jpg")
-    attachment.expects(:styles).returns({})
+    attachment = spy
+    expect(attachment).to receive(:original_filename).and_return("one.jpg")
+    expect(attachment).to receive(:styles).and_return({})
     assert_equal "jpg", Paperclip::Interpolations.extension(attachment, :style)
   end
 
   it "returns the extension of the file as the format if defined in the style" do
-    attachment = mock
-    attachment.expects(:original_filename).never
-    attachment.expects(:styles).twice.returns({style: {format: "png"}})
+    attachment = spy
+    expect(attachment).to_not receive(:original_filename)
+    expect(attachment).to receive(:styles).at_least(2).times.and_return(style: { format: "png" })
 
-    [:style, 'style'].each do |style|
+    [:style, "style"].each do |style|
       assert_equal "png", Paperclip::Interpolations.extension(attachment, style)
     end
   end
 
   it "returns the extension of the file based on the content type" do
-    attachment = mock
-    attachment.expects(:content_type).returns('image/png')
-    attachment.expects(:styles).returns({})
+    attachment = spy
+    expect(attachment).to receive(:content_type).and_return("image/png")
+    expect(attachment).to receive(:styles).and_return({})
     interpolations = Paperclip::Interpolations
-    interpolations.expects(:extension).returns('random')
+    expect(interpolations).to receive(:extension).and_return("random")
     assert_equal "png", interpolations.content_type_extension(attachment, :style)
   end
 
   it "returns the original extension of the file if it matches a content type extension" do
-    attachment = mock
-    attachment.expects(:content_type).returns('image/jpeg')
-    attachment.expects(:styles).returns({})
+    attachment = spy
+    expect(attachment).to receive(:content_type).and_return("image/jpeg")
+    expect(attachment).to receive(:styles).and_return({})
     interpolations = Paperclip::Interpolations
-    interpolations.expects(:extension).returns('jpe')
+    expect(interpolations).to receive(:extension).and_return("jpe")
     assert_equal "jpe", interpolations.content_type_extension(attachment, :style)
   end
 
   it "returns the extension of the file with a dot" do
-    attachment = mock
-    attachment.expects(:original_filename).returns("one.jpg")
-    attachment.expects(:styles).returns({})
+    attachment = spy
+    expect(attachment).to receive(:original_filename).and_return("one.jpg")
+    expect(attachment).to receive(:styles).and_return({})
     assert_equal ".jpg", Paperclip::Interpolations.dotextension(attachment, :style)
   end
 
   it "returns the extension of the file without a dot if the extension is empty" do
-    attachment = mock
-    attachment.expects(:original_filename).returns("one")
-    attachment.expects(:styles).returns({})
+    attachment = spy
+    expect(attachment).to receive(:original_filename).and_return("one")
+    expect(attachment).to receive(:styles).and_return({})
     assert_equal "", Paperclip::Interpolations.dotextension(attachment, :style)
   end
 
   it "returns the latter half of the content type of the extension if no match found" do
-    attachment = mock
-    attachment.expects(:content_type).at_least_once().returns('not/found')
-    attachment.expects(:styles).returns({})
+    attachment = spy
+    allow(attachment).to receive(:content_type).at_least(1).times.and_return("not/found")
+    allow(attachment).to receive(:styles).and_return({})
     interpolations = Paperclip::Interpolations
-    interpolations.expects(:extension).returns('random')
+    expect(interpolations).to receive(:extension).and_return("random")
     assert_equal "found", interpolations.content_type_extension(attachment, :style)
   end
 
   it "returns the format if defined in the style, ignoring the content type" do
-    attachment = mock
-    attachment.expects(:content_type).returns('image/jpeg')
-    attachment.expects(:styles).returns({style: {format: "png"}})
+    attachment = spy
+    expect(attachment).to receive(:content_type).and_return("image/jpeg")
+    expect(attachment).to receive(:styles).and_return(style: { format: "png" })
     interpolations = Paperclip::Interpolations
-    interpolations.expects(:extension).returns('random')
+    expect(interpolations).to receive(:extension).and_return("random")
     assert_equal "png", interpolations.content_type_extension(attachment, :style)
   end
 
   it "is able to handle numeric style names" do
-    attachment = mock(
+    attachment = spy(
       styles: {:"4" => {format: :expected_extension}}
     )
     assert_equal :expected_extension, Paperclip::Interpolations.extension(attachment, 4)
   end
 
   it "returns the #to_param of the attachment" do
-    attachment = mock
-    attachment.expects(:to_param).returns("23-awesome")
-    attachment.expects(:instance).returns(attachment)
+    attachment = spy
+    expect(attachment).to receive(:to_param).and_return("23-awesome")
+    expect(attachment).to receive(:instance).and_return(attachment)
     assert_equal "23-awesome", Paperclip::Interpolations.param(attachment, :style)
   end
 
   it "returns the id of the attachment" do
-    attachment = mock
-    attachment.expects(:id).returns(23)
-    attachment.expects(:instance).returns(attachment)
+    attachment = spy
+    expect(attachment).to receive(:id).and_return(23)
+    expect(attachment).to receive(:instance).and_return(attachment)
     assert_equal 23, Paperclip::Interpolations.id(attachment, :style)
   end
 
   it "returns nil for attachments to new records" do
-    attachment = mock
-    attachment.expects(:id).returns(nil)
-    attachment.expects(:instance).returns(attachment)
+    attachment = spy
+    expect(attachment).to receive(:id).and_return(nil)
+    expect(attachment).to receive(:instance).and_return(attachment)
     assert_nil Paperclip::Interpolations.id(attachment, :style)
   end
 
   it "returns the partitioned id of the attachment when the id is an integer" do
-    attachment = mock
-    attachment.expects(:id).returns(23)
-    attachment.expects(:instance).returns(attachment)
+    attachment = spy
+    expect(attachment).to receive(:id).and_return(23)
+    expect(attachment).to receive(:instance).and_return(attachment)
     assert_equal "000/000/023", Paperclip::Interpolations.id_partition(attachment, :style)
   end
 
+  it "returns the partitioned id when the id is above 999_999_999" do
+    attachment = spy
+    expect(attachment).to receive(:id).and_return(Paperclip::Interpolations::ID_PARTITION_LIMIT)
+    expect(attachment).to receive(:instance).and_return(attachment)
+    assert_equal "001/000/000/000",
+                 Paperclip::Interpolations.id_partition(attachment, :style)
+  end
+
   it "returns the partitioned id of the attachment when the id is a string" do
-    attachment = mock
-    attachment.expects(:id).returns("32fnj23oio2f")
-    attachment.expects(:instance).returns(attachment)
+    attachment = spy
+    expect(attachment).to receive(:id).and_return("32fnj23oio2f")
+    expect(attachment).to receive(:instance).and_return(attachment)
     assert_equal "32f/nj2/3oi", Paperclip::Interpolations.id_partition(attachment, :style)
   end
 
   it "returns nil for the partitioned id of an attachment to a new record (when the id is nil)" do
-    attachment = mock
-    attachment.expects(:id).returns(nil)
-    attachment.expects(:instance).returns(attachment)
+    attachment = spy
+    expect(attachment).to receive(:id).and_return(nil)
+    expect(attachment).to receive(:instance).and_return(attachment)
     assert_nil Paperclip::Interpolations.id_partition(attachment, :style)
   end
 
   it "returns the name of the attachment" do
-    attachment = mock
-    attachment.expects(:name).returns("file")
+    attachment = spy
+    expect(attachment).to receive(:name).and_return("file")
     assert_equal "files", Paperclip::Interpolations.attachment(attachment, :style)
   end
 
@@ -164,89 +172,89 @@ describe Paperclip::Interpolations do
   end
 
   it "returns the default style" do
-    attachment = mock
-    attachment.expects(:default_style).returns(:default_style)
+    attachment = spy
+    expect(attachment).to receive(:default_style).and_return(:default_style)
     assert_equal :default_style, Paperclip::Interpolations.style(attachment, nil)
   end
 
   it "reinterpolates :url" do
-    attachment = mock
-    attachment.expects(:url).with(:style, timestamp: false, escape: false).returns("1234")
+    attachment = spy
+    expect(attachment).to receive(:url).with(:style, timestamp: false, escape: false).and_return("1234")
     assert_equal "1234", Paperclip::Interpolations.url(attachment, :style)
   end
 
   it "raises if infinite loop detcted reinterpolating :url" do
     attachment = Object.new
     class << attachment
-      def url(*args)
+      def url(*_args)
         Paperclip::Interpolations.url(self, :style)
       end
     end
-    assert_raises(Paperclip::Errors::InfiniteInterpolationError){ Paperclip::Interpolations.url(attachment, :style) }
+    assert_raises(Paperclip::Errors::InfiniteInterpolationError) { Paperclip::Interpolations.url(attachment, :style) }
   end
 
   it "returns the filename as basename.extension" do
-    attachment = mock
-    attachment.expects(:styles).returns({})
-    attachment.expects(:original_filename).returns("one.jpg").times(2)
+    attachment = spy
+    expect(attachment).to receive(:styles).and_return({})
+    expect(attachment).to receive(:original_filename).and_return("one.jpg").twice
     assert_equal "one.jpg", Paperclip::Interpolations.filename(attachment, :style)
   end
 
   it "returns the filename as basename.extension when format supplied" do
-    attachment = mock
-    attachment.expects(:styles).returns({style: {format: :png}})
-    attachment.expects(:original_filename).returns("one.jpg").times(1)
+    attachment = spy
+    expect(attachment).to receive(:styles).and_return(style: { format: :png })
+    expect(attachment).to receive(:original_filename).and_return("one.jpg").once
     assert_equal "one.png", Paperclip::Interpolations.filename(attachment, :style)
   end
 
   it "returns the filename as basename when extension is blank" do
-    attachment = mock
-    attachment.stubs(:styles).returns({})
-    attachment.stubs(:original_filename).returns("one")
+    attachment = spy
+    allow(attachment).to receive(:styles).and_return({})
+    allow(attachment).to receive(:original_filename).and_return("one")
     assert_equal "one", Paperclip::Interpolations.filename(attachment, :style)
   end
-  
+
   it "returns the basename when the extension contains regexp special characters" do
-    attachment = mock
-    attachment.stubs(:styles).returns({})
-    attachment.stubs(:original_filename).returns("one.ab)")
+    attachment = spy
+    allow(attachment).to receive(:styles).and_return({})
+    allow(attachment).to receive(:original_filename).and_return("one.ab)")
     assert_equal "one", Paperclip::Interpolations.basename(attachment, :style)
   end
 
   it "returns the timestamp" do
     now = Time.now
-    zone = 'UTC'
-    attachment = mock
-    attachment.expects(:instance_read).with(:updated_at).returns(now)
-    attachment.expects(:time_zone).returns(zone)
+    zone = "UTC"
+    attachment = spy
+    expect(attachment).to receive(:instance_read).with(:updated_at).and_return(now)
+    expect(attachment).to receive(:time_zone).and_return(zone)
     assert_equal now.in_time_zone(zone).to_s, Paperclip::Interpolations.timestamp(attachment, :style)
   end
 
   it "returns updated_at" do
-    attachment = mock
+    attachment = spy
     seconds_since_epoch = 1234567890
-    attachment.expects(:updated_at).returns(seconds_since_epoch)
+    expect(attachment).to receive(:updated_at).and_return(seconds_since_epoch)
     assert_equal seconds_since_epoch, Paperclip::Interpolations.updated_at(attachment, :style)
   end
 
   it "returns attachment's hash when passing both arguments" do
-    attachment = mock
+    attachment = spy
     fake_hash = "a_wicked_secure_hash"
-    attachment.expects(:hash_key).returns(fake_hash)
+    expect(attachment).to receive(:hash_key).and_return(fake_hash)
     assert_equal fake_hash, Paperclip::Interpolations.hash(attachment, :style)
   end
 
   it "returns Object#hash when passing no argument" do
-    attachment = mock
+    attachment = spy
     fake_hash = "a_wicked_secure_hash"
-    attachment.expects(:hash_key).never.returns(fake_hash)
+    expect(attachment).to_not receive(:hash_key)
     assert_not_equal fake_hash, Paperclip::Interpolations.hash
   end
 
   it "calls all expected interpolations with the given arguments" do
-    Paperclip::Interpolations.expects(:id).with(:attachment, :style).returns(1234)
-    Paperclip::Interpolations.expects(:attachment).with(:attachment, :style).returns("attachments")
-    Paperclip::Interpolations.expects(:notreal).never
+    expect(Paperclip::Interpolations).to receive(:id).with(:attachment, :style).and_return(1234)
+    expect(Paperclip::Interpolations).to receive(:attachment).with(:attachment, :style).and_return("attachments")
+    expect(Paperclip::Interpolations).to_not receive(:notreal)
     value = Paperclip::Interpolations.interpolate(":notreal/:id/:attachment", :attachment, :style)
     assert_equal ":notreal/1234/attachments", value
   end
@@ -255,7 +263,7 @@ describe Paperclip::Interpolations do
     Paperclip.interpolates :foo? do
       "bar"
     end
-    Paperclip::Interpolations.expects(:fool).never
+    expect(Paperclip::Interpolations).to_not receive(:fool)
     value = Paperclip::Interpolations.interpolate(":fo/:foo?")
     assert_equal ":fo/bar", value
   end

data/spec/paperclip/io_adapters/abstract_adapter_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Paperclip::AbstractAdapter do
   class TestAdapter < Paperclip::AbstractAdapter
@@ -13,9 +13,9 @@ describe Paperclip::AbstractAdapter do
 
   context "content type from file contents" do
     before do
-      subject.stubs(:path).returns("image.png")
-      Paperclip.stubs(:run).returns("image/png\n")
-      Paperclip::ContentTypeDetector.any_instance.stubs(:type_from_mime_magic).returns("image/png")
+      allow(subject).to receive(:path).and_return("image.png")
+      allow(Paperclip).to receive(:run).and_return("image/png\n")
+      allow_any_instance_of(Paperclip::ContentTypeDetector).to receive(:type_from_marcel).and_return("image/png")
     end
 
     it "returns the content type without newline" do
@@ -31,29 +31,29 @@ describe Paperclip::AbstractAdapter do
 
   context "delegation" do
     before do
-      subject.tempfile = stub("Tempfile")
+      subject.tempfile = double("Tempfile")
     end
 
     [:binmode, :binmode?, :close, :close!, :closed?, :eof?, :path, :readbyte, :rewind, :unlink].each do |method|
       it "delegates #{method} to @tempfile" do
-        subject.tempfile.stubs(method)
+        allow(subject.tempfile).to receive(method)
         subject.public_send(method)
-        assert_received subject.tempfile, method
+        expect(subject.tempfile).to have_received(method)
       end
     end
   end
 
-  it 'gets rid of slashes and colons in filenames' do
+  it "gets rid of slashes and colons in filenames" do
     subject.original_filename = "awesome/file:name.png"
 
     assert_equal "awesome_file_name.png", subject.original_filename
   end
 
-  it 'is an assignment' do
+  it "is an assignment" do
     assert subject.assignment?
   end
 
-  it 'is not nil' do
+  it "is not nil" do
     assert !subject.nil?
   end
 
@@ -61,7 +61,7 @@ describe Paperclip::AbstractAdapter do
     expect(subject.send(:destination).path).to_not be_nil
   end
 
-  it 'uses the original filename to generate the tempfile' do
+  it "uses the original filename to generate the tempfile" do
     subject.original_filename = "file.png"
     expect(subject.send(:destination).path).to end_with(".png")
   end
@@ -70,7 +70,7 @@ describe Paperclip::AbstractAdapter do
     subject { TestAdapter.new(nil, options) }
 
     before do
-      subject.stubs(:path).returns(fixture_file("50x50.png"))
+      allow(subject).to receive(:path).and_return(fixture_file("50x50.png"))
     end
 
     context "MD5" do
@@ -93,6 +93,34 @@ describe Paperclip::AbstractAdapter do
     end
   end
 
+  context "#copy_to_tempfile" do
+    around do |example|
+      FileUtils.module_eval do
+        class << self
+          alias paperclip_ln ln
+
+          def ln(*)
+            raise Errno::EXDEV
+          end
+        end
+      end
+
+      example.run
+
+      FileUtils.module_eval do
+        class << self
+          alias ln paperclip_ln
+          undef paperclip_ln
+        end
+      end
+    end
+
+    it "should return a readable file even when linking fails" do
+      src = open(fixture_file("5k.png"), "rb")
+      expect(subject.send(:copy_to_tempfile, src).read).to eq src.read
+    end
+  end
+
   context "#original_filename=" do
     it "should not fail with a nil original filename" do
       expect { subject.original_filename = nil }.not_to raise_error
@@ -124,7 +152,7 @@ describe Paperclip::AbstractAdapter do
     end
 
     it "should be able to reopen the file after symlink has failed" do
-      FileUtils.expects(:ln).raises(Errno::EXDEV)
+      expect(FileUtils).to receive(:ln).and_raise(Errno::EXDEV)
 
       expect(subject.copy_to_tempfile(file).read).to eq(body)
     end

data/spec/paperclip/io_adapters/attachment_adapter_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Paperclip::AttachmentAdapter do
   before do
-    rebuild_model path: "tmp/:class/:attachment/:style/:filename", styles: {thumb: '50x50'}
+    rebuild_model path: "tmp/:class/:attachment/:style/:filename", styles: { thumb: "50x50" }
     @attachment = Dummy.new.avatar
   end
 
@@ -39,7 +39,7 @@ describe Paperclip::AttachmentAdapter do
     end
 
     it "returns false for a call to nil?" do
-      assert ! @subject.nil?
+      assert !@subject.nil?
     end
 
     it "generates a MD5 hash of the contents" do
@@ -50,18 +50,17 @@ describe Paperclip::AttachmentAdapter do
     it "reads the contents of the file" do
       expected = @file.read
       actual = @subject.read
-      assert expected.length > 0
+      assert !expected.empty?
       assert_equal expected.length, actual.length
       assert_equal expected, actual
     end
-
   end
 
   context "for a file with restricted characters in the name" do
     before do
       file_contents = IO.read(fixture_file("animated.gif"))
       @file = StringIO.new(file_contents)
-      @file.stubs(:original_filename).returns('image:restricted.gif')
+      allow(@file).to receive(:original_filename).and_return("image:restricted.gif")
       @file.binmode
 
       @attachment.assign(@file)
@@ -79,7 +78,7 @@ describe Paperclip::AttachmentAdapter do
     end
 
     it "does not generate filenames that include restricted characters" do
-      assert_equal 'image_restricted.gif', @subject.original_filename
+      assert_equal "image_restricted.gif", @subject.original_filename
     end
   end
 
@@ -121,7 +120,7 @@ describe Paperclip::AttachmentAdapter do
     end
 
     it "returns false for a call to nil?" do
-      assert ! @subject.nil?
+      assert !@subject.nil?
     end
 
     it "generates a MD5 hash of the contents" do
@@ -133,10 +132,9 @@ describe Paperclip::AttachmentAdapter do
       @thumb.rewind
       expected = @thumb.read
       actual = @subject.read
-      assert expected.length > 0
+      assert !expected.empty?
       assert_equal expected.length, actual.length
       assert_equal expected, actual
     end
-
   end
 end

data/spec/paperclip/io_adapters/data_uri_adapter_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Paperclip::DataUriAdapter do
   before do
@@ -13,12 +13,12 @@ describe Paperclip::DataUriAdapter do
     end
   end
 
-  it 'allows a missing mime-type' do
+  it "allows a missing mime-type" do
     adapter = Paperclip.io_adapters.for("data:;base64,#{original_base64_content}")
     assert_equal Paperclip::DataUriAdapter, adapter.class
   end
 
-  it 'alows mime type that has dot in it' do
+  it "alows mime type that has dot in it" do
     adapter = Paperclip.io_adapters.for("data:image/vnd.microsoft.icon;base64,#{original_base64_content}")
     assert_equal Paperclip::DataUriAdapter, adapter.class
   end
@@ -57,26 +57,25 @@ describe Paperclip::DataUriAdapter do
       assert_equal @subject.fingerprint, @subject.fingerprint
     end
 
-    it 'accepts a content_type' do
-      @subject.content_type = 'image/png'
-      assert_equal 'image/png', @subject.content_type
+    it "accepts a content_type" do
+      @subject.content_type = "image/png"
+      assert_equal "image/png", @subject.content_type
     end
 
-    it 'accepts an original_filename' do
-      @subject.original_filename = 'image.png'
-      assert_equal 'image.png', @subject.original_filename
+    it "accepts an original_filename" do
+      @subject.original_filename = "image.png"
+      assert_equal "image.png", @subject.original_filename
     end
 
     it "does not generate filenames that include restricted characters" do
-      @subject.original_filename = 'image:restricted.png'
-      assert_equal 'image_restricted.png', @subject.original_filename
+      @subject.original_filename = "image:restricted.png"
+      assert_equal "image_restricted.png", @subject.original_filename
     end
 
     it "does not generate paths that include restricted characters" do
-      @subject.original_filename = 'image:restricted.png'
+      @subject.original_filename = "image:restricted.png"
       expect(@subject.path).to_not match(/:/)
     end
-
   end
 
   def original_base64_content
@@ -84,6 +83,6 @@ describe Paperclip::DataUriAdapter do
   end
 
   def original_file_contents
-    @original_file_contents ||= File.read(fixture_file('5k.png'))
+    @original_file_contents ||= File.read(fixture_file("5k.png"))
   end
 end

data/spec/paperclip/io_adapters/empty_string_adapter_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Paperclip::EmptyStringAdapter do
-  context 'a new instance' do
+  context "a new instance" do
     before do
-      @subject = Paperclip.io_adapters.for('')
+      @subject = Paperclip.io_adapters.for("")
     end
 
     it "returns false for a call to nil?" do
       assert !@subject.nil?
     end
 
-    it 'returns false for a call to assignment?' do
+    it "returns false for a call to assignment?" do
       assert !@subject.assignment?
     end
   end