carrierwave_direct 0.0.13 → 0.0.17

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), video_identifier: sample(:stored_filename)) }
   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,40 @@ 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(:store_dir).and_return(sample(:store_dir))
+          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 +93,35 @@ 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))
+        allow(subject).to receive(:cache_dir).and_return(sample(:cache_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/
+        it "should return /\\A(#{sample(:store_dir)}|#{sample(:cache_dir)})\\/#{GUID_REGEXP}\\/.+\\.#{sample(:extension_regexp)}\\z/" do
+          expect(subject.key_regexp).to eq /\A(#{sample(:store_dir)}|#{sample(:cache_dir)})\/#{GUID_REGEXP}\/.+\.(?i)#{sample(:extension_regexp)}(?-i)\z/
         end
       end
     end
@@ -190,17 +130,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 +148,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 +157,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 +170,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 +178,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 +186,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 +202,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 +210,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 +218,51 @@ 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
+      context "and the model's remote #{sample(:mounted_as)} url has special characters 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")
+          ).and_return("http://anyurl.com/any_path/video_dir/filename ()+[]2.avi")
         end
 
-        it "should be sanitized (whitespace replaced with _)" do
+        it "should be sanitized (special characters 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 #{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,23 +270,52 @@ 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
 
   # http://aws.amazon.com/articles/1434?_encoding=UTF8
   describe "#policy" do
-    def decoded_policy(options = {})
+
+
+    def decoded_policy(options = {}, &block)
       instance = options.delete(:subject) || subject
-      JSON.parse(Base64.decode64(instance.policy(options)))
+      JSON.parse(Base64.decode64(instance.policy(options, &block)))
+    end
+
+    context "policy is given a block" do
+      it "should yield the options to the block" do
+        number = 0
+        subject.policy do |conditions|
+          number+=1
+        end
+        expect(number).to eq 1
+      end
+      it "should include new options in the conditions" do
+        policy = subject.policy do |conditions|
+          conditions << {"x-aws-storage-class" => "STANDARD"}
+        end
+        decoded = JSON.parse(Base64.decode64(policy))
+        expect(decoded['conditions'].last['x-aws-storage-class']).to eq "STANDARD"
+      end
     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
@@ -387,29 +323,30 @@ describe CarrierWaveDirect::Uploader do
         decoded_policy(options)["expiration"]
       end
 
+      # JSON times have no seconds, so accept upto one second inaccuracy
       def have_expiration(expires_in = DirectUploader.upload_expiration)
-        eql(
-          Time.parse(
-            JSON.parse({
-              "expiry" => Time.now + expires_in
-            }.to_json)["expiry"]
-          )
-        )
+        be_within(1.second).of (Time.now + expires_in)
+      end
+
+      it "should be valid ISO8601 and not use default Time#to_json" do
+        Time.any_instance.stub(:to_json) { '"Invalid time"' } # JSON gem
+        Time.any_instance.stub(:as_json) { '"Invalid time"' } # Active Support
+        expect { Time.iso8601(expiration) }.to_not raise_error
       end
 
       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
@@ -424,40 +361,49 @@ describe CarrierWaveDirect::Uploader do
       end
 
       context "should include" do
-        # Rails form builder conditions
-        it "'utf8'" do
-          conditions.should have_condition(:utf8)
+        it "'utf8' if enforce_ut8 is set" do
+          expect(conditions(enforce_utf8: true)).to have_condition(:utf8)
+        end
+
+        it "'utf8' if enforce_ut8 is set" do
+          expect(conditions).to_not 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