card 1.19.0 → 1.19.1

data/vendor/carrierwave/spec/sanitized_file_spec.rb

@@ -0,0 +1,805 @@
+require 'spec_helper'
+
+begin
+  # Use mime/types/columnar if available, for reduced memory usage
+  require 'mime/types/columnar'
+rescue LoadError
+  require 'mime/types'
+end
+
+describe CarrierWave::SanitizedFile do
+  before do
+    FileUtils.cp(file_path('test.jpg'), file_path('llama.jpg'))
+  end
+
+  after(:all) do
+    if File.exist?(file_path('llama.jpg'))
+      FileUtils.rm(file_path('llama.jpg'))
+    end
+    FileUtils.rm_rf(public_path)
+  end
+
+  describe "#empty?" do
+    it "should be empty for nil" do
+      sanitized_file = CarrierWave::SanitizedFile.new(nil)
+
+      expect(sanitized_file).to be_empty
+    end
+
+    it "should be empty for an empty string" do
+      sanitized_file = CarrierWave::SanitizedFile.new("")
+
+      expect(sanitized_file).to be_empty
+    end
+
+    it "should be empty for an empty StringIO" do
+      sanitized_file = CarrierWave::SanitizedFile.new(StringIO.new(""))
+
+      expect(sanitized_file).to be_empty
+    end
+
+  end
+
+  describe '#original_filename' do
+    it "should default to the original_filename" do
+      file = double('file', :original_filename => 'llama.jpg')
+      sanitized_file = CarrierWave::SanitizedFile.new(file)
+      expect(sanitized_file.original_filename).to eq("llama.jpg")
+    end
+
+    it "should defer to the base name of the path if original_filename is unavailable" do
+      file = double('file', :path => '/path/to/test.jpg')
+      sanitized_file = CarrierWave::SanitizedFile.new(file)
+      expect(sanitized_file.original_filename).to eq("test.jpg")
+    end
+
+    it "should be nil otherwise" do
+      file = double('file')
+      sanitized_file = CarrierWave::SanitizedFile.new(file)
+      expect(sanitized_file.original_filename).to be_nil
+    end
+  end
+
+  describe "#basename" do
+    it "should return the basename for complicated extensions" do
+      sanitized_file = CarrierWave::SanitizedFile.new(file_path("complex.filename.tar.gz"))
+
+      expect(sanitized_file.basename).to eq("complex.filename")
+    end
+
+    it "should be the filename if the file has no extension" do
+      sanitized_file = CarrierWave::SanitizedFile.new(file_path("complex"))
+
+      expect(sanitized_file.basename).to eq("complex")
+    end
+  end
+
+  describe "#extension" do
+    %w[gz bz2 z lz xz].each do |ext|
+      it "should return the extension for complicated extensions (tar.#{ext})" do
+        sanitized_file = CarrierWave::SanitizedFile.new(file_path("complex.filename.tar.#{ext}"))
+
+        expect(sanitized_file.extension).to eq("tar.#{ext}")
+      end
+    end
+
+    it "should return the extension for real-world user file names" do
+      sanitized_file = CarrierWave::SanitizedFile.new(file_path("Photo on 2009-12-01 at 11.12.jpg"))
+
+      expect(sanitized_file.extension).to eq("jpg")
+    end
+
+    it "should return the extension for basic filenames" do
+      sanitized_file = CarrierWave::SanitizedFile.new(file_path("something.png"))
+
+      expect(sanitized_file.extension).to eq("png")
+    end
+
+    it "should be an empty string if the file has no extension" do
+      sanitized_file = CarrierWave::SanitizedFile.new(file_path("complex"))
+
+      expect(sanitized_file.extension).to eq("")
+    end
+  end
+
+  describe "#filename" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(nil) }
+
+    it "should default to the original filename if it is valid" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("llama.jpg")
+      expect(sanitized_file.filename).to eq("llama.jpg")
+    end
+
+    it "should remove illegal characters from a filename" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("test-s,%&m#st?.jpg")
+      expect(sanitized_file.filename).to eq("test-s___m_st_.jpg")
+    end
+
+    it "should remove slashes from the filename" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("../../very_tricky/foo.bar")
+      expect(sanitized_file.filename).not_to match(/[\\\/]/)
+    end
+
+    it "should remove illegal characters if there is no extension" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("`*foo")
+      expect(sanitized_file.filename).to eq("__foo")
+    end
+
+    it "should remove the path prefix on Windows" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return('c:\temp\foo.txt')
+      expect(sanitized_file.filename).to eq("foo.txt")
+    end
+
+    it "should make sure the *nix directory thingies can't be used as filenames" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return(".")
+      expect(sanitized_file.filename).to eq("_.")
+    end
+
+    it "should maintain uppercase filenames" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("DSC4056.JPG")
+      expect(sanitized_file.filename).to eq("DSC4056.JPG")
+    end
+
+    it "should remove illegal characters from a non-ASCII filename" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("⟲«Du côté des chars lourds»_123.doc")
+      expect(sanitized_file.filename).to eq("__Du_côté_des_chars_lourds__123.doc")
+    end
+
+    it "should default to the original non-ASCII filename if it is valid" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("тестовый.jpg")
+      expect(sanitized_file.filename).to eq("тестовый.jpg")
+    end
+
+    it "should downcase non-ASCII characters properly" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("ТестоВый Ёжик.jpg")
+      expect(sanitized_file.filename).to eq("ТестоВый_Ёжик.jpg")
+    end
+  end
+
+  describe "#filename with an overridden sanitize_regexp" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(nil) }
+
+    before do
+      allow(sanitized_file).to receive(:sanitize_regexp).and_return(/[^a-zA-Z\.\-\+_]/)
+    end
+
+    it "should default to the original filename if it is valid" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("llama.jpg")
+      expect(sanitized_file.filename).to eq("llama.jpg")
+    end
+
+    it "should remove illegal characters from a filename" do
+      expect(sanitized_file).to receive(:original_filename).at_least(:once).and_return("123.jpg")
+      expect(sanitized_file.filename).to eq("___.jpg")
+    end
+  end
+
+  describe "#content_type" do
+    it "preserves file's content_type" do
+      sanitized_file = CarrierWave::SanitizedFile.new(content_type: "image/png")
+
+      expect(sanitized_file.content_type).to eq("image/png")
+    end
+
+    it "preserves file's content_type when passed as type (Rack)" do
+      sanitized_file = CarrierWave::SanitizedFile.new(type: "image/png")
+
+      expect(sanitized_file.content_type).to eq("image/png")
+    end
+
+    it "handles Mime::Type object" do
+      file = File.open(file_path('sponsored.doc'))
+      allow(file).to receive(:content_type).and_return(MIME::Type.new("application/msword"))
+      sanitized_file = CarrierWave::SanitizedFile.new(file)
+      allow(sanitized_file).to receive(:file).and_return(file)
+
+      expect { sanitized_file.content_type }.not_to raise_error
+      expect(sanitized_file.content_type).to eq("application/msword")
+    end
+
+    it "reads content type from path if missing" do
+      sanitized_file = CarrierWave::SanitizedFile.new("llama.jpg")
+
+      expect(sanitized_file.content_type).to eq("image/jpeg")
+    end
+  end
+
+  describe "#content_type=" do
+    it "sets content_type" do
+      sanitized_file = CarrierWave::SanitizedFile.new(content_type: "image/png")
+      sanitized_file.content_type = "text/html"
+
+      expect(sanitized_file.content_type).to eq("text/html")
+    end
+  end
+
+  shared_examples_for "all valid sanitized files" do
+    describe '#empty?' do
+      it "should not be empty" do
+        expect(sanitized_file).not_to be_empty
+      end
+    end
+
+    describe '#original_filename' do
+      it "should return the original filename" do
+        expect(sanitized_file.original_filename).to eq("llama.jpg")
+      end
+    end
+
+    describe "#filename" do
+      it "should return the filename" do
+        expect(sanitized_file.filename).to eq("llama.jpg")
+      end
+    end
+
+    describe "#basename" do
+      it "should return the basename" do
+        expect(sanitized_file.basename).to eq("llama")
+      end
+    end
+
+    describe "#extension" do
+      it "should return the extension" do
+        expect(sanitized_file.extension).to eq("jpg")
+      end
+    end
+
+    describe "#read" do
+      it "should return the contents of the file" do
+        expect(sanitized_file.read).to eq("this is stuff")
+      end
+    end
+
+    describe "#size" do
+      it "should return the size of the file" do
+        expect(sanitized_file.size).to eq(13)
+      end
+    end
+
+    describe "#move_to" do
+      after do
+        FileUtils.rm_f(file_path("gurr.png"))
+      end
+
+      it "should be moved to the correct location" do
+        sanitized_file.move_to(file_path("gurr.png"))
+
+        expect(File.exist?( file_path("gurr.png") )).to be_truthy
+      end
+
+      it "should have changed its path when moved" do
+        sanitized_file.move_to(file_path("gurr.png"))
+
+        expect(sanitized_file.path).to eq(file_path("gurr.png"))
+      end
+
+      it "should have changed its filename when moved" do
+        sanitized_file.move_to(file_path("gurr.png"))
+
+        expect(sanitized_file.filename).to eq("gurr.png")
+      end
+
+      it "should have changed its basename when moved" do
+        sanitized_file.move_to(file_path("gurr.png"))
+
+        expect(sanitized_file.basename).to eq("gurr")
+      end
+
+      it "should have changed its extension when moved" do
+        sanitized_file.move_to(file_path("gurr.png"))
+
+        expect(sanitized_file.extension).to eq("png")
+      end
+
+      it "should set the right permissions" do
+        sanitized_file.move_to(file_path("gurr.png"), 0755)
+
+        expect(sanitized_file).to have_permissions(0755)
+      end
+
+      it "should set the right directory permissions" do
+        sanitized_file.move_to(file_path("new_dir","gurr.png"), nil, 0775)
+
+        expect(sanitized_file).to have_directory_permissions(0775)
+        FileUtils.rm_rf(file_path("new_dir"))
+      end
+
+      it "should return itself" do
+        expect(sanitized_file.move_to(file_path("gurr.png"))).to eq(sanitized_file)
+      end
+    end
+
+    describe "#copy_to" do
+      after do
+        FileUtils.rm_f(file_path("gurr.png"))
+      end
+
+      it "should be copied to the correct location" do
+        sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(File.exist?( file_path("gurr.png") )).to be_truthy
+
+        expect(file_path("gurr.png")).to be_identical_to(file_path("llama.jpg"))
+      end
+
+      it "should not have changed its path when copied" do
+        expect(running { sanitized_file.copy_to(file_path("gurr.png")) }).not_to change(sanitized_file, :path)
+      end
+
+      it "should not have changed its filename when copied" do
+        expect(running { sanitized_file.copy_to(file_path("gurr.png")) }).not_to change(sanitized_file, :filename)
+      end
+
+      it "should return an object of the same class when copied" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(new_file).to be_an_instance_of(sanitized_file.class)
+      end
+
+      it "should adjust the path of the object that is returned when copied" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(new_file.path).to eq(file_path("gurr.png"))
+      end
+
+      it "should adjust the filename of the object that is returned when copied" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(new_file.filename).to eq("gurr.png")
+      end
+
+      it "should adjust the basename of the object that is returned when copied" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(new_file.basename).to eq("gurr")
+      end
+
+      it "should adjust the extension of the object that is returned when copied" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(new_file.extension).to eq("png")
+      end
+
+      it "should set the right permissions" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"), 0755)
+
+        expect(new_file).to have_permissions(0755)
+      end
+
+      it "should set the right directory permissions" do
+        new_file = sanitized_file.copy_to(file_path("new_dir", "gurr.png"), nil, 0755)
+
+        expect(new_file).to have_directory_permissions(0755)
+        FileUtils.rm_rf(file_path("new_dir"))
+      end
+
+      it "should preserve the file's content type" do
+        new_file = sanitized_file.copy_to(file_path("gurr.png"))
+
+        expect(new_file.content_type).to eq(sanitized_file.content_type)
+      end
+    end
+  end
+
+  shared_examples_for "all valid sanitized files that are stored on disk" do
+    describe "#move_to" do
+      it "should not raise an error when moved to its own location" do
+        expect(running { sanitized_file.move_to(sanitized_file.path) }).not_to raise_error
+      end
+
+      it "should remove the original file" do
+        original_path = sanitized_file.path
+        sanitized_file.move_to(public_path("blah.txt"))
+
+        expect(File.exist?(original_path)).to be_falsey
+      end
+    end
+
+    describe '#copy_to' do
+      it "should return a new instance when copied to its own location" do
+        expect(running {
+          new_file = sanitized_file.copy_to(sanitized_file.path)
+          expect(new_file).to be_an_instance_of(sanitized_file.class)
+        }).not_to raise_error
+      end
+
+      it "should not remove the original file" do
+        new_file = sanitized_file.copy_to(public_path("blah.txt"))
+
+        expect(File.exist?(sanitized_file.path)).to be_truthy
+        expect(File.exist?(new_file.path)).to be_truthy
+      end
+    end
+
+    describe "#exists?" do
+      it "should be true" do
+        expect(sanitized_file.exists?).to be_truthy
+      end
+    end
+
+    describe "#delete" do
+      it "should remove it from the filesystem" do
+        expect(File.exist?(sanitized_file.path)).to be_truthy
+
+        sanitized_file.delete
+
+        expect(File.exist?(sanitized_file.path)).to be_falsey
+      end
+    end
+
+    describe "#to_file" do
+      it "should return a File object" do
+        expect(sanitized_file.to_file).to be_a(File)
+      end
+
+      it "should have the same path as the SanitizedFile" do
+        expect(sanitized_file.to_file.path).to eq(sanitized_file.path)
+      end
+
+      it "should have the same contents as the SantizedFile" do
+        expect(sanitized_file.to_file.read).to eq(sanitized_file.read)
+      end
+    end
+  end
+
+  shared_examples_for "all valid sanitized files that are read from an IO object" do
+
+    describe "#read" do
+      it "should have an open IO object" do
+        expect(sanitized_file.instance_variable_get(:@file).closed?).to be_falsey
+      end
+
+      it "should close the IO object after reading" do
+        sanitized_file.read
+
+        expect(sanitized_file.instance_variable_get(:@file).closed?).to be_truthy
+      end
+    end
+  end
+
+  describe "with a valid Hash" do
+    let(:hash) {
+      {
+        "tempfile" => stub_merb_tempfile("llama.jpg"),
+        "filename" => "llama.jpg",
+        "content_type" => "image/jpeg"
+      }
+    }
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(hash) }
+
+    it_should_behave_like "all valid sanitized files"
+
+    it_should_behave_like "all valid sanitized files that are stored on disk"
+
+    it_should_behave_like "all valid sanitized files that are read from an IO object"
+
+    describe "#path" do
+      it "should return the path of the tempfile" do
+        expect(sanitized_file.path).not_to be_nil
+        expect(sanitized_file.path).to eq(hash["tempfile"].path)
+      end
+    end
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(sanitized_file.is_path?).to be_falsey
+      end
+    end
+  end
+
+  describe "with a valid Tempfile" do
+    let(:tempfile) { stub_tempfile("llama.jpg", "image/jpeg") }
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(tempfile) }
+
+    it_should_behave_like "all valid sanitized files"
+
+    it_should_behave_like "all valid sanitized files that are stored on disk"
+
+    it_should_behave_like "all valid sanitized files that are read from an IO object"
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(sanitized_file.is_path?).to be_falsey
+      end
+    end
+
+    describe "#path" do
+      it "should return the path of the tempfile" do
+        expect(sanitized_file.path).not_to be_nil
+        expect(sanitized_file.path).to eq(tempfile.path)
+      end
+    end
+  end
+
+  describe "with a valid StringIO" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(stub_stringio("llama.jpg", "image/jpeg")) }
+
+    it_should_behave_like "all valid sanitized files"
+
+    it_should_behave_like "all valid sanitized files that are read from an IO object"
+
+    describe "#exists?" do
+      it "should be false" do
+        expect(sanitized_file.exists?).to be_falsey
+      end
+    end
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(sanitized_file.is_path?).to be_falsey
+      end
+    end
+
+    describe "#path" do
+      it "should be nil" do
+        expect(sanitized_file.path).to be_nil
+      end
+    end
+
+    describe "#delete" do
+      it "should not raise an error" do
+        expect(running { sanitized_file.delete }).not_to raise_error
+      end
+    end
+
+    describe "#to_file" do
+      it "should be nil" do
+        expect(sanitized_file.to_file).to be_nil
+      end
+    end
+  end
+
+  describe "with a valid File object" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(stub_file("llama.jpg", "image/jpeg")) }
+
+    before do
+      FileUtils.cp(file_path("test.jpg"), file_path("llama.jpg"))
+
+      expect(sanitized_file).not_to be_empty
+    end
+
+    it_should_behave_like "all valid sanitized files"
+
+    it_should_behave_like "all valid sanitized files that are stored on disk"
+
+    it_should_behave_like "all valid sanitized files that are read from an IO object"
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(sanitized_file.is_path?).to be_falsey
+      end
+    end
+
+    describe "#path" do
+      it "should return the path of the file" do
+        expect(sanitized_file.path).not_to be_nil
+        expect(sanitized_file.path).to eq(file_path("llama.jpg"))
+      end
+    end
+  end
+
+  describe "with a valid File object and an empty file" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(stub_file("llama.jpg", "image/jpeg")) }
+
+    before do
+      FileUtils.cp(file_path("test.jpg"), file_path("llama.jpg"))
+      FileUtils.rm file_path("llama.jpg")
+      FileUtils.touch file_path("llama.jpg")
+
+      expect(sanitized_file).not_to be_empty
+    end
+
+    it_should_behave_like "all valid sanitized files that are stored on disk"
+
+    it_should_behave_like "all valid sanitized files that are read from an IO object"
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(sanitized_file.is_path?).to be_falsey
+      end
+    end
+
+    describe "#path" do
+      it "should return the path of the file" do
+        expect(sanitized_file.path).not_to be_nil
+        expect(sanitized_file.path).to eq(file_path("llama.jpg"))
+      end
+    end
+  end
+
+  describe "with a valid path" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(file_path("llama.jpg")) }
+
+    before do
+      FileUtils.cp(file_path("test.jpg"), file_path("llama.jpg"))
+
+      expect(sanitized_file).not_to be_empty
+    end
+
+    it_should_behave_like "all valid sanitized files"
+
+    it_should_behave_like "all valid sanitized files that are stored on disk"
+
+    describe "#is_path?" do
+      it "should be true" do
+        expect(sanitized_file.is_path?).to be_truthy
+      end
+    end
+
+    describe "#path" do
+      it "should return the path of the file" do
+        expect(sanitized_file.path).not_to be_nil
+        expect(sanitized_file.path).to eq(file_path("llama.jpg"))
+      end
+    end
+
+  end
+
+  describe "with a valid Pathname" do
+    let(:sanitized_file) { CarrierWave::SanitizedFile.new(Pathname.new(file_path("llama.jpg"))) }
+
+    before do
+      FileUtils.copy_file(file_path("test.jpg"), file_path("llama.jpg"))
+
+      expect(sanitized_file).not_to be_empty
+    end
+
+    it_should_behave_like "all valid sanitized files"
+
+    it_should_behave_like "all valid sanitized files that are stored on disk"
+
+    describe "#is_path?" do
+      it "should be true" do
+        expect(sanitized_file.is_path?).to be_truthy
+      end
+    end
+
+    describe "#path" do
+      it "should return the path of the file" do
+        expect(sanitized_file.path).not_to be_nil
+        expect(sanitized_file.path).to eq(file_path("llama.jpg"))
+      end
+    end
+
+  end
+
+  describe "that is empty" do
+    let(:empty) { CarrierWave::SanitizedFile.new(nil) }
+
+    describe "#empty?" do
+      it "should be true" do
+        expect(empty).to be_empty
+      end
+    end
+
+    describe "#exists?" do
+      it "should be false" do
+        expect(empty.exists?).to be_falsey
+      end
+    end
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(empty.is_path?).to be_falsey
+      end
+    end
+
+    describe "#size" do
+      it "should be zero" do
+        expect(empty.size).to be_zero
+      end
+    end
+
+    describe "#path" do
+      it "should be nil" do
+        expect(empty.path).to be_nil
+      end
+    end
+
+    describe "#original_filename" do
+      it "should be nil" do
+        expect(empty.original_filename).to be_nil
+      end
+    end
+
+    describe "#filename" do
+      it "should be nil" do
+        expect(empty.filename).to be_nil
+      end
+    end
+
+    describe "#basename" do
+      it "should be nil" do
+        expect(empty.basename).to be_nil
+      end
+    end
+
+    describe "#extension" do
+      it "should be nil" do
+        expect(empty.extension).to be_nil
+      end
+    end
+
+    describe "#delete" do
+      it "should not raise an error" do
+        expect(running { empty.delete }).not_to raise_error
+      end
+    end
+
+    describe "#to_file" do
+      it "should be nil" do
+        expect(empty.to_file).to be_nil
+      end
+    end
+  end
+
+  describe "that is an empty string" do
+    let(:empty) { CarrierWave::SanitizedFile.new("") }
+
+    describe "#empty?" do
+      it "should be true" do
+        expect(empty).to be_empty
+      end
+    end
+
+    describe "#exists?" do
+      it "should be false" do
+        expect(empty.exists?).to be_falsey
+      end
+    end
+
+    describe "#is_path?" do
+      it "should be false" do
+        expect(empty.is_path?).to be_falsey
+      end
+    end
+
+    describe "#size" do
+      it "should be zero" do
+        expect(empty.size).to be_zero
+      end
+    end
+
+    describe "#path" do
+      it "should be nil" do
+        expect(empty.path).to be_nil
+      end
+    end
+
+    describe "#original_filename" do
+      it "should be nil" do
+        expect(empty.original_filename).to be_nil
+      end
+    end
+
+    describe "#filename" do
+      it "should be nil" do
+        expect(empty.filename).to be_nil
+      end
+    end
+
+    describe "#basename" do
+      it "should be nil" do
+        expect(empty.basename).to be_nil
+      end
+    end
+
+    describe "#extension" do
+      it "should be nil" do
+        expect(empty.extension).to be_nil
+      end
+    end
+
+    describe "#delete" do
+      it "should not raise an error" do
+        expect(running { empty.delete }).not_to raise_error
+      end
+    end
+
+    describe "#to_file" do
+      it "should be nil" do
+        expect(empty.to_file).to be_nil
+      end
+    end
+  end
+end