card 1.19.0 → 1.19.1

data/vendor/carrierwave/spec/uploader/configuration_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'carrierwave/storage/fog'
+
+describe CarrierWave do
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+
+  describe '.configure' do
+    before do
+      CarrierWave::Uploader::Base.add_config :test_config
+      CarrierWave.configure { |config| config.test_config = "foo" }
+    end
+
+    it "proxies to Uploader configuration" do
+      expect(CarrierWave::Uploader::Base.test_config).to eq('foo')
+    end
+  end
+end
+
+describe CarrierWave::Uploader::Base do
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+
+  describe '.configure' do
+    before do
+      uploader_class.tap do |uc|
+        uc.add_config :foo_bar
+        uc.configure { |config| config.foo_bar = "monkey" }
+      end
+    end
+
+    it "sets a configuration parameter" do
+      expect(uploader_class.foo_bar).to eq('monkey')
+    end
+  end
+
+  describe ".storage" do
+    let(:storage) { double('some kind of storage').as_null_object }
+
+    it "sets the storage if an argument is given" do
+      uploader_class.storage(storage)
+
+      expect(uploader_class.storage).to storage
+    end
+
+    it "defaults to file" do
+      expect(uploader_class.storage).to eq(CarrierWave::Storage::File)
+    end
+
+    it "sets the storage from the configured shortcuts if a symbol is given" do
+      uploader_class.storage :file
+      expect(uploader_class.storage).to eq(CarrierWave::Storage::File)
+    end
+
+    context "when inherited" do
+      before { uploader_class.storage(:fog) }
+      let(:subclass) { Class.new(uploader_class) }
+
+      it "remembers the storage" do
+        expect(subclass.storage).to eq(CarrierWave::Storage::Fog)
+      end
+
+      it "'s changeable" do
+        expect(subclass.storage).to eq(CarrierWave::Storage::Fog)
+
+        subclass.storage(:file)
+        expect(subclass.storage).to eq(CarrierWave::Storage::File)
+      end
+    end
+
+    it "raises UnknownStorageError when set unknown storage" do
+      expect{ uploader_class.storage :unknown }.to raise_error(CarrierWave::UnknownStorageError, "Unknown storage: unknown")
+    end
+  end
+
+  describe '.add_config' do
+    before do
+      uploader_class.add_config :foo_bar
+      uploader_class.foo_bar = 'foo'
+    end
+
+    it "adds a class level accessor" do
+      expect(uploader_class.foo_bar).to eq('foo')
+    end
+
+    it "adds an instance level accessor" do
+      expect(uploader_class.new.foo_bar).to eq('foo')
+    end
+
+    it "adds a convenient in-class setter" do
+      expect(uploader_class.foo_bar).to eq('foo')
+    end
+
+    ['foo', :foo, 45, ['foo', :bar]].each do |val|
+      it "'s inheritable for a #{val.class}" do
+        uploader_class.add_config :foo_bar
+        child_class = Class.new(uploader_class)
+
+        uploader_class.foo_bar = val
+        expect(uploader_class.foo_bar).to eq(val)
+        expect(child_class.foo_bar).to eq(val)
+
+        child_class.foo_bar = "bar"
+        expect(child_class.foo_bar).to eq("bar")
+
+        expect(uploader_class.foo_bar).to eq(val)
+      end
+    end
+
+    describe "assigning a proc to a config attribute" do
+      before do
+        uploader_class.tap do |uc|
+          uc.add_config :hoobatz
+          uc.hoobatz = this_proc
+        end
+      end
+
+      context "when the proc accepts no arguments" do
+        let(:this_proc) { proc { "a return value" } }
+
+        it "calls the proc without arguments" do
+          expect(uploader_class.new.hoobatz).to eq("a return value")
+        end
+      end
+
+      context "when the proc accepts one argument" do
+        let(:this_proc) { proc { |arg1| expect(arg1).to be_an_instance_of(uploader_class) } }
+
+        it "calls the proc with an instance of the uploader" do
+          uploader_class.new.hoobatz
+        end
+      end
+    end
+  end
+end

data/vendor/carrierwave/spec/uploader/content_type_blacklist_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe CarrierWave::Uploader do
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+  let(:uploader) { uploader_class.new }
+  let(:ruby_file) { File.open(file_path('ruby.gif')) }
+  let(:bork_file) { File.open(file_path('bork.txt')) }
+  let(:test_file) { File.open(file_path('test.jpeg')) }
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe '#cache!' do
+    before do
+      allow(CarrierWave).to receive(:generate_cache_id).and_return('1369894322-345-1234-2255')
+    end
+
+    context "when there is no blacklist" do
+      it "does not raise an integrity error" do
+        allow(uploader).to receive(:content_type_blacklist).and_return(nil)
+
+        expect { uploader.cache!(ruby_file) }.not_to raise_error
+      end
+    end
+
+    context "when there is a blacklist" do
+      context "when the blacklist is an array of values" do
+        it "does not raise an integrity error when the file has not a blacklisted content type" do
+          allow(uploader).to receive(:content_type_blacklist).and_return(['image/gif'])
+
+          expect { uploader.cache!(bork_file) }.not_to raise_error
+        end
+
+        it "raises an integrity error if the file has a blacklisted content type" do
+          allow(uploader).to receive(:content_type_blacklist).and_return(['image/gif'])
+
+          expect { uploader.cache!(ruby_file) }.to raise_error(CarrierWave::IntegrityError)
+        end
+
+        it "accepts content types as regular expressions" do
+          allow(uploader).to receive(:content_type_blacklist).and_return([/image\//])
+
+          expect { uploader.cache!(ruby_file) }.to raise_error(CarrierWave::IntegrityError)
+        end
+      end
+
+      context "when the blacklist is a single value" do
+        it "accepts a single extension string value" do
+          allow(uploader).to receive(:extension_whitelist).and_return('jpeg')
+
+          expect { uploader.cache!(test_file) }.not_to raise_error
+        end
+
+        it "accepts a single extension regular expression value" do
+          allow(uploader).to receive(:extension_whitelist).and_return(/jpe?g/)
+
+          expect { uploader.cache!(test_file) }.not_to raise_error
+        end
+      end
+    end
+  end
+end

data/vendor/carrierwave/spec/uploader/content_type_whitelist_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe CarrierWave::Uploader do
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+  let(:uploader) { uploader_class.new }
+  let(:ruby_file) { File.open(file_path('ruby.gif')) }
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe '#cache!' do
+    before do
+      allow(CarrierWave).to receive(:generate_cache_id).and_return('1369894322-345-1234-2255')
+    end
+
+    context "when there is no whitelist" do
+      it "does not raise an integrity error" do
+        allow(uploader).to receive(:content_type_whitelist).and_return(nil)
+
+        expect { uploader.cache!(ruby_file) }.not_to raise_error
+      end
+    end
+
+    context "when there is a whitelist" do
+      context "when the whitelist is an array of values" do
+        let(:bork_file) { File.open(file_path('bork.txt')) }
+
+        it "does not raise an integrity error when the file has a whitelisted content type" do
+          allow(uploader).to receive(:content_type_whitelist).and_return(['image/gif'])
+
+          expect { uploader.cache!(ruby_file) }.not_to raise_error
+        end
+
+        it "raises an integrity error the file has not a whitelisted content type" do
+          allow(uploader).to receive(:content_type_whitelist).and_return(['image/gif'])
+
+          expect { uploader.cache!(bork_file) }.to raise_error(CarrierWave::IntegrityError)
+        end
+
+        it "accepts content types as regular expressions" do
+          allow(uploader).to receive(:content_type_whitelist).and_return([/image\//])
+
+          expect { uploader.cache!(bork_file) }.to raise_error(CarrierWave::IntegrityError)
+        end
+      end
+
+      context "when the whitelist is a single value" do
+        let(:test_file) { File.open(file_path('test.jpeg')) }
+
+        it "accepts a single extension string value" do
+          allow(uploader).to receive(:extension_whitelist).and_return('jpeg')
+
+          expect { uploader.cache!(test_file) }.not_to raise_error
+        end
+
+        it "accepts a single extension regular expression value" do
+          allow(uploader).to receive(:extension_whitelist).and_return(/jpe?g/)
+
+          expect { uploader.cache!(test_file) }.not_to raise_error
+        end
+      end
+    end
+  end
+end

data/vendor/carrierwave/spec/uploader/default_url_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe CarrierWave::Uploader do
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+  let(:uploader) { uploader_class.new }
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe 'with a default url' do
+    before do
+      uploader_class.class_eval do
+        version :thumb
+        def default_url
+          ['http://someurl.example.com', version_name].compact.join('/')
+        end
+      end
+    end
+
+    describe '#blank?' do
+      subject { uploader }
+
+      it "is blank by default" do
+        is_expected.to be_blank
+      end
+    end
+
+    describe '#current_path' do
+      subject { uploader.current_path }
+
+      it { is_expected.to be_nil }
+    end
+
+    describe '#url' do
+      let(:url_example) { "http://someurl.example.com" }
+
+      it "returns the default url" do
+        expect(uploader.url).to eq(url_example)
+      end
+
+      it "returns the default url with version when given" do
+        expect(uploader.url(:thumb)).to eq("#{url_example}/thumb")
+      end
+    end
+
+    describe '#cache!' do
+      let(:cache_id) { '1369894322-345-1234-2255' }
+      let(:file_name) { 'test.jpg' }
+
+      subject { uploader }
+
+      before do
+        allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id)
+        uploader.cache!(File.open(file_path(file_name)))
+      end
+
+      it "caches a file" do
+        expect(uploader.file).to be_an_instance_of(CarrierWave::SanitizedFile)
+      end
+
+      it "is cached" do
+        expect(uploader).to be_cached
+      end
+
+      it "isn't blank" do
+        expect(uploader).not_to be_blank
+      end
+
+      it "sets the current_path" do
+        expect(uploader.current_path).to eq(public_path("uploads/tmp/#{cache_id}/#{file_name}"))
+      end
+
+      it "sets the url" do
+        expect(uploader.url).to eq ("/uploads/tmp/#{cache_id}/#{file_name}")
+      end
+    end
+  end
+end

data/vendor/carrierwave/spec/uploader/download_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe CarrierWave::Uploader::Download do
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+  let(:uploader) { uploader_class.new }
+  let(:cache_id) { '1369894322-345-1234-2255' }
+  let(:base_url) { "http://www.example.com" }
+  let(:url) { base_url + "/test.jpg" }
+  let(:test_file) { File.read(file_path(test_file_name)) }
+  let(:test_file_name) { "test.jpg" }
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe '#download!' do
+    before do
+      allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id)
+
+      stub_request(:get, "www.example.com/#{test_file_name}")
+        .to_return(body: test_file)
+
+      stub_request(:get, "www.example.com/test-with-no-extension/test").
+        to_return(body: test_file, headers: { "Content-Type" => "image/jpeg" })
+
+      stub_request(:get, "www.example.com/test%20with%20spaces/#{test_file_name}").
+        to_return(body: test_file)
+
+      stub_request(:get, "www.example.com/content-disposition").
+        to_return(body: test_file, headers: { "Content-Disposition" => 'filename="another_test.jpg"' })
+
+      stub_request(:get, "www.redirect.com").
+        to_return(status: 301, body: "Redirecting", headers: { "Location" => url })
+
+      stub_request(:get, "www.example.com/missing.jpg").
+        to_return(status: 404)
+    end
+
+    context "when a file was downloaded" do
+      before do
+        uploader.download!(url)
+      end
+
+      it "caches a file" do
+        expect(uploader.file).to be_an_instance_of(CarrierWave::SanitizedFile)
+      end
+
+      it "'s cached" do
+        expect(uploader).to be_cached
+      end
+
+      it "stores the cache name" do
+        expect(uploader.cache_name).to eq("#{cache_id}/#{test_file_name}")
+      end
+
+      it "sets the filename to the file's sanitized filename" do
+        expect(uploader.filename).to eq("#{test_file_name}")
+      end
+
+      it "moves it to the tmp dir" do
+        expect(uploader.file.path).to eq(public_path("uploads/tmp/#{cache_id}/#{test_file_name}"))
+        expect(uploader.file.exists?).to be_truthy
+      end
+
+      it "sets the url" do
+        expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
+      end
+    end
+
+    context "with directory permissions set" do
+      let(:permissions) { 0777 }
+
+      it "sets permissions" do
+        uploader_class.permissions = permissions
+        uploader.download!(url)
+
+        expect(uploader).to have_permissions(permissions)
+      end
+
+      it "sets directory permissions" do
+        uploader_class.directory_permissions = permissions
+        uploader.download!(url)
+
+        expect(uploader).to have_directory_permissions(permissions)
+      end
+    end
+
+    it "raises an error when trying to download a local file" do
+      expect { uploader.download!('/etc/passwd') }.to raise_error(CarrierWave::DownloadError)
+    end
+
+    it "raises an error when trying to download a missing file" do
+      expect{ uploader.download!("#{base_url}/missing.jpg") }.to raise_error(CarrierWave::DownloadError)
+    end
+
+    it "accepts spaces in the url" do
+      uploader.download!(url)
+      expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
+    end
+
+    it "follows redirects" do
+      uploader.download!('http://www.redirect.com/')
+      expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
+    end
+
+    it "reads content-disposition headers" do
+      uploader.download!("#{base_url}/content-disposition")
+      expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/another_#{test_file_name}")
+    end
+
+    it 'sets file extension based on content-type if missing' do
+      uploader.download!("#{base_url}/test-with-no-extension/test")
+
+      expect(uploader.url).to match %r{/uploads/tmp/#{cache_id}/test\.jp(e|e?g)$}
+    end
+
+    it "doesn't obscure original exception message" do
+      expect { uploader.download!("#{base_url}/missing.jpg") }.to raise_error(CarrierWave::DownloadError, /could not download file: 404/)
+    end
+
+    describe '#download! with an extension_whitelist' do
+      before do
+        uploader_class.class_eval do
+          def extension_whitelist
+            %w(txt)
+          end
+        end
+      end
+
+      it "follows redirects but still respect the extension_whitelist" do
+        expect { uploader.download!('http://www.redirect.com/') }.to raise_error(CarrierWave::IntegrityError)
+      end
+
+      it "reads content-disposition header but still respect the extension_whitelist" do
+        expect { uploader.download!("#{base_url}/content-disposition") }.to raise_error(CarrierWave::IntegrityError)
+      end
+    end
+
+    describe '#download! with an extension_blacklist' do
+      before do
+        uploader_class.class_eval do
+          def extension_blacklist
+            %w(jpg)
+          end
+        end
+      end
+
+      it "follows redirects but still respect the extension_blacklist" do
+        expect { uploader.download!('http://www.redirect.com/') }.to raise_error(CarrierWave::IntegrityError)
+      end
+
+      it "reads content-disposition header but still respect the extension_blacklist" do
+        expect { uploader.download!("#{base_url}/content-disposition") }.to raise_error(CarrierWave::IntegrityError)
+      end
+    end
+  end
+
+  describe '#download! with an overridden process_uri method' do
+    before do
+      uploader_class.class_eval do
+        def process_uri(uri)
+          raise CarrierWave::DownloadError
+        end
+      end
+    end
+
+    it "allows overriding the process_uri method" do
+      expect { uploader.download!(url) }.to raise_error(CarrierWave::DownloadError)
+    end
+  end
+
+  describe '#process_uri' do
+    it "parses but not escape already escaped uris" do
+      uri = 'http://example.com/%5B.jpg'
+      processed = uploader.process_uri(uri)
+      expect(processed.class).to eq(URI::HTTP)
+      expect(processed.to_s).to eq(uri)
+    end
+
+    it "parses but not escape uris with query-string-only characters not needing escaping" do
+      uri = 'http://example.com/?foo[]=bar'
+      processed = uploader.process_uri(uri)
+      expect(processed.class).to eq(URI::HTTP)
+      expect(processed.to_s).to eq(uri)
+    end
+
+    it "escapes and parse unescaped uris" do
+      uri = 'http://example.com/ %[].jpg'
+      processed = uploader.process_uri(uri)
+      expect(processed.class).to eq(URI::HTTP)
+      expect(processed.to_s).to eq('http://example.com/%20%25%5B%5D.jpg')
+    end
+
+    it "escapes and parse brackets in uri paths without harming the query string" do
+      uri = 'http://example.com/].jpg?test[]'
+      processed = uploader.process_uri(uri)
+      expect(processed.class).to eq(URI::HTTP)
+      expect(processed.to_s).to eq('http://example.com/%5D.jpg?test[]')
+    end
+
+    it "throws an exception on bad uris" do
+      uri = '~http:'
+      expect { uploader.process_uri(uri) }.to raise_error(CarrierWave::DownloadError)
+    end
+  end
+end