carrierwave_direct 0.0.13 → 0.0.14

data/spec/support/form_builder_helpers.rb

@@ -12,6 +12,7 @@ require 'carrierwave_direct/action_view_extensions/form_helper'
 
 module FormBuilderHelpers
   include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::FormOptionsHelper
   include CarrierWaveDirect::ActionViewExtensions::FormHelper
   include ActionView::Context
 

data/spec/support/model_helpers.rb

@@ -16,16 +16,16 @@ module ModelHelpers
         if options[:accessible]
           if options[:accessible] == true
             it "should == '#{sample_data}'" do
-              accessor_value.should == sample_data
+              expect(accessor_value).to eq sample_data
             end
           else
             it "##{options[:accessible].keys.first} should be #{options[:accessible].values.first}" do
-              subject.send(options[:accessible].keys.first).should == options[:accessible].values.first
+              expect(subject.send(options[:accessible].keys.first)).to eq options[:accessible].values.first
             end
           end
         else
           it "should be nil" do
-            accessor_value.should be_nil
+            expect(accessor_value).to be_nil
           end
         end
       end
@@ -38,14 +38,14 @@ module ModelHelpers
       describe "##{name} = '#{sample_data}'" do
         it "should set the #{delegation_object}'s #{delegation_method}" do
           subject.send("#{name}=", sample_data)
-          subject.send(delegation_object).send(delegation_method).should == sample_data
+          expect(subject.send(delegation_object).send(delegation_method)).to eq sample_data
         end
       end
 
       describe "##{name}" do
         it "should return the #{delegation_method} from the #{delegation_object}" do
           subject.send(delegation_object).send("#{delegation_method}=", sample_data)
-          subject.send(name).should == sample_data
+          expect(subject.send(name)).to eq sample_data
         end
 
         it_should_be_accessible(name, sample_data, options)
@@ -62,7 +62,7 @@ module ModelHelpers
       end
 
       it "should respond to ##{name}=" do
-        subject.should respond_to("#{name}=")
+        expect(subject).to respond_to("#{name}=")
       end
 
       describe "##{name}" do
@@ -70,7 +70,7 @@ module ModelHelpers
           before { subject.send("#{name}=", sample_data) }
 
           it "should == '#{sample_data}'" do
-            subject.send(name).should == sample_data
+            expect(subject.send(name)).to eq sample_data
           end
         end
 

data/spec/support/view_helpers.rb

@@ -36,12 +36,22 @@ module ViewHelpers
   end
 
   def have_input(resource_name, input, options = {})
+    count = (options.delete :count).to_i
+    selector_options = count > 0 ? {:count => count} : {}
+
     options[:type] ||= input
     options[:id] ||= "#{resource_name}_#{input}"
     options[:name] ||= "#{resource_name}[#{input}]"
     options[:required] ||= "required" unless options[:required] == false
     parent_selector << "input[#{to_xpath_attributes(options)}]"
-    have_parent_selector
+    have_parent_selector selector_options
+  end
+
+  def have_content_type(content_type,selected=nil)
+    options = {:value => content_type}
+    options[:selected] = 'selected' if selected
+
+    have_selector :xpath, ".//select[@name=\"Content-Type\"]/option[#{to_xpath_attributes(options)}]"
   end
 end
 

data/spec/test/capybara_helpers_spec.rb

@@ -8,22 +8,26 @@ describe CarrierWaveDirect::Test::CapybaraHelpers do
   end
 
   let(:subject) { ExampleSpec.new }
-  let(:page) { mock("Page").as_null_object }
-  let(:selector) { mock("Selector") }
+  let(:page) { double("Page").as_null_object }
+  let(:selector) { double("Selector") }
 
   def stub_page
-    subject.stub(:page).and_return(page)
+    allow(subject).to receive(:page).and_return(page)
   end
 
-  def find_element_value(css, value)
-    page.stub(:find).with(css).and_return(selector)
-    selector.stub(:value).and_return(value)
+  def find_element_value(css, value, options = nil)
+    if options
+      allow(page).to receive(:find).with(css, options).and_return(selector)
+    else
+      allow(page).to receive(:find).with(css).and_return(selector)
+    end
+    allow(selector).to receive(:value).and_return(value)
   end
 
   describe "#attach_file_for_direct_upload" do
     context "'path/to/file.ext'" do
       it "should attach a file with the locator => 'file'" do
-        subject.should_receive(:attach_file).with("file", "path/to/file.ext")
+        expect(subject).to receive(:attach_file).with("file", "path/to/file.ext")
         subject.attach_file_for_direct_upload "path/to/file.ext"
       end
     end
@@ -40,19 +44,19 @@ describe CarrierWaveDirect::Test::CapybaraHelpers do
 
     def stub_common
       stub_page
-      find_element_value("input[@name='success_action_redirect']", "http://example.com")
-      subject.stub(:visit)
+      find_element_value("input[name='success_action_redirect']", "http://example.com", visible: false)
+      allow(subject).to receive(:visit)
     end
 
     before do
-      subject.stub(:click_button)
+      allow(subject).to receive(:click_button)
     end
 
     shared_examples_for "submitting the form" do
       let(:options) { {} }
 
       it "should submit the form" do
-        subject.should_receive(:click_button).with("Upload!")
+        expect(subject).to receive(:click_button).with("Upload!")
         upload_directly(options.merge(:button_locator => "Upload!"))
       end
     end
@@ -61,7 +65,7 @@ describe CarrierWaveDirect::Test::CapybaraHelpers do
       let(:options) { { :success => false } }
 
       it "should not redirect" do
-        subject.should_not_receive(:visit)
+        expect(subject).to_not receive(:visit)
         upload_directly(options)
       end
     end
@@ -69,30 +73,30 @@ describe CarrierWaveDirect::Test::CapybaraHelpers do
     context "passing no options" do
       before do
         stub_common
-        subject.stub(:find_key).and_return("upload_dir/guid/$filename")
-        subject.stub(:find_upload_path).and_return("path/to/file.ext")
+        allow(subject).to receive(:find_key).and_return("upload_dir/guid/$filename")
+        allow(subject).to receive(:find_upload_path).and_return("path/to/file.ext")
       end
 
       it_should_behave_like "submitting the form"
 
       it "should redirect to the page's success_action_redirect url" do
-        subject.should_receive(:visit).with(/^http:\/\/example.com/)
+        expect(subject).to receive(:visit).with(/^http:\/\/example.com/)
         upload_directly
       end
 
       context "the redirect url's params" do
         it "should include the bucket name" do
-          subject.should_receive(:visit).with(/bucket=/)
+          expect(subject).to receive(:visit).with(/bucket=/)
           upload_directly
         end
 
         it "should include an etag" do
-          subject.should_receive(:visit).with(/etag=/)
+          expect(subject).to receive(:visit).with(/etag=/)
           upload_directly
         end
 
         it "should include the key derived from the form" do
-          subject.should_receive(:visit).with(/key=upload_dir%2Fguid%2Ffile.ext/)
+          expect(subject).to receive(:visit).with(/key=upload_dir%2Fguid%2Ffile.ext/)
           upload_directly
         end
       end
@@ -106,7 +110,7 @@ describe CarrierWaveDirect::Test::CapybaraHelpers do
 
         context "the redirect url's params" do
           it "should include the key from the :redirect_key option" do
-            subject.should_receive(:visit).with(/key=some\+redirect\+key/)
+            expect(subject).to receive(:visit).with(/key=some\+redirect\+key/)
             upload_directly(:redirect_key => "some redirect key")
           end
         end
@@ -137,24 +141,23 @@ describe CarrierWaveDirect::Test::CapybaraHelpers do
   describe "#find_key" do
     before do
       stub_page
-      find_element_value("input[@name='key']", "key")
+      find_element_value("input[name='key']", "key", visible: false)
     end
 
     it "should try to find the key on the page" do
-      subject.find_key.should == "key"
+      expect(subject.find_key).to eq "key"
     end
   end
 
   describe "#find_upload_path" do
     before do
       stub_page
-      find_element_value("input[@name='file']", "upload path")
+      find_element_value("input[name='file']", "upload path", visible: false)
     end
 
     it "should try to find the upload path on the page" do
-      subject.find_upload_path.should == "upload path"
+      expect(subject.find_upload_path).to eq "upload path"
     end
   end
-
 end
 

data/spec/test/helpers_spec.rb

@@ -13,23 +13,23 @@ describe CarrierWaveDirect::Test::Helpers do
 
         shared_examples_for "returning the default extension" do
           it "should return '*/guid/filename.extension'" do
-            sample_key(direct_uploader).should =~ /#{GUID_REGEXP}\/filename\.extension$/
+            expect(sample_key(direct_uploader)).to match /#{GUID_REGEXP}\/filename\.extension$/
           end
         end
 
         context "['exe', 'bmp']" do
           before do
-            direct_uploader.stub(:extension_white_list).and_return(%w{exe bmp})
+            allow(direct_uploader).to receive(:extension_white_list).and_return(%w{exe bmp})
           end
 
           it "should return '*/guid/filename.exe'" do
-            sample_key(direct_uploader).should =~ /#{GUID_REGEXP}\/filename\.exe$/
+            expect(sample_key(direct_uploader)).to match /#{GUID_REGEXP}\/filename\.exe$/
           end
         end
 
         context "[]" do
           before do
-            direct_uploader.stub(:extension_white_list).and_return([])
+            allow(direct_uploader).to receive(:extension_white_list).and_return([])
           end
 
           it_should_behave_like "returning the default extension"
@@ -37,7 +37,7 @@ describe CarrierWaveDirect::Test::Helpers do
 
         context "nil" do
           before do
-            direct_uploader.stub(:extension_white_list).and_return(nil)
+            allow(direct_uploader).to receive(:extension_white_list).and_return(nil)
           end
 
           it_should_behave_like "returning the default extension"
@@ -47,9 +47,7 @@ describe CarrierWaveDirect::Test::Helpers do
 
       context "with no options" do
         it "should return '*/guid/filename.extension'" do
-          sample_key(
-            direct_uploader
-          ).should =~ /#{GUID_REGEXP}\/filename\.extension$/
+          expect(sample_key(direct_uploader)).to match /#{GUID_REGEXP}\/filename\.extension$/
         end
       end
 
@@ -64,7 +62,7 @@ describe CarrierWaveDirect::Test::Helpers do
 
         shared_examples_for "a custom filename" do
           it "should return '*/guid/some_file.reg'" do
-            sample_key(direct_uploader, options).should =~ /#{GUID_REGEXP}\/some_file\.reg$/
+            expect(sample_key(direct_uploader, options)).to match /#{GUID_REGEXP}\/some_file\.reg$/
           end
         end
 
@@ -82,10 +80,10 @@ describe CarrierWaveDirect::Test::Helpers do
 
         context ":base => 'upload_dir/porno/movie/${filename}'" do
           it "should return 'upload_dir/porno/movie/guid/filename.extension'" do
-            sample_key(
+            expect(sample_key(
               direct_uploader,
               :base => "upload_dir/porno/movie/${filename}"
-            ).should == "upload_dir/porno/movie/filename.extension"
+            )).to eq "upload_dir/porno/movie/filename.extension"
           end
         end
         context ":filename => 'some_file.reg'" do

data/spec/uploader/configuration_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe CarrierWaveDirect::Uploader::Configuration do
+  include UploaderHelpers
+  include ModelHelpers
+
+  let(:subject) { DirectUploader }
+
+  before do
+    subject.reset_direct_config
+  end
+
+  describe "default configuration" do
+    it "returns false for validate_is_attached" do
+      expect(subject.validate_is_attached).to be_false
+    end
+
+    it "returns false for validate_is_uploaded" do
+      expect(subject.validate_is_uploaded).to be_false
+    end
+
+    it "return true for validate_unique_filename" do
+      expect(subject.validate_unique_filename).to be_true
+    end
+
+    it "returns true for validate_remote_net_url_format" do
+      expect(subject.validate_remote_net_url_format).to be_true
+    end
+
+    it "has upload_expiration of 10 hours" do
+      expect(subject.upload_expiration).to eq 36000
+    end
+
+    it "has min_file_size of 1 byte" do
+      expect(subject.min_file_size).to eq 1
+    end
+
+    it "has max_file_size of 5 MB" do
+      expect(subject.max_file_size).to eq 5242880
+    end
+
+    it "returns false for use_action_status" do
+      expect(subject.use_action_status).to be_false
+    end
+  end
+end

data/spec/uploader/content_type_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe CarrierWaveDirect::Uploader::ContentType do
+  subject { DirectUploader.new }
+
+  describe "#content_type" do
+    it "defaults to binary/octet-stream when there is no default_content_type" do
+      allow(subject.class).to receive(:default_content_type).and_return(nil)
+      expect(subject.content_type).to eq 'binary/octet-stream'
+    end
+
+    it "returns the default_content_type if set" do
+      allow(subject.class).to receive(:default_content_type).and_return('video/mp4')
+      expect(subject.content_type).to eq 'video/mp4'
+    end
+  end
+
+  describe "#content_types" do
+    it "should default to common media types" do
+      expect(subject.content_types).to eq %w(application/atom+xml application/ecmascript application/json
+                                            application/javascript application/octet-stream application/ogg
+                                            application/pdf application/postscript application/rss+xml
+                                            application/font-woff application/xhtml+xml application/xml
+                                            application/xml-dtd application/zip application/gzip audio/basic
+                                            audio/mp4 audio/mpeg audio/ogg audio/vorbis audio/vnd.rn-realaudio
+                                            audio/vnd.wave audio/webm image/gif image/jpeg image/pjpeg image/png
+                                            image/svg+xml image/tiff text/cmd text/css text/csv text/html
+                                            text/javascript text/plain text/vcard text/xml video/mpeg video/mp4
+                                            video/ogg video/quicktime video/webm video/x-matroska video/x-ms-wmv
+                                            video/x-flv)
+    end
+
+    it "should be the configured value" do
+      allow(subject.class).to receive(:allowed_content_types).and_return(['audio/ogg'])
+      expect(subject.content_types).to eq ['audio/ogg']
+    end
+  end
+end

data/spec/uploader/direct_url_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+require 'data/sample_data'
+
+describe CarrierWaveDirect::Uploader::DirectUrl do
+
+  let(:subject) { DirectUploader.new }
+
+  describe "#direct_fog_url" do
+    it "should return the result from CarrierWave::Storage::Fog::File#public_url" do
+      expect(subject.direct_fog_url).to eq CarrierWave::Storage::Fog::File.new(
+        subject, nil, nil
+      ).public_url
+    end
+
+    context ":with_path => true" do
+
+      context "#key is set to '#{sample(:path_with_special_chars)}'" do
+        before { subject.key = sample(:path_with_special_chars) }
+
+        it "should return the full url with '/#{URI.escape(sample(:path_with_special_chars))}' as the path" do
+          direct_fog_url = CarrierWave::Storage::Fog::File.new(
+            subject, nil, nil
+          ).public_url
+          expect(subject.direct_fog_url(:with_path => true)).to eq direct_fog_url + "#{URI.escape(sample(:path_with_special_chars))}"
+        end
+      end
+
+      context "#key is set to '#{sample(:path_with_escaped_chars)}'" do
+        before { subject.key = sample(:path_with_escaped_chars) }
+
+        it "should return the full url with '/#{sample(:path_with_escaped_chars)}' as the path" do
+          direct_fog_url = CarrierWave::Storage::Fog::File.new(
+            subject, nil, nil
+          ).public_url
+          expect(subject.direct_fog_url(:with_path => true)).to eq direct_fog_url + sample(:path_with_escaped_chars)
+        end
+      end
+
+      context "#key is set to '#{sample(:path)}'" do
+        before { subject.key = sample(:path) }
+
+        it "should return the full url with '/#{sample(:path)}' as the path" do
+          direct_fog_url = CarrierWave::Storage::Fog::File.new(
+            subject, nil, nil
+          ).public_url
+          expect(subject.direct_fog_url(:with_path => true)).to eq direct_fog_url + "#{sample(:path)}"
+        end
+      end
+    end
+  end
+end
+
+
+

data/spec/uploader_spec.rb

@@ -1,87 +1,25 @@
 # encoding: utf-8
-
 require 'spec_helper'
+require 'data/sample_data'
 
 describe CarrierWaveDirect::Uploader do
   include UploaderHelpers
   include ModelHelpers
 
-  SAMPLE_DATA = {
-    :path => "upload_dir/bliind.exe",
-    :path_with_special_chars => "upload_dir/some file & blah.exe",
-    :key => "some key",
-    :guid => "guid",
-    :store_dir => "store_dir",
-    :extension_regexp => "(avi)",
-    :url => "http://example.com/some_url",
-    :expiration => 60,
-    :min_file_size => 1024,
-    :max_file_size => 10485760,
-    :file_url => "http://anyurl.com/any_path/video_dir/filename.avi",
-    :mounted_model_name => "Porno",
-    :mounted_as => :video,
-    :filename => "filename",
-    :extension => ".avi",
-    :version => :thumb,
-    :s3_bucket_url => "https://s3-bucket.s3.amazonaws.com"
-  }
-
-  SAMPLE_DATA.merge!(
-    :stored_filename_base => "#{sample(:guid)}/#{sample(:filename)}"
-  )
-
-  SAMPLE_DATA.merge!(
-    :stored_filename => "#{sample(:stored_filename_base)}#{sample(:extension)}",
-    :stored_version_filename => "#{sample(:stored_filename_base)}_#{sample(:version)}#{sample(:extension)}"
-  )
-
-  SAMPLE_DATA.merge!(
-    :s3_key => "#{sample(:store_dir)}/#{sample(:stored_filename)}"
-  )
-
-  SAMPLE_DATA.merge!(
-    :s3_file_url => "#{sample(:s3_bucket_url)}/#{sample(:s3_key)}"
-  )
-
-  SAMPLE_DATA.freeze
-
   let(:subject) { DirectUploader.new }
-  let(:mounted_model) { mock(sample(:mounted_model_name)) }
+  let(:mounted_model) { double(sample(:mounted_model_name)) }
   let(:mounted_subject) { DirectUploader.new(mounted_model, sample(:mounted_as)) }
   let(:direct_subject) { DirectUploader.new }
 
-  describe ".upload_expiration" do
-    it "should be 10 hours" do
-      subject.class.upload_expiration.should == 36000
-    end
-  end
-
-  describe ".min_file_size" do
-    it "should be 1 byte" do
-      subject.class.min_file_size.should == 1
-    end
-  end
-
-  describe ".max_file_size" do
-    it "should be 5 MB" do
-      subject.class.max_file_size.should == 5242880
-    end
-  end
-
-  describe ".use_action_status" do
-    it "should be false" do
-      subject.class.use_action_status.should be_false
-    end
-  end
 
   DirectUploader.fog_credentials.keys.each do |key|
     describe "##{key}" do
       it "should return the #{key.to_s.capitalize}" do
-        subject.send(key).should == DirectUploader.fog_credentials[key]
+        expect(subject.send(key)).to eq subject.class.fog_credentials[key]
       end
 
       it "should not be nil" do
-        subject.send(key).should_not be_nil
+        expect(subject.send(key)).to_not be_nil
       end
     end
   end
@@ -93,13 +31,13 @@ describe CarrierWaveDirect::Uploader do
     before { subject.key = sample(:key) }
 
     it "should set the key" do
-      subject.key.should == sample(:key)
+      expect(subject.key).to eq sample(:key)
     end
 
     context "the versions keys" do
       it "should == this subject's key" do
         subject.versions.each do |name, version_subject|
-          version_subject.key.should == subject.key
+          expect(version_subject.key).to eq subject.key
         end
       end
     end
@@ -112,39 +50,39 @@ describe CarrierWaveDirect::Uploader do
       end
 
       it "should return '*/\#\{guid\}/${filename}'" do
-        mounted_subject.key.should =~ /#{GUID_REGEXP}\/\$\{filename\}$/
+        expect(mounted_subject.key).to match /#{GUID_REGEXP}\/\$\{filename\}$/
       end
 
       context "and #store_dir returns '#{sample(:store_dir)}'" do
         before do
-          mounted_subject.stub(:store_dir).and_return(sample(:store_dir))
+          allow(mounted_subject).to receive(:store_dir).and_return(sample(:store_dir))
         end
 
         it "should return '#{sample(:store_dir)}/\#\{guid\}/${filename}'" do
-          mounted_subject.key.should =~ /^#{sample(:store_dir)}\/#{GUID_REGEXP}\/\$\{filename\}$/
+          expect(mounted_subject.key).to match /^#{sample(:store_dir)}\/#{GUID_REGEXP}\/\$\{filename\}$/
         end
       end
 
       context "and the uploaders url is #default_url" do
         it "should return '*/\#\{guid\}/${filename}'" do
-          mounted_subject.stub(:url).and_return(sample(:s3_file_url))
-          mounted_subject.stub(:present?).and_return(false)
-          mounted_subject.key.should =~ /#{GUID_REGEXP}\/\$\{filename\}$/
+          allow(mounted_subject).to receive(:url).and_return(sample(:s3_file_url))
+          allow(mounted_subject).to receive(:present?).and_return(false)
+          expect(mounted_subject.key).to match /#{GUID_REGEXP}\/\$\{filename\}$/
         end
       end
 
       context "but the uploaders url is '#{sample(:s3_file_url)}'" do
         before do
-          mounted_subject.stub(:url).and_return(sample(:s3_file_url))
-          mounted_subject.stub(:present?).and_return(true)
+          allow(mounted_subject).to receive(:url).and_return(sample(:s3_file_url))
+          allow(mounted_subject).to receive(:present?).and_return(true)
         end
 
         it "should return '#{sample(:s3_key)}'" do
-          mounted_subject.key.should == sample(:s3_key)
+          expect(mounted_subject.key).to eq sample(:s3_key)
         end
 
         it "should set the key explicitly in order to update the version keys" do
-          mounted_subject.should_receive("key=").with(sample(:s3_key))
+          expect(mounted_subject).to receive("key=").with(sample(:s3_key))
           mounted_subject.key
         end
       end
@@ -154,34 +92,34 @@ describe CarrierWaveDirect::Uploader do
       before { subject.key = sample(:key) }
 
       it "should return '#{sample(:key)}'" do
-        subject.key.should == sample(:key)
+        expect(subject.key).to eq sample(:key)
       end
     end
   end
 
   describe "#url_scheme_white_list" do
     it "should return nil" do
-      subject.url_scheme_white_list.should be_nil
+      expect(subject.url_scheme_white_list).to be_nil
     end
   end
 
   describe "#key_regexp" do
     it "should return a regexp" do
-      subject.key_regexp.should be_a(Regexp)
+      expect(subject.key_regexp).to be_a(Regexp)
     end
 
     context "where #store_dir returns '#{sample(:store_dir)}'" do
       before do
-        subject.stub(:store_dir).and_return(sample(:store_dir))
+        allow(subject).to receive(:store_dir).and_return(sample(:store_dir))
       end
 
       context "and #extension_regexp returns '#{sample(:extension_regexp)}'" do
         before do
-          subject.stub(:extension_regexp).and_return(sample(:extension_regexp))
+          allow(subject).to receive(:extension_regexp).and_return(sample(:extension_regexp))
         end
 
         it "should return /\\A#{sample(:store_dir)}\\/#{GUID_REGEXP}\\/.+\\.#{sample(:extension_regexp)}\\z/" do
-          subject.key_regexp.should ==  /\A#{sample(:store_dir)}\/#{GUID_REGEXP}\/.+\.(?i)#{sample(:extension_regexp)}(?-i)\z/
+          expect(subject.key_regexp).to eq /\A#{sample(:store_dir)}\/#{GUID_REGEXP}\/.+\.(?i)#{sample(:extension_regexp)}(?-i)\z/
         end
       end
     end
@@ -190,17 +128,17 @@ describe CarrierWaveDirect::Uploader do
   describe "#extension_regexp" do
     shared_examples_for "a globally allowed file extension" do
       it "should return '\\w+'" do
-        subject.extension_regexp.should == "\\w+"
+        expect(subject.extension_regexp).to eq "\\w+"
       end
     end
 
     it "should return a string" do
-      subject.extension_regexp.should be_a(String)
+      expect(subject.extension_regexp).to be_a(String)
     end
 
     context "where #extension_white_list returns nil" do
       before do
-        subject.stub(:extension_white_list).and_return(nil)
+        allow(subject).to receive(:extension_white_list).and_return(nil)
       end
 
       it_should_behave_like "a globally allowed file extension"
@@ -208,7 +146,7 @@ describe CarrierWaveDirect::Uploader do
 
     context "where #extension_white_list returns []" do
       before do
-        subject.stub(:extension_white_list).and_return([])
+        allow(subject).to receive(:extension_white_list).and_return([])
       end
 
       it_should_behave_like "a globally allowed file extension"
@@ -217,11 +155,11 @@ describe CarrierWaveDirect::Uploader do
     context "where #extension_white_list returns ['exe', 'bmp']" do
 
       before do
-        subject.stub(:extension_white_list).and_return(%w{exe bmp})
+        allow(subject).to receive(:extension_white_list).and_return(%w{exe bmp})
       end
 
       it "should return '(exe|bmp)'" do
-        subject.extension_regexp.should == "(exe|bmp)"
+        expect(subject.extension_regexp).to eq "(exe|bmp)"
       end
     end
   end
@@ -230,7 +168,7 @@ describe CarrierWaveDirect::Uploader do
     context "a key has not been set" do
 
       it "should return false" do
-        subject.should_not have_key
+        expect(subject).to_not have_key
       end
     end
 
@@ -238,7 +176,7 @@ describe CarrierWaveDirect::Uploader do
       before { subject.key }
 
       it "should return false" do
-        subject.should_not have_key
+        expect(subject).to_not have_key
       end
     end
 
@@ -246,47 +184,14 @@ describe CarrierWaveDirect::Uploader do
       before { subject.key = sample_key }
 
       it "should return true" do
-        subject.should have_key
-      end
-    end
-  end
-
-  describe "#direct_fog_url" do
-    it "should return the result from CarrierWave::Storage::Fog::File#public_url" do
-      subject.direct_fog_url.should == CarrierWave::Storage::Fog::File.new(
-        subject, nil, nil
-      ).public_url
-    end
-
-    context ":with_path => true" do
-
-      context "#key is set to '#{sample(:path_with_special_chars)}'" do
-        before { subject.key = sample(:path_with_special_chars) }
-
-        it "should return the full url with '/#{URI.escape(sample(:path_with_special_chars))}' as the path" do
-          direct_fog_url = CarrierWave::Storage::Fog::File.new(
-            subject, nil, nil
-          ).public_url
-          subject.direct_fog_url(:with_path => true).should == direct_fog_url + "#{URI.escape(sample(:path_with_special_chars))}"
-        end
-      end
-
-      context "#key is set to '#{sample(:path)}'" do
-        before { subject.key = sample(:path) }
-
-        it "should return the full url with '/#{sample(:path)}' as the path" do
-          direct_fog_url = CarrierWave::Storage::Fog::File.new(
-            subject, nil, nil
-          ).public_url
-          subject.direct_fog_url(:with_path => true).should == direct_fog_url + "#{sample(:path)}"
-        end
+        expect(subject).to have_key
       end
     end
   end
 
   describe "#persisted?" do
     it "should return false" do
-      subject.should_not be_persisted
+      expect(subject).to_not be_persisted
     end
   end
 
@@ -295,7 +200,7 @@ describe CarrierWaveDirect::Uploader do
       before { mounted_subject.key = sample(:s3_key) }
 
       it "should return '#{sample(:stored_filename)}'" do
-        mounted_subject.filename.should == sample(:stored_filename)
+        expect(mounted_subject.filename).to eq sample(:stored_filename)
       end
     end
 
@@ -303,7 +208,7 @@ describe CarrierWaveDirect::Uploader do
       before { subject.key = sample(:key) }
 
       it "should return '#{sample(:key)}'" do
-        subject.filename.should == sample(:key)
+        expect(subject.filename).to eq sample(:key)
       end
     end
 
@@ -311,51 +216,76 @@ describe CarrierWaveDirect::Uploader do
       context "but the model's remote #{sample(:mounted_as)} url is: '#{sample(:file_url)}'" do
 
         before do
-          mounted_subject.model.stub(
+          allow(mounted_subject.model).to receive(
             "remote_#{mounted_subject.mounted_as}_url"
           ).and_return(sample(:file_url))
         end
 
         it "should set the key to contain '#{File.basename(sample(:file_url))}'" do
           mounted_subject.filename
-          mounted_subject.key.should =~ /#{Regexp.escape(File.basename(sample(:file_url)))}$/
+          expect(mounted_subject.key).to match /#{Regexp.escape(File.basename(sample(:file_url)))}$/
         end
 
         it "should return a filename based off the key and remote url" do
           filename = mounted_subject.filename
-          mounted_subject.key.should =~ /#{Regexp.escape(filename)}$/
+          expect(mounted_subject.key).to match /#{Regexp.escape(filename)}$/
         end
 
         # this ensures that the version subject keys are updated
         # see spec for key= for more details
         it "should set the key explicitly" do
-          mounted_subject.should_receive(:key=)
+          expect(mounted_subject).to receive(:key=)
           mounted_subject.filename
         end
       end
 
       context "and the model's remote #{sample(:mounted_as)} url has whitespace in it" do
         before do
-          mounted_model.stub(
+          allow(mounted_model).to receive(
             "remote_#{mounted_subject.mounted_as}_url"
           ).and_return("http://anyurl.com/any_path/video_dir/filename 2.avi")
         end
 
         it "should be sanitized (whitespace replaced with _)" do
           mounted_subject.filename
-          mounted_subject.key.should =~ /filename_2.avi$/
+          expect(mounted_subject.key).to match /filename_2.avi$/
         end
       end
 
+      context "and the model's remote url contains escape characters" do
+        before do 
+          subject.key = nil
+          allow(subject).to receive(:present?).and_return(:true)
+          allow(subject).to receive(:url).and_return("http://anyurl.com/any_path/video_dir/filename ()+[]2.avi")
+        end
+
+        it "should be escaped and replaced with non whitespace characters" do
+          expect(subject.key).to match /filename%20%28%29%2B%5B%5D2.avi/
+        end
+      end
+
+      context "and the model's remote url contains already escaped characters" do
+        before do
+          subject.key = nil
+          allow(subject).to receive(:present?).and_return(:true)
+          allow(subject).to receive(:url).and_return("http://anyurl.com/any_path/video_dir/filename%20%28%29%2B%5B%5D2.avi")
+        end
+
+        it "should not double escape already escaped characters" do
+          expect(subject.key).to match /filename%20%28%29%2B%5B%5D2.avi/
+        end
+
+      end
+
       context "and the model's remote #{sample(:mounted_as)} url is blank" do
         before do
-          mounted_model.stub(
+          allow(mounted_model).to receive(
             "remote_#{mounted_subject.mounted_as}_url"
           ).and_return nil
         end
 
         it "should return nil" do
-          mounted_subject.filename.should be_nil
+          expect(mounted_subject.filename).to be_nil
         end
       end
     end
@@ -363,7 +293,7 @@ describe CarrierWaveDirect::Uploader do
 
   describe "#acl" do
     it "should return the correct s3 access policy" do
-      subject.acl.should == (subject.fog_public ? 'public-read' : 'private')
+      expect(subject.acl).to eq (subject.fog_public ? 'public-read' : 'private')
     end
   end
 
@@ -375,11 +305,21 @@ describe CarrierWaveDirect::Uploader do
     end
 
     it "should return Base64-encoded JSON" do
-      decoded_policy.should be_a(Hash)
+      expect(decoded_policy).to be_a(Hash)
     end
 
     it "should not contain any new lines" do
-      subject.policy.should_not include("\n")
+      expect(subject.policy).to_not include("\n")
+    end
+
+    it "should be cached" do
+      Timecop.freeze(Time.now) do
+        @policy_now = subject.policy
+      end
+      Timecop.freeze(1.second.from_now) do
+        @policy_later = subject.policy
+      end
+      expect(@policy_later).to eql @policy_now
     end
 
     context "expiration" do
@@ -399,17 +339,17 @@ describe CarrierWaveDirect::Uploader do
 
       it "should be #{DirectUploader.upload_expiration / 3600} hours from now" do
         Timecop.freeze(Time.now) do
-          Time.parse(expiration).should have_expiration
+          expect(Time.parse(expiration)).to have_expiration
         end
       end
 
       it "should be encoded as a utc time" do
-        Time.parse(expiration).should be_utc
+        expect(Time.parse(expiration)).to be_utc
       end
 
       it "should be #{sample(:expiration) / 60 } minutes from now when passing {:expiration => #{sample(:expiration)}}" do
         Timecop.freeze(Time.now) do
-          Time.parse(expiration(:expiration => sample(:expiration))).should have_expiration(sample(:expiration))
+          expect(Time.parse(expiration(:expiration => sample(:expiration)))).to have_expiration(sample(:expiration))
         end
       end
     end
@@ -426,38 +366,44 @@ describe CarrierWaveDirect::Uploader do
       context "should include" do
         # Rails form builder conditions
         it "'utf8'" do
-          conditions.should have_condition(:utf8)
+          expect(conditions).to have_condition(:utf8)
         end
 
         # S3 conditions
         it "'key'" do
-          mounted_subject.stub(:key).and_return(sample(:s3_key))
-          conditions(
+          allow(mounted_subject).to receive(:key).and_return(sample(:s3_key))
+          expect(conditions(
             :subject => mounted_subject
-          ).should have_condition(:key, sample(:s3_key))
+          )).to have_condition(:key, sample(:s3_key))
         end
 
         it "'key' without FILENAME_WILDCARD" do
-          conditions(
+          expect(conditions(
             :subject => mounted_subject
-          ).should have_condition(:key, mounted_subject.key.sub("${filename}", ""))
+          )).to have_condition(:key, mounted_subject.key.sub("${filename}", ""))
         end
 
         it "'bucket'" do
-          conditions.should have_condition("bucket" => subject.fog_directory)
+          expect(conditions).to have_condition("bucket" => subject.fog_directory)
         end
 
         it "'acl'" do
-          conditions.should have_condition("acl" => subject.acl)
+          expect(conditions).to have_condition("acl" => subject.acl)
         end
 
         it "'success_action_redirect'" do
           subject.success_action_redirect = "http://example.com/some_url"
-          conditions.should have_condition("success_action_redirect" => "http://example.com/some_url")
+          expect(conditions).to have_condition("success_action_redirect" => "http://example.com/some_url")
         end
 
-        it "'content-type' only if enabled" do
-          conditions.should have_condition('Content-Type') if subject.class.will_include_content_type
+        it "does not have 'content-type' when will_include_content_type is false" do
+          allow(subject.class).to receive(:will_include_content_type).and_return(false)
+          expect(conditions).to_not have_condition('Content-Type')
+        end
+
+        it "has 'content-type' when will_include_content_type is true" do
+          allow(subject.class).to receive(:will_include_content_type).and_return(true)
+          expect(conditions).to have_condition('Content-Type')
         end
 
         context 'when use_action_status is true' do
@@ -471,12 +417,12 @@ describe CarrierWaveDirect::Uploader do
 
           it "'success_action_status'" do
             subject.success_action_status = '200'
-            conditions.should have_condition("success_action_status" => "200")
+            expect(conditions).to have_condition("success_action_status" => "200")
           end
 
           it "does not have 'success_action_redirect'" do
             subject.success_action_redirect = "http://example.com/some_url"
-            conditions.should_not have_condition("success_action_redirect" => "http://example.com/some_url")
+            expect(conditions).to_not have_condition("success_action_redirect" => "http://example.com/some_url")
           end
         end
 
@@ -490,53 +436,68 @@ describe CarrierWaveDirect::Uploader do
           end
 
           it "#{DirectUploader.min_file_size} bytes" do
-            conditions.should have_content_length_range
+            expect(conditions).to have_content_length_range
           end
 
           it "#{DirectUploader.max_file_size} bytes" do
-            conditions.should have_content_length_range
+            expect(conditions).to have_content_length_range
           end
 
           it "#{sample(:min_file_size)} bytes when passing {:min_file_size => #{sample(:min_file_size)}}" do
-            conditions(
+            expect(conditions(
               :min_file_size => sample(:min_file_size)
-            ).should have_content_length_range(:min_file_size => sample(:min_file_size))
+            )).to have_content_length_range(:min_file_size => sample(:min_file_size))
           end
 
           it "#{sample(:max_file_size)} bytes when passing {:max_file_size => #{sample(:max_file_size)}}" do
-            conditions(
+            expect(conditions(
               :max_file_size => sample(:max_file_size)
-            ).should have_content_length_range(:max_file_size => sample(:max_file_size))
+            )).to have_content_length_range(:max_file_size => sample(:max_file_size))
           end
         end
       end
     end
   end
 
+  describe "clear_policy!" do
+    it "should reset the cached policy string" do
+      Timecop.freeze(Time.now) do
+        @policy_now = subject.policy
+      end
+      subject.clear_policy!
+
+      Timecop.freeze(1.second.from_now) do
+        @policy_after_reset = subject.policy
+      end
+      expect(@policy_after_reset).not_to eql @policy_now
+    end
+  end
+
   describe "#signature" do
     it "should not contain any new lines" do
-      subject.signature.should_not include("\n")
+      expect(subject.signature).to_not include("\n")
     end
 
     it "should return a base64 encoded 'sha1' hash of the secret key and policy document" do
-      Base64.decode64(subject.signature).should == OpenSSL::HMAC.digest(
-        OpenSSL::Digest::Digest.new('sha1'),
+      expect(Base64.decode64(subject.signature)).to eq OpenSSL::HMAC.digest(
+        OpenSSL::Digest.new('sha1'),
         subject.aws_secret_access_key, subject.policy
       )
     end
   end
 
+
   # note that 'video' is hardcoded into the MountedClass support file
   # so changing the sample will cause the tests to fail
   context "a class has a '#{sample(:mounted_as)}' mounted" do
     describe "#{sample(:mounted_as).to_s.capitalize}Uploader" do
       describe "##{sample(:mounted_as)}" do
         it "should be defined" do
-          direct_subject.should be_respond_to(sample(:mounted_as))
+          expect(direct_subject).to be_respond_to(sample(:mounted_as))
         end
 
         it "should return itself" do
-          direct_subject.send(sample(:mounted_as)).should == direct_subject
+          expect(direct_subject.send(sample(:mounted_as))).to eq direct_subject
         end
       end
 
@@ -556,11 +517,11 @@ describe CarrierWaveDirect::Uploader do
             let(:store_path) { video_subject.send(sample(:version)).store_path }
 
             it "should be like '#{sample(:stored_version_filename)}'" do
-              store_path.should =~ /#{sample(:stored_version_filename)}$/
+              expect(store_path).to match /#{sample(:stored_version_filename)}$/
             end
 
             it "should not be like '#{sample(:version)}_#{sample(:stored_filename_base)}'" do
-              store_path.should_not =~ /#{sample(:version)}_#{sample(:stored_filename_base)}/
+              expect(store_path).to_not match /#{sample(:version)}_#{sample(:stored_filename_base)}/
             end
           end
         end