card 1.19.0 → 1.19.1

data/vendor/carrierwave/spec/spec_helper.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'pry'
+require 'tempfile'
+require 'time'
+require 'logger'
+
+require 'carrierwave'
+require 'timecop'
+require 'open-uri'
+require "webmock/rspec"
+require 'mini_magick'
+
+I18n.enforce_available_locales = false
+
+CARRIERWAVE_DIRECTORY = "carrierwave#{Time.now.to_i}" unless defined?(CARRIERWAVE_DIRECTORY)
+
+alias :running :lambda
+
+def file_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', *paths))
+end
+
+def public_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'public', *paths))
+end
+
+def tmp_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'tmp', *paths))
+end
+
+CarrierWave.root = public_path
+I18n.load_path << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "carrierwave", "locale", 'en.yml'))
+
+module CarrierWave
+  module Test
+    module MockStorage
+      def mock_storage(kind)
+        storage = double("storage for #{kind} uploader")
+        allow(storage).to receive(:setup!)
+        storage
+      end
+    end
+
+    module MockFiles
+      def stub_tempfile(filename, mime_type=nil, fake_name=nil)
+        raise "#{path} file does not exist" unless File.exist?(file_path(filename))
+
+        tempfile = Tempfile.new(filename)
+        FileUtils.copy_file(file_path(filename), tempfile.path)
+        allow(tempfile).to receive_messages(:original_filename => fake_name || filename,
+                      :content_type => mime_type)
+        tempfile
+      end
+
+      alias_method :stub_merb_tempfile, :stub_tempfile
+
+      def stub_stringio(filename, mime_type=nil, fake_name=nil)
+        file = IO.read( file_path( filename ) ) if filename
+        stringio = StringIO.new(file)
+        allow(stringio).to receive_messages(:local_path => "",
+                      :original_filename => filename || fake_name,
+                      :content_type => mime_type)
+        stringio
+      end
+
+      def stub_file(filename, mime_type=nil, fake_name=nil)
+        File.open(file_path(filename))
+      end
+    end
+
+    module I18nHelpers
+      def change_locale_and_store_translations(locale, translations, &block)
+        current_locale = I18n.locale
+        begin
+          I18n.backend.store_translations locale, translations
+          I18n.locale = locale
+          yield
+        ensure
+          I18n.reload!
+          I18n.locale = current_locale
+        end
+      end
+    end
+
+    module ManipulationHelpers
+      def color_of_pixel(path, x, y)
+        image = ::MiniMagick::Image.open(path)
+        color = image.run_command("convert", "#{image.path}[1x1+#{x}+#{y}]", "-depth", "8", "txt:").split("\n")[1]
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CarrierWave::Test::Matchers
+  config.include CarrierWave::Test::MockFiles
+  config.include CarrierWave::Test::MockStorage
+  config.include CarrierWave::Test::I18nHelpers
+  config.include CarrierWave::Test::ManipulationHelpers
+  if RUBY_ENGINE == 'jruby'
+    config.filter_run_excluding :rmagick => true
+  end
+end

data/vendor/carrierwave/spec/storage/file_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'support/file_utils_helper'
+require 'tempfile'
+
+describe CarrierWave::Storage::File do
+  include FileUtilsHelper
+
+  subject(:storage) { described_class.new(uploader) }
+
+  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
+  let(:tempfile) { Tempfile.new("foo") }
+  let(:sanitized_temp_file) { CarrierWave::SanitizedFile.new(tempfile) }
+  let(:uploader) { uploader_class.new }
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe '#delete_dir!' do
+    let(:file) { File.open(file_path("test.jpg")) }
+
+    context "when the directory is not empty" do
+      let(:cache_id_dir) { File.dirname(cache_path) }
+      let(:cache_path) { File.expand_path(File.join(uploader.cache_dir, uploader.cache_name), uploader.root) }
+      let(:existing_file) { File.join(cache_id_dir, "exsting_file.txt") }
+
+      before do
+        uploader.cache!(file)
+        File.open(existing_file, "wb"){|f| f << "I exist"}
+        uploader.store!
+      end
+
+      it "doesn't delete the old cache_id" do
+        expect(File).to be_directory(cache_id_dir)
+      end
+
+      it "doesn't delete other existing files in old cache_id dir" do
+        expect(File).to exist existing_file
+      end
+    end
+  end
+
+  describe '#cache!' do
+    context "when FileUtils.mkdir_p raises Errno::EMLINK" do
+      before { fake_failed_mkdir_p }
+      after { storage.cache!(sanitized_temp_file) }
+
+      it { is_expected.to receive(:clean_cache!).with(600) }
+    end
+  end
+
+  describe '#clean_cache!' do
+    let(:five_days_ago_int) { 1369894322 }
+    let(:three_days_ago_int) { 1370067122 }
+    let(:yesterday_int) { 1370239922 }
+    let(:cache_dir) { File.expand_path(uploader_class.cache_dir, CarrierWave.root) }
+
+    before do
+      FileUtils.mkdir_p File.expand_path("#{five_days_ago_int}-234-2213", cache_dir)
+      FileUtils.mkdir_p File.expand_path("#{three_days_ago_int}-234-2213", cache_dir)
+      FileUtils.mkdir_p File.expand_path("#{yesterday_int}-234-2213", cache_dir)
+    end
+
+    after { FileUtils.rm_rf(cache_dir) }
+
+    it "clears all files older than, by default, 24 hours in the default cache directory" do
+      Timecop.freeze(Time.at(1370261522)) { uploader_class.clean_cached_files! }
+
+      expect(Dir.glob("#{cache_dir}/*").size).to eq(1)
+    end
+
+    it "allows to set since how many seconds delete the cached files" do
+      Timecop.freeze(Time.at(1370261522)) { uploader_class.clean_cached_files!(60*60*24*4) }
+
+      expect(Dir.glob("#{cache_dir}/*").size).to eq(2)
+    end
+
+    it "'s aliased on the CarrierWave module" do
+      Timecop.freeze(Time.at(1370261522)) { CarrierWave.clean_cached_files! }
+
+      expect(Dir.glob("#{cache_dir}/*").size).to eq(1)
+    end
+  end
+end

data/vendor/carrierwave/spec/storage/fog_credentials.rb

@@ -0,0 +1,46 @@
+unless defined?(FOG_CREDENTIALS)
+
+  credentials = []
+
+  if Fog.mocking?
+    # Local and Rackspace don't have fog double support yet
+    mappings = {
+      'AWS'       => [:aws_access_key_id, :aws_secret_access_key],
+      'Google'    => [:google_storage_access_key_id, :google_storage_secret_access_key],
+      # 'Local'     => [:local_root],
+      # 'Rackspace' => [:rackspace_api_key, :rackspace_username]
+    }
+
+    mappings.each do |provider, keys|
+      data = {:provider => provider}
+      keys.each do |key|
+        data[key] = key.to_s
+      end
+      credentials << data
+    end
+
+    FOG_CREDENTIALS = credentials
+  else
+    Fog.credential = :carrierwave
+
+    mappings = {
+      'AWS'       => [:aws_access_key_id, :aws_secret_access_key],
+      'Google'    => [:google_storage_access_key_id, :google_storage_secret_access_key],
+      'Local'     => [:local_root],
+      'Rackspace' => [:rackspace_api_key, :rackspace_username]
+    }
+
+    mappings.each do |provider, keys|
+      unless (creds = Fog.credentials.reject {|key, value| ![*keys].include?(key)}).empty?
+        data = {:provider => provider}
+        keys.each do |key|
+          data[key] = creds[key]
+        end
+        credentials << data
+      end
+    end
+
+    FOG_CREDENTIALS = credentials
+  end
+
+end

data/vendor/carrierwave/spec/storage/fog_helper.rb

@@ -0,0 +1,428 @@
+def fog_tests(fog_credentials)
+  describe CarrierWave::Storage::Fog do
+    shared_examples_for "#{fog_credentials[:provider]} storage" do
+
+      before do
+        CarrierWave.configure do |config|
+          config.reset_config
+          config.fog_attributes = {}
+          config.fog_credentials = fog_credentials
+          config.fog_directory = CARRIERWAVE_DIRECTORY
+          config.fog_public = true
+          config.fog_use_ssl_for_aws = true
+          config.cache_storage = :fog
+        end
+
+        eval <<-RUBY
+class FogSpec#{fog_credentials[:provider]}Uploader < CarrierWave::Uploader::Base
+storage :fog
+end
+        RUBY
+
+        @provider = fog_credentials[:provider]
+
+        # @uploader = FogSpecUploader.new
+        @uploader = eval("FogSpec#{@provider}Uploader")
+        allow(@uploader).to receive(:store_path).and_return('uploads/test.jpg')
+
+        @storage = CarrierWave::Storage::Fog.new(@uploader)
+        @directory = @storage.connection.directories.get(CARRIERWAVE_DIRECTORY) || @storage.connection.directories.create(:key => CARRIERWAVE_DIRECTORY, :public => true)
+      end
+
+      after do
+        CarrierWave.configure do |config|
+          config.reset_config
+        end
+      end
+
+      describe '#cache_stored_file!' do
+        it "should cache_stored_file! after store!" do
+          uploader = @uploader.new
+          uploader.store!(file)
+          expect { uploader.cache_stored_file! }.not_to raise_error
+        end
+      end
+
+      describe '#store!' do
+
+        let(:store_path) { 'uploads/test+.jpg' }
+
+        before do
+          allow(@uploader).to receive(:store_path).and_return(store_path)
+          @fog_file = @storage.store!(file)
+        end
+
+        it "should upload the file" do
+          # reading the file after upload should return the body, not a closed tempfile
+          expect(@fog_file.read).to eq('this is stuff')
+          # make sure it actually uploaded to the service, too
+          expect(@directory.files.get(store_path).body).to eq('this is stuff')
+        end
+
+        it "should have a path" do
+          expect(@fog_file.path).to eq(store_path)
+        end
+
+        it "should have a content_type" do
+          expect(@fog_file.content_type).to eq('image/jpeg')
+          expect(@directory.files.get(store_path).content_type).to eq('image/jpeg')
+        end
+
+        it "should have an extension" do
+          expect(@fog_file.extension).to eq("jpg")
+        end
+
+        context "without asset_host" do
+          it "should have a public_url" do
+            unless fog_credentials[:provider] == 'Local'
+              expect(@fog_file.public_url).not_to be_nil
+            end
+          end
+
+          it "should have a url" do
+            unless fog_credentials[:provider] == 'Local'
+              expect(@fog_file.url).not_to be_nil
+            end
+          end
+
+          it "should use a subdomain URL for AWS if the directory is a valid subdomain" do
+            if @provider == 'AWS'
+              allow(@uploader).to receive(:fog_directory).and_return('assets.site.com')
+              expect(@fog_file.public_url).to include('https://assets.site.com.s3.amazonaws.com')
+            end
+          end
+
+          it "should not use a subdomain URL for AWS if the directory is not a valid subdomain" do
+            if @provider == 'AWS'
+              allow(@uploader).to receive(:fog_directory).and_return('SiteAssets')
+              expect(@fog_file.public_url).to include('https://s3.amazonaws.com/SiteAssets')
+            end
+          end
+
+          it "should use https as a default protocol" do
+            if @provider == 'AWS'
+              expect(@fog_file.public_url).to start_with 'https://'
+            end
+          end
+
+          it "should use https as a default protocol" do
+            if @provider == 'AWS'
+              allow(@uploader).to receive(:fog_use_ssl_for_aws).and_return(false)
+              expect(@fog_file.public_url).to start_with 'http://'
+            end
+          end
+        end
+
+        context "with asset_host" do
+          before { allow(@uploader).to receive(:asset_host).and_return(asset_host) }
+
+          context "when a asset_host is a proc" do
+
+            let(:asset_host) { proc { "http://foo.bar" } }
+
+            describe "args passed to proc" do
+              let(:asset_host) { proc { |storage| expect(storage).to be_instance_of ::CarrierWave::Storage::Fog::File } }
+
+              it "should be the uploader" do
+                @fog_file.public_url
+              end
+            end
+
+            it "should have a asset_host rooted public_url" do
+              expect(@fog_file.public_url).to eq('http://foo.bar/uploads/test%2B.jpg')
+            end
+
+            it "should have a asset_host rooted url" do
+              expect(@fog_file.url).to eq('http://foo.bar/uploads/test%2B.jpg')
+            end
+
+            it "should always have the same asset_host rooted url" do
+              expect(@fog_file.url).to eq('http://foo.bar/uploads/test%2B.jpg')
+              expect(@fog_file.url).to eq('http://foo.bar/uploads/test%2B.jpg')
+            end
+
+            it 'should retrieve file name' do
+              expect(@fog_file.filename).to eq('test+.jpg')
+            end
+          end
+
+          context "when a string" do
+            let(:asset_host) { "http://foo.bar" }
+
+            it "should have a asset_host rooted public_url" do
+              expect(@fog_file.public_url).to eq('http://foo.bar/uploads/test%2B.jpg')
+            end
+
+            it "should have a asset_host rooted url" do
+              expect(@fog_file.url).to eq('http://foo.bar/uploads/test%2B.jpg')
+            end
+
+            it "should always have the same asset_host rooted url" do
+              expect(@fog_file.url).to eq('http://foo.bar/uploads/test%2B.jpg')
+              expect(@fog_file.url).to eq('http://foo.bar/uploads/test%2B.jpg')
+            end
+          end
+
+        end
+
+        context "without extension" do
+
+          let(:store_path) { 'uploads/test' }
+
+          it "should have no extension" do
+            expect(@fog_file.extension).to be_nil
+          end
+
+        end
+
+        it "should return filesize" do
+          expect(@fog_file.size).to eq(13)
+        end
+
+        it "should be deletable" do
+          @fog_file.delete
+          expect(@directory.files.head(store_path)).to eq(nil)
+        end
+
+        context "when the file has been deleted" do
+          before { @fog_file.delete }
+
+          it "should not error getting the file size" do
+            expect { @fog_file.size }.not_to raise_error
+          end
+
+          it "should not error getting the content type" do
+            expect { @fog_file.content_type }.not_to raise_error
+          end
+        end
+      end
+
+      describe '#retrieve!' do
+        before do
+          @directory.files.create(:key => 'uploads/test.jpg', :body => 'A test, 1234', :public => true)
+          allow(@uploader).to receive(:store_path).with('test.jpg').and_return('uploads/test.jpg')
+          @fog_file = @storage.retrieve!('test.jpg')
+        end
+
+        it "should retrieve the file contents" do
+          expect(@fog_file.read.chomp).to eq("A test, 1234")
+        end
+
+        it "should have a path" do
+          expect(@fog_file.path).to eq('uploads/test.jpg')
+        end
+
+        it "should have a public url" do
+          unless fog_credentials[:provider] == 'Local'
+            expect(@fog_file.public_url).not_to be_nil
+          end
+        end
+
+        it "should return filesize" do
+          expect(@fog_file.size).to eq(12)
+        end
+
+        it "should be deletable" do
+          @fog_file.delete
+          expect(@directory.files.head('uploads/test.jpg')).to eq(nil)
+        end
+      end
+
+      describe '#cache!' do
+        before do
+          allow(@uploader).to receive(:cache_path).and_return('uploads/tmp/test+.jpg')
+          @fog_file = @storage.cache!(file)
+        end
+
+        it "should upload the file", focus: true do
+          expect(@directory.files.get('uploads/tmp/test+.jpg').body).to eq('this is stuff')
+        end
+      end
+
+      describe '#retrieve_from_cache!' do
+        before do
+          @directory.files.create(:key => 'uploads/tmp/test.jpg', :body => 'A test, 1234', :public => true)
+          allow(@uploader).to receive(:cache_path).with('test.jpg').and_return('uploads/tmp/test.jpg')
+          @fog_file = @storage.retrieve_from_cache!('test.jpg')
+        end
+
+        it "should retrieve the file contents" do
+          expect(@fog_file.read.chomp).to eq("A test, 1234")
+        end
+      end
+
+      describe '#delete_dir' do
+        it "should do nothing" do
+          expect(running{ @storage.delete_dir!('foobar') }).not_to raise_error
+        end
+      end
+
+      describe '#clean_cache!' do
+        let(:now){ Time.now.to_i }
+        before do
+          # clean up
+          @directory.files.each{|file| file.destroy }
+          # We can't use simple time freezing because of AWS request time check
+          five_days_ago_int  = now - 367270
+          three_days_ago_int = now - 194400
+          yesterday_int      = now - 21600
+
+          [five_days_ago_int, three_days_ago_int, yesterday_int].each do |as_of|
+            @directory.files.create(:key => "uploads/tmp/#{as_of}-234-2213/test.jpg", :body => 'A test, 1234', :public => true)
+          end
+        end
+
+        it "should clear all files older than, by defaul, 24 hours in the default cache directory" do
+          Timecop.freeze(Time.at(now)) do
+            @uploader.clean_cached_files!
+          end
+          expect(@directory.files.all(:prefix => 'uploads/tmp').size).to eq(1)
+        end
+
+        it "should permit to set since how many seconds delete the cached files" do
+          Timecop.freeze(Time.at(now)) do
+            @uploader.clean_cached_files!(60*60*24*4)
+          end
+          expect(@directory.files.all(:prefix => 'uploads/tmp').size).to eq(2)
+        end
+
+        it "should be aliased on the CarrierWave module" do
+          Timecop.freeze(Time.at(now)) do
+            CarrierWave.clean_cached_files!
+          end
+          expect(@directory.files.all(:prefix => 'uploads/tmp').size).to eq(1)
+        end
+      end
+
+      describe 'fog_public' do
+
+        context "true" do
+          before do
+            directory_key = "#{CARRIERWAVE_DIRECTORY}public"
+            @directory = @storage.connection.directories.create(:key => directory_key, :public => true)
+            allow(@uploader).to receive(:fog_directory).and_return(directory_key)
+            allow(@uploader).to receive(:store_path).and_return('uploads/public.txt')
+            @fog_file = @storage.store!(file)
+          end
+
+          after do
+            @directory.files.new(:key => 'uploads/public.txt').destroy
+            @directory.files.new(:key => 'test.jpg').destroy
+            @directory.destroy
+          end
+
+          it "should be available at public URL" do
+            unless Fog.mocking? || fog_credentials[:provider] == 'Local'
+              expect(open(@fog_file.public_url).read).to eq('this is stuff')
+            end
+          end
+        end
+
+        context "false" do
+          before do
+            directory_key = "#{CARRIERWAVE_DIRECTORY}private"
+            @directory = @storage.connection.directories.create(:key => directory_key, :public => true)
+            allow(@uploader).to receive(:fog_directory).and_return(directory_key)
+            allow(@uploader).to receive(:fog_public).and_return(false)
+            allow(@uploader).to receive(:store_path).and_return('uploads/private.txt')
+            @fog_file = @storage.store!(file)
+          end
+
+          after do
+            @directory.files.new(:key => 'uploads/private.txt').destroy
+            @directory.files.new(:key => 'test.jpg').destroy
+            @directory.destroy
+          end
+
+          it "should not be available at public URL" do
+            unless Fog.mocking? || fog_credentials[:provider] == 'Local'
+              expect(running{ open(@fog_file.public_url) }).to raise_error
+            end
+          end
+
+          it "should have an authenticated_url" do
+            if ['AWS', 'Rackspace', 'Google', 'OpenStack'].include?(@provider)
+              expect(@fog_file.authenticated_url).not_to be_nil
+            end
+          end
+
+          it 'should generate correct filename' do
+            expect(@fog_file.filename).to eq('private.txt')
+          end
+
+          it "should handle query params" do
+            if @provider == 'AWS' && !Fog.mocking?
+              headers = Excon.get(@fog_file.url(:query => {"response-content-disposition" => "attachment"})).headers
+              expect(headers["Content-Disposition"]).to eq("attachment")
+            end
+          end
+        end
+      end
+
+    end
+
+    describe "with a valid Hash" do
+      let(:file) do
+        CarrierWave::SanitizedFile.new(
+          :tempfile => stub_merb_tempfile('test.jpg'),
+          :filename => 'test.jpg',
+          :content_type => 'image/jpeg'
+        )
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+    end
+
+    describe "with a valid Tempfile" do
+      let(:file) do
+        CarrierWave::SanitizedFile.new(stub_tempfile('test.jpg', 'image/jpeg'))
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+    end
+
+    describe "with a valid StringIO" do
+      let(:file) do
+        CarrierWave::SanitizedFile.new(stub_stringio('test.jpg', 'image/jpeg'))
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+    end
+
+    describe "with a valid File object" do
+      let(:file) do
+        CarrierWave::SanitizedFile.new(stub_file('test.jpg', 'image/jpeg'))
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+
+    end
+
+    describe "with a valid path" do
+      let(:file) do
+        CarrierWave::SanitizedFile.new(file_path('test.jpg'))
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+    end
+
+    describe "with a valid Pathname" do
+      let(:file) do
+        CarrierWave::SanitizedFile.new(Pathname.new(file_path('test.jpg')))
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+    end
+
+    describe "with a CarrierWave::Storage::Fog::File" do
+      let(:file) do
+        CarrierWave::Storage::Fog::File.new(@uploader, @storage, 'test.jpg').
+          tap{|file| file.store(CarrierWave::SanitizedFile.new(
+            :tempfile => StringIO.new('this is stuff'), :content_type => 'image/jpeg')) }
+      end
+
+      it_should_behave_like "#{fog_credentials[:provider]} storage"
+    end
+
+  end
+end