card 1.19.3 → 1.19.4

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

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-describe CarrierWave::Uploader do
-  subject { lambda { uploader.cache!(test_file) } }
-
-  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
-  let(:uploader) { uploader_class.new }
-  let(:cache_id) { '1369894322-345-1234-2255' }
-  let(:test_file_name) { 'test.jpg' }
-  let(:test_file) { File.open(file_path(test_file_name)) }
-
-  after { FileUtils.rm_rf(public_path) }
-
-  before { allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id) }
-
-  describe '#cache!' do
-    before { allow(uploader).to receive(:extension_blacklist).and_return(extension_blacklist) }
-
-    context "when there are no blacklisted extensions" do
-      let(:extension_blacklist) { nil }
-
-      it "doesn't raise an integrity error" do
-        is_expected.not_to raise_error
-      end
-    end
-
-    context "when there is a blacklist" do
-      context "when the blacklist is an array of values" do
-        context "when the file extension matches a blacklisted extension" do
-          let(:extension_blacklist) { %w(jpg gif png) }
-
-          it "raises an integrity error" do
-            is_expected.to raise_error(CarrierWave::IntegrityError)
-          end
-        end
-
-        context "when the file extension doesn't match a blacklisted extension" do
-          let(:extension_blacklist) { %w(txt doc xls) }
-
-          it "doesn't raise an integrity error" do
-            is_expected.to_not raise_error
-          end
-        end
-
-        context "when the file extension has only the starting part of a blacklisted extension string" do
-          let(:text_file_name) { 'bork.ttxt' }
-          let(:extension_blacklist) { %w(txt) }
-
-          it "doesn't raise an integrity error" do
-            is_expected.to_not raise_error
-          end
-        end
-
-        context "when the file extension has only the ending part of a blacklisted extension string" do
-          let(:text_file_name) { 'bork.txtt' }
-          let(:extension_blacklist) { %w(txt) }
-
-          it "doesn't raise an integrity error" do
-            is_expected.to_not raise_error
-          end
-        end
-
-        context "when the file has a capitalized extension of a blacklisted extension" do
-          let(:text_file_name) { 'case.JPG' }
-          let(:extension_blacklist) { %w(jpg gif png) }
-
-          it "raise an integrity error" do
-            is_expected.to raise_error(CarrierWave::IntegrityError)
-          end
-        end
-
-        context "when the file has an extension which matches a blacklisted capitalized extension" do
-          let(:text_file_name) { 'test.jpg' }
-          let(:extension_blacklist) { %w(JPG GIF PNG) }
-
-          it "raise an integrity error" do
-            is_expected.to raise_error(CarrierWave::IntegrityError)
-          end
-        end
-
-        context "when the file has an extension which matches the blacklisted extension regular expression" do
-          let(:text_file_name) { 'test.jpeg' }
-          let(:extension_blacklist) { [/jpe?g/, 'gif', 'png'] }
-
-          it "raise an integrity error" do
-            is_expected.to raise_error(CarrierWave::IntegrityError)
-          end
-        end
-      end
-
-      context "when the blacklist is a single value" do
-        context "when the file has an extension which is equal the blacklisted extension string" do
-          let(:test_file_name) { 'test.jpeg' }
-          let(:extension_blacklist) { 'jpeg' }
-
-          it "raises an integrity error" do
-            is_expected.to raise_error(CarrierWave::IntegrityError)
-          end
-        end
-
-        context "when the file has a name which matches the blacklisted extension regular expression" do
-          let(:text_file_name) { 'test.jpeg' }
-          let(:extension_blacklist) { /jpe?g/ }
-
-          it "raise an integrity error" do
-            is_expected.to raise_error(CarrierWave::IntegrityError)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-describe CarrierWave::Uploader do
-  before do
-    @uploader_class = Class.new(CarrierWave::Uploader::Base)
-    @uploader = @uploader_class.new
-  end
-
-  after do
-    FileUtils.rm_rf(public_path)
-  end
-
-  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(:extension_whitelist).and_return(nil)
-
-        expect(running {
-          @uploader.cache!(File.open(file_path('test.jpg')))
-        }).not_to raise_error
-      end
-    end
-
-    context "when there is a whitelist" do
-      context "when the whitelist is an array of values" do
-        it "does not raise an integrity error when the file has a whitelisted extension" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(%w(jpg gif png))
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('test.jpg')))
-          }).not_to raise_error
-        end
-
-        it "raises an integrity error if the file has not a whitelisted extension" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(%w(txt doc xls))
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('test.jpg')))
-          }).to raise_error(CarrierWave::IntegrityError)
-        end
-
-        it "raises an integrity error if the file has not a whitelisted extension, using start of string matcher" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(%w(txt))
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('bork.ttxt')))
-          }).to raise_error(CarrierWave::IntegrityError)
-        end
-
-        it "raises an integrity error if the file has not a whitelisted extension, using end of string matcher" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(%w(txt))
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('bork.txtt')))
-          }).to raise_error(CarrierWave::IntegrityError)
-        end
-
-        it "compares extensions in a case insensitive manner when capitalized extension provided" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(%w(jpg gif png))
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('case.JPG')))
-          }).not_to raise_error
-        end
-
-        it "compares extensions in a case insensitive manner when lowercase extension provided" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(%w(JPG GIF PNG))
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('test.jpg')))
-          }).not_to raise_error
-        end
-
-        it "accepts extensions as regular expressions" do
-          allow(@uploader).to receive(:extension_whitelist).and_return([/jpe?g/, 'gif', 'png'])
-
-          expect(running {
-            @uploader.cache!(File.open(file_path('test.jpeg')))
-          }).not_to raise_error
-        end
-      end
-
-      context "when the whitelist 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!(File.open(file_path('test.jpg'))) }.to raise_error(CarrierWave::IntegrityError)
-        end
-
-        it "accepts a single extension regular expression value" do
-          allow(@uploader).to receive(:extension_whitelist).and_return(/jpe?g/)
-
-          expect { @uploader.cache!(File.open(file_path('bork.txt')))}.to raise_error
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe CarrierWave::Uploader do
-  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
-  let(:uploader) { uploader_class.new }
-  let(:cache_id) { '20071201-1234-1234-2255' }
-  let(:test_file) { File.open(file_path('test.jpg')) }
-
-  after { FileUtils.rm_rf(public_path) }
-
-  describe '#cache!' do
-    subject { lambda { uploader.cache!(test_file) } }
-
-    before { allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id) }
-
-    describe "file size range" do
-      before { allow(uploader).to receive(:size_range).and_return(range) }
-
-      context "when not specified" do
-        let(:range) { nil }
-
-        it "doesn't raise an integrity error" do
-          is_expected.not_to raise_error
-        end
-      end
-
-      context "when below the minimum" do
-        let(:range) { 2097152..4194304 }
-
-        it "raises an integrity error" do
-          is_expected.to raise_error(CarrierWave::IntegrityError)
-        end
-      end
-
-      context "when above the maximum" do
-        let(:range) { 0..10 }
-
-        it "raises an integrity error" do
-          is_expected.to raise_error(CarrierWave::IntegrityError)
-        end
-      end
-
-      context "when inside the range" do
-        let(:range) { 0..100 }
-
-        it "doesn't raise an integrity error" do
-          is_expected.not_to raise_error
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +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 '#model' do
-    let(:model) { double('a model object') }
-    let(:uploader) { uploader_class.new(model) }
-
-    it "is remembered from initialization" do
-      expect(uploader.model).to eq(model)
-    end
-  end
-
-  describe '#mounted_as' do
-    let(:model) { double('a model object') }
-    let(:uploader) { uploader_class.new(model, :llama) }
-
-    it "is remembered from initialization" do
-      expect(uploader.mounted_as).to eq(:llama)
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe CarrierWave::Uploader do
-  let(:uploader_class) do
-    Class.new(CarrierWave::Uploader::Base).tap do |uc|
-      uc.configure do |config|
-
-        config.fog_credentials = {
-          :provider               => 'AWS',         # required
-          :aws_access_key_id      => 'XXXX',        # required
-          :aws_secret_access_key  => 'YYYY',        # required
-          :region                 => 'us-east-1'    # optional, defaults to 'us-east-1'
-        }
-
-        config.fog_directory = "defaultbucket"
-      end
-    end
-  end
-
-  let(:uploader) { uploader_class.new }
-
-  let(:uploader_overridden) do
-    uploader_class.tap do |uo|
-      uo.fog_credentials = {
-        :provider               => 'AWS',               # required
-        :aws_access_key_id      => 'ZZZZ',              # required
-        :aws_secret_access_key  => 'AAAA',              # required
-        :region                 => 'us-east-2'          # optional, defaults to 'us-east-1'
-      }
-      uo.fog_public = false
-    end
-  end
-
-  describe 'fog_credentials' do
-    describe 'reflects the standard value if no override done' do
-      it { expect(uploader.fog_credentials).to be_a(Hash) }
-      it { expect(uploader.fog_credentials[:provider]).to be_eql('AWS') }
-      it { expect(uploader.fog_credentials[:aws_access_key_id]).to be_eql('XXXX') }
-      it { expect(uploader.fog_credentials[:aws_secret_access_key]).to be_eql('YYYY') }
-      it { expect(uploader.fog_credentials[:region]).to be_eql('us-east-1') }
-    end
-
-    describe 'reflects the new values in uploader class with override' do
-      it { expect(uploader_overridden.fog_credentials).to be_a(Hash) }
-      it { expect(uploader_overridden.fog_credentials[:provider]).to be_eql('AWS') }
-      it { expect(uploader_overridden.fog_credentials[:aws_access_key_id]).to be_eql('ZZZZ') }
-      it { expect(uploader_overridden.fog_credentials[:aws_secret_access_key]).to be_eql('AAAA') }
-      it { expect(uploader_overridden.fog_credentials[:region]).to be_eql('us-east-2') }
-    end
-  end
-
-  describe 'fog_directory' do
-    it 'reflects the standard value if no override done' do
-      expect(uploader.fog_directory).to be_eql('defaultbucket')
-    end
-
-    it 'reflects the standard value in overridden object because property is not overridden' do
-      expect(uploader_overridden.fog_directory).to be_eql('defaultbucket')
-    end
-  end
-
-  describe 'fog_public' do
-    it 'reflects the standard value if no override done' do
-      expect(uploader.fog_public).to be_eql(true)
-    end
-
-    it 'reflects the standard value in overridden object because property is not overridden' do
-      expect(uploader_overridden.fog_public).to be_eql(false)
-    end
-  end
-end

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

@@ -1,18 +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 '#root' do
-    describe "default behavior" do
-      before { CarrierWave.root = public_path }
-
-      it "defaults to the current value of CarrierWave.root" do
-        expect(uploader.root).to eq(public_path)
-      end
-    end
-  end
-end

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

@@ -1,159 +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 '.process' do
-    context "when a symbol is given" do
-      before { uploader_class.process(process_param) }
-      after { uploader.process! }
-
-      let(:process_param) { :sepiatone }
-
-      it "adds a single processor" do
-        expect(uploader).to receive(:sepiatone)
-      end
-    end
-
-    context "when an array of symbols is given" do
-      before { uploader_class.process(*process_param) }
-      after { uploader.process! }
-
-      let(:process_param) { [:sepiatone, :desaturate, :invert] }
-
-      it "adds multiple processors" do
-        expect(uploader).to receive(:sepiatone)
-        expect(uploader).to receive(:desaturate)
-        expect(uploader).to receive(:invert)
-      end
-    end
-
-    it "adds a single processor with an argument when a hash is given" do
-      uploader_class.process :format => 'png'
-      expect(uploader).to receive(:format).with('png')
-      uploader.process!
-    end
-
-    it "adds a single processor with several argument when a hash is given" do
-      uploader_class.process :resize => [200, 300]
-      expect(uploader).to receive(:resize).with(200, 300)
-      uploader.process!
-    end
-
-    it "adds multiple processors when an hash with multiple keys is given" do
-      uploader_class.process :resize => [200, 300], :format => 'png'
-      expect(uploader).to receive(:resize).with(200, 300)
-      expect(uploader).to receive(:format).with('png')
-      uploader.process!
-    end
-
-    it "calls the processor if the condition method returns true" do
-      uploader_class.process :resize => [200, 300], :if => :true?
-      uploader_class.process :fancy, :if => :true?
-      expect(uploader).to receive(:true?).with("test.jpg").twice.and_return(true)
-      expect(uploader).to receive(:resize).with(200, 300)
-      expect(uploader).to receive(:fancy)
-      uploader.process!("test.jpg")
-    end
-
-    it "doesn't call the processor if the condition method returns false" do
-      uploader_class.process :resize => [200, 300], :if => :false?
-      uploader_class.process :fancy, :if => :false?
-      expect(uploader).to receive(:false?).with("test.jpg").twice.and_return(false)
-      expect(uploader).not_to receive(:resize)
-      expect(uploader).not_to receive(:fancy)
-      uploader.process!("test.jpg")
-    end
-
-    it "calls the processor if the condition block returns true" do
-      uploader_class.process :resize => [200, 300], :if => lambda{|record, args| record.true?(args[:file])}
-      uploader_class.process :fancy, :if => :true?
-      expect(uploader).to receive(:true?).with("test.jpg").twice.and_return(true)
-      expect(uploader).to receive(:resize).with(200, 300)
-      expect(uploader).to receive(:fancy)
-      uploader.process!("test.jpg")
-    end
-
-    it "doesn't call the processor if the condition block returns false" do
-      uploader_class.process :resize => [200, 300], :if => lambda{|record, args| record.false?(args[:file])}
-      uploader_class.process :fancy, :if => :false?
-      expect(uploader).to receive(:false?).with("test.jpg").twice.and_return(false)
-      expect(uploader).not_to receive(:resize)
-      expect(uploader).not_to receive(:fancy)
-      uploader.process!("test.jpg")
-    end
-
-    context "when using RMagick", :rmagick => true do
-      before do
-        def uploader.cover
-          manipulate! { |frame, index| frame if index.zero? }
-        end
-
-        uploader_class.send :include, CarrierWave::RMagick
-      end
-
-      after { uploader.instance_eval { undef cover } }
-
-      context "with a multi-page PDF" do
-        before { uploader.cache! File.open(file_path("multi_page.pdf")) }
-
-        it "successfully processes" do
-          uploader_class.process :convert => 'jpg'
-          uploader.process!
-        end
-
-        it "supports page specific transformations" do
-          uploader_class.process :cover
-          uploader.process!
-        end
-      end
-
-      context "with a simple image" do
-        before { uploader.cache! File.open(file_path("portrait.jpg")) }
-
-        it "allows page specific transformations" do
-          uploader_class.process :cover
-          uploader.process!
-        end
-      end
-    end
-
-    context "with 'enable_processing' set to false" do
-      before { uploader_class.enable_processing = false }
-
-      it "doesn't do any processing" do
-        uploader_class.process :sepiatone, :desaturate, :invert
-        expect(uploader).not_to receive(:sepiatone)
-        expect(uploader).not_to receive(:desaturate)
-        expect(uploader).not_to receive(:invert)
-        uploader.process!
-      end
-    end
-  end
-
-  describe '#cache!' do
-    before do
-      allow(CarrierWave).to receive(:generate_cache_id).and_return('1369894322-345-1234-2255')
-    end
-
-    it "triggers a process!" do
-      expect(uploader).to receive(:process!)
-      uploader.cache!(File.open(file_path('test.jpg')))
-    end
-  end
-
-  describe '#recreate_versions!' do
-    before do
-      allow(CarrierWave).to receive(:generate_cache_id).and_return('1369894322-345-1234-2255')
-    end
-
-    it "triggers a process!" do
-      uploader.store!(File.open(file_path('test.jpg')))
-      expect(uploader).to receive(:process!)
-      uploader.recreate_versions!
-    end
-  end
-end