card 1.19.3 → 1.19.4

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

@@ -1,133 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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