card 1.19.0 → 1.19.1

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

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

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

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

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

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

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

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