cloudinary 1.1.6 → 1.1.7

data/spec/archive_spec.rb

@@ -3,14 +3,13 @@ require 'cloudinary'
 require 'rest_client'
 require 'zip'
 
-ARCHIVE_TAG = "archive_test_tag_#{rand}"
-
 RSpec.shared_context 'archive' do
+
   before :all do
     Cloudinary::Uploader.upload(
       "http://res.cloudinary.com/demo/image/upload/sample.jpg",
       :public_id      => 'tag_samplebw',
-      :tags           => [TEST_TAG, ARCHIVE_TAG],
+      :tags           => [TEST_TAG, TIMESTAMP_TAG],
       :transformation => {
         :effect => :blackwhite
       }
@@ -18,13 +17,13 @@ RSpec.shared_context 'archive' do
     Cloudinary::Uploader.upload(
       "http://res.cloudinary.com/demo/image/upload/sample.jpg",
       :public_id      => 'tag_sample',
-      :tags           => [TEST_TAG, ARCHIVE_TAG],
+      :tags           => [TEST_TAG, TIMESTAMP_TAG],
       :transformation => {
         :effect => :blackwhite
       }
     )
   end
-  include_context "cleanup"
+  include_context "cleanup", TIMESTAMP_TAG
 end
 
 describe Cloudinary::Utils do
@@ -37,7 +36,7 @@ describe Cloudinary::Utils do
         {
           :target_public_id => 'gem_archive_test',
           :public_ids       => %w(tag_sample tag_samplebw),
-          :target_tags      => [TEST_TAG, ARCHIVE_TAG]
+          :target_tags      => [TEST_TAG, TIMESTAMP_TAG]
         }.merge(options))
     }
 
@@ -62,12 +61,15 @@ describe Cloudinary::Uploader do
   let(:options) { {} }
 
   describe '.create_archive' do
+    let!(:target_public_id) {
+      "gem_test#{ rand(1000000)}"
+    }
     let!(:archive_result) {
       Cloudinary::Uploader.create_archive(
         {
-          :target_public_id => 'gem_archive_test',
+          :target_public_id => target_public_id,
           :public_ids       => %w(tag_sample tag_samplebw),
-          :tags             => ARCHIVE_TAG
+          :tags             => [TEST_TAG, TIMESTAMP_TAG]
         }.merge(options))
     }
     let(:options) { { :mode => :create } }

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require 'rest_client'
 
 TEST_IMAGE_URL = "http://cloudinary.com/images/old_logo.png"
 TEST_TAG = 'cloudinary_gem_test'
+TIMESTAMP_TAG = "#{TEST_TAG}_#{rand(999999999)}_#{RUBY_VERSION}_#{ defined? Rails::version ? Rails::version : 'no_rails'}"
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
@@ -15,12 +16,20 @@ RSpec.configure do |config|
   config.filter_run_excluding :delete_all => true
 end
 
-RSpec.shared_context "cleanup" do
+RSpec.shared_context "cleanup" do |tag|
+  tag ||= TEST_TAG
   after :all do
-    Cloudinary::Api.delete_resources_by_tag(TEST_TAG) unless Cloudinary.config.keep_test_products
+    Cloudinary::Api.delete_resources_by_tag(tag) unless Cloudinary.config.keep_test_products
   end
 
 end
+
+
+CALLS_SERVER_WITH_PARAMETERS = "calls server with parameters"
+RSpec.shared_examples CALLS_SERVER_WITH_PARAMETERS do |expected|
+  expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+end
+
 # Create a regexp with the given +tag+ name.
 def html_tag_matcher( tag)
   /<#{tag}([\s]+([-[:word:]]+)[\s]*\=\s*\"([^\"]*)\")*\s*>.*<\s*\/#{tag}\s*>/
@@ -157,9 +166,54 @@ end
 RSpec::Matchers.define :deep_hash_value do |expected|
   match do |actual|
     expected.all? do |path, value|
-      values_match? deep_fetch(actual, path), value
+      Cloudinary.values_match? deep_fetch(actual, path), value
     end
   end
 end
 
-RSpec::Matchers.alias_matcher :have_deep_hash_values_of, :deep_hash_value
+RSpec::Matchers.alias_matcher :have_deep_hash_values_of, :deep_hash_value
+
+module Cloudinary
+  # @api private
+  def self.values_match?( actual, expected)
+    if Hash === actual
+      return hashes_match?(expected, actual) if Hash === expected
+    elsif Array === expected && Enumerable === actual && !(Struct === actual)
+      return arrays_match?(expected, actual.to_a)
+    elsif Regexp === expected
+      return expected.match actual.to_s
+    end
+
+
+    return true if actual == expected
+
+    begin
+      expected === actual
+    rescue ArgumentError
+      # Some objects, like 0-arg lambdas on 1.9+, raise
+      # ArgumentError for `expected === actual`.
+      false
+    end
+  end
+
+  # @private
+  def self.arrays_match?(expected_list, actual_list)
+    return false if expected_list.size != actual_list.size
+
+    expected_list.zip(actual_list).all? do |expected, actual|
+      values_match?(expected, actual)
+    end
+  end
+
+  # @private
+  def self.hashes_match?(expected_hash, actual_hash)
+    return false if expected_hash.size != actual_hash.size
+
+    expected_hash.all? do |expected_key, expected_value|
+      actual_value = actual_hash.fetch(expected_key) { return false }
+      values_match?(expected_value, actual_value)
+    end
+  end
+
+  private_class_method :arrays_match?, :hashes_match?
+end

data/spec/uploader_spec.rb

@@ -7,14 +7,14 @@ end
 
 describe Cloudinary::Uploader do
   break puts("Please setup environment for api test to run") if Cloudinary.config.api_secret.blank?
-  include_context "cleanup"
+  include_context "cleanup", TIMESTAMP_TAG
 
   TEST_IMG = "spec/logo.png"
   TEST_IMG_W = 241
   TEST_IMG_H = 51
 
   it "should successfully upload file" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["width"]).to eq(TEST_IMG_W)
     expect(result["height"]).to eq(TEST_IMG_H)
     expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>result["public_id"], :version=>result["version"]}, Cloudinary.config.api_secret)
@@ -22,12 +22,12 @@ describe Cloudinary::Uploader do
   end
 
   it "should successfully upload a file from pathname", :pathname => true do
-    result = Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["width"]).to eq(TEST_IMG_W)
   end
 
   it "should successfully upload file by url" do
-    result = Cloudinary::Uploader.upload("http://cloudinary.com/images/old_logo.png", :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload("http://cloudinary.com/images/old_logo.png", :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["width"]).to eq(TEST_IMG_W)
     expect(result["height"]).to eq(TEST_IMG_H)
     expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>result["public_id"], :version=>result["version"]}, Cloudinary.config.api_secret)
@@ -36,9 +36,9 @@ describe Cloudinary::Uploader do
 
   describe '.rename' do
     before(:all) do
-      @result        = Cloudinary::Uploader.upload(TEST_IMG, :tags => TEST_TAG)
+      @result        = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])
       @resource_1_id = @result["public_id"]
-      result         = Cloudinary::Uploader.upload("spec/favicon.ico", :tags => TEST_TAG)
+      result         = Cloudinary::Uploader.upload("spec/favicon.ico", :tags => [TEST_TAG, TIMESTAMP_TAG])
       @resource_2_id = result["public_id"]
     end
 
@@ -55,115 +55,148 @@ describe Cloudinary::Uploader do
     end
     context ':overwrite => true' do
       it 'should rename to an existing ID' do
-        new_id = Cloudinary::Uploader.upload(TEST_IMG, :tags => TEST_TAG)["public_id"]
+        new_id = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])["public_id"]
         Cloudinary::Uploader.rename(@resource_2_id, new_id, :overwrite => true)
         expect(Cloudinary::Api.resource(new_id)["format"]).to eq("ico")
         @resource_2_id = new_id # will not update if expect fails
       end
     end
     context ':invalidate => true' do
-      it 'should notidy the server to invalidate the resource in the CDN' do
+      it 'should notify the server to invalidate the resource in the CDN' do
         # Can't test the result, so we just verify the parameter is send to the server
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value([:payload, :invalidate] => 1))
+        expected ={
+            :url => /.*\/rename$/,
+            [:payload, :invalidate] => 1,
+            [:payload, :from_public_id] => @resource_2_id,
+            [:payload, :to_public_id] => @resource_2_id+"2"
+        }
+        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
         Cloudinary::Uploader.rename(@resource_2_id, @resource_2_id+"2", :invalidate => true) # will not affect the server
       end
 
     end
   end
 
-
   it "should support explicit" do
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :public_id] => "sample", [:payload, :eager] => "c_scale,w_2.0"))
     result = Cloudinary::Uploader.explicit("sample", :type=>"upload", :eager=>[{:crop=>"scale", :width=>"2.0"}])
-    url = Cloudinary::Utils.cloudinary_url("sample", :type=>"upload", :crop=>"scale", :width=>"2.0", :format=>"jpg", :version=>result["version"])
-    expect(result["eager"][0]["url"]).to eq(url)
   end
   
   it "should support eager" do
-    Cloudinary::Uploader.upload(TEST_IMG, :eager =>[{ :crop =>"scale", :width =>"2.0"}], :tags => TEST_TAG)
+    Cloudinary::Uploader.upload(TEST_IMG, :eager =>[{ :crop =>"scale", :width =>"2.0"}], :tags => [TEST_TAG, TIMESTAMP_TAG])
   end
 
   it "should support headers" do
-    Cloudinary::Uploader.upload(TEST_IMG, :headers =>["Link: 1"], :tags => TEST_TAG)
-    Cloudinary::Uploader.upload(TEST_IMG, :headers =>{ "Link" => "1"}, :tags => TEST_TAG)
+    Cloudinary::Uploader.upload(TEST_IMG, :headers =>["Link: 1"], :tags => [TEST_TAG, TIMESTAMP_TAG])
+    Cloudinary::Uploader.upload(TEST_IMG, :headers =>{ "Link" => "1"}, :tags => [TEST_TAG, TIMESTAMP_TAG])
   end
 
   it "should successfully generate text image" do
-    result = Cloudinary::Uploader.text("hello world", :tags => TEST_TAG)
+    result = Cloudinary::Uploader.text("hello world", :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["width"]).to be > 1
     expect(result["height"]).to be > 1
   end
 
-  it "should correctly handle tags" do
-    new_tag = "tag#{rand(10000)}"
-    result = Cloudinary::Uploader.upload(TEST_IMG, :tags => TEST_TAG)
-    Cloudinary::Uploader.add_tag("#{new_tag}_1", result["public_id"])
-    Cloudinary::Uploader.add_tag("#{new_tag}_2", result["public_id"])
-    expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to match_array(["#{new_tag}_1", "#{new_tag}_2", TEST_TAG])
-    Cloudinary::Uploader.remove_tag("#{new_tag}_1", result["public_id"])
-    expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to match_array(["#{new_tag}_2", TEST_TAG])
-    Cloudinary::Uploader.replace_tag("#{new_tag}_3", result["public_id"])
-    expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to match_array(["#{new_tag}_3"])
-  end
+  describe "tag" do
+    describe "add_tag" do
+      it "should correctly handle tags" do
+        expected ={
+            :url => /.*\/tags/,
+            [:payload, :tag] => "new_tag",
+            [:payload, :public_ids] => ["some_public_id"],
+            [:payload, :command] => "add"
+        }
+        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+
+        Cloudinary::Uploader.add_tag( "new_tag", "some_public_id")
+      end
+      describe ":exclusive" do
+        it "should support :exclusive" do
+          expected ={
+              :url => /.*\/tags/,
+              [:payload, :tag] => "new_tag",
+              [:payload, :public_ids] => ["some_public_id"],
+              [:payload, :command] => "set_exclusive"
+          }
+          expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+
+          Cloudinary::Uploader.add_tag( "new_tag", "some_public_id", :exclusive => true)
+        end
+      end
+
+
+
+    end
+
+      # Cloudinary::Uploader.add_tag("#{new_tag}_2", result["public_id"])
+      # expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to match_array(["#{new_tag}_1", "#{new_tag}_2", TEST_TAG, TIMESTAMP_TAG])
+      # Cloudinary::Uploader.remove_tag("#{new_tag}_1", result["public_id"])
+      # expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to match_array(["#{new_tag}_2", TEST_TAG, TIMESTAMP_TAG])
+      # Cloudinary::Uploader.replace_tag("#{new_tag}_3", result["public_id"])
+      # expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to match_array(["#{new_tag}_3"])
+    end
+
+
   
   it "should correctly handle unique_filename" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :use_filename => true, :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload(TEST_IMG, :use_filename => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["public_id"]).to match(/logo_[a-zA-Z0-9]{6}/)
-    result = Cloudinary::Uploader.upload(TEST_IMG, :use_filename => true, :unique_filename => false, :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload(TEST_IMG, :use_filename => true, :unique_filename => false, :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["public_id"]).to eq("logo")
   end
   
   it "should allow whitelisted formats if allowed_formats", :allowed=>true do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["png"], :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["png"], :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["format"]).to eq("png")
   end
   
   it "should prevent non whitelisted formats from being uploaded if allowed_formats is specified", :allowed=>true do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["jpg"], :tags => TEST_TAG)}.to raise_error
+    expect{Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["jpg"], :tags => [TEST_TAG, TIMESTAMP_TAG])}.to raise_error
   end
   
   it "should allow non whitelisted formats if type is specified and convert to that type", :allowed=>true do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["jpg"], :format => "jpg", :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["jpg"], :format => "jpg", :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["format"]).to eq("jpg")
   end
   
   it "should allow sending face coordinates" do
     coordinates = [[120, 30, 109, 150], [121, 31, 110, 151]]
-    result = Cloudinary::Uploader.upload(TEST_IMG, { :face_coordinates => coordinates, :faces => true, :tags => TEST_TAG})
+    result = Cloudinary::Uploader.upload(TEST_IMG, { :face_coordinates => coordinates, :faces => true, :tags => [TEST_TAG, TIMESTAMP_TAG]})
     expect(result["faces"]).to eq(coordinates)
 
     different_coordinates = [[122, 32, 111, 152]]
-    Cloudinary::Uploader.explicit(result["public_id"], {:face_coordinates => different_coordinates, :faces => true, :type => "upload", :tags => TEST_TAG})
+    Cloudinary::Uploader.explicit(result["public_id"], {:face_coordinates => different_coordinates, :faces => true, :type => "upload", :tags => [TEST_TAG, TIMESTAMP_TAG]})
     info = Cloudinary::Api.resource(result["public_id"], {:faces => true})
     expect(info["faces"]).to eq(different_coordinates)
   end
   
   it "should allow sending context" do
     context = {"caption" => "some caption", "alt" => "alternative"}
-    result = Cloudinary::Uploader.upload(TEST_IMG, { :context => context, :tags => TEST_TAG})
+    result = Cloudinary::Uploader.upload(TEST_IMG, { :context => context, :tags => [TEST_TAG, TIMESTAMP_TAG]})
     info = Cloudinary::Api.resource(result["public_id"], {:context => true})
     expect(info["context"]).to eq({"custom" => context})
   end
   
   it "should support requesting manual moderation" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, { :moderation => :manual, :tags => TEST_TAG})
+    result = Cloudinary::Uploader.upload(TEST_IMG, { :moderation => :manual, :tags => [TEST_TAG, TIMESTAMP_TAG]})
     expect(result["moderation"][0]["status"]).to eq("pending")
     expect(result["moderation"][0]["kind"]).to eq("manual")
   end
     
   it "should support requesting raw conversion" do
-    expect{Cloudinary::Uploader.upload("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal, :tags => TEST_TAG})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
+    expect{Cloudinary::Uploader.upload("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
   end
   
   it "should support requesting categorization" do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, { :categorization => :illegal, :tags => TEST_TAG})}.to raise_error(CloudinaryException, /Illegal value|not a valid|is invalid/)
+    expect{Cloudinary::Uploader.upload(TEST_IMG, { :categorization => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid|is invalid/)
   end
   
   it "should support requesting detection" do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, { :detection => :illegal, :tags => TEST_TAG})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
+    expect{Cloudinary::Uploader.upload(TEST_IMG, { :detection => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
   end
   
   it "should support requesting auto_tagging" do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, { :auto_tagging => 0.5, :tags => TEST_TAG})}.to raise_error(CloudinaryException, /Must use/)
+    expect{Cloudinary::Uploader.upload(TEST_IMG, { :auto_tagging => 0.5, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Must use/)
   end
 
   it "should support upload_large", :large => true do
@@ -172,10 +205,10 @@ describe Cloudinary::Uploader do
     io.puts(header)
     5880000.times{ io.write("\xFF") }
     io.rewind
-    result = Cloudinary::Uploader.upload_large(io, :chunk_size => 5243000, :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload_large(io, :chunk_size => 5243000, :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["resource_type"]).to eq('raw')
     io.rewind
-    result = Cloudinary::Uploader.upload_large(io, :resource_type => 'image', :chunk_size => 5243000, :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload_large(io, :resource_type => 'image', :chunk_size => 5243000, :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["resource_type"]).to eq('image')
     expect(result["width"]).to eq(1400)
     expect(result["height"]).to eq(1400)
@@ -188,12 +221,12 @@ describe Cloudinary::Uploader do
     end
     
     it "should support unsigned uploading using presets", :upload_preset => true do
-      preset = Cloudinary::Api.create_upload_preset(:folder => "test_folder_upload", :unsigned => true, :tags => TEST_TAG)
+      preset = Cloudinary::Api.create_upload_preset(:folder => "test_folder_upload", :unsigned => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
 
       Cloudinary.config.api_key = nil
       Cloudinary.config.api_secret = nil
 
-      result = Cloudinary::Uploader.unsigned_upload(TEST_IMG, preset["name"], :tags => TEST_TAG)
+      result = Cloudinary::Uploader.unsigned_upload(TEST_IMG, preset["name"], :tags => [TEST_TAG, TIMESTAMP_TAG])
       expect(result["public_id"]).to match(/^test_folder_upload\/[a-z0-9]+$/)
 
       Cloudinary.class_variable_set(:@@config, nil)
@@ -211,13 +244,13 @@ describe Cloudinary::Uploader do
     end
 
     it "should fail if timeout is reached" do
-      expect{Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :tags => TEST_TAG)}.to raise_error
+      expect{Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :tags => [TEST_TAG, TIMESTAMP_TAG])}.to raise_error
     end
   end
 
   context ":responsive_breakpoints" do
     context ":create_derived" do
-      result = Cloudinary::Uploader.upload(TEST_IMG, :responsive_breakpoints => { :create_derived => false }, :tags => TEST_TAG)
+      result = Cloudinary::Uploader.upload(TEST_IMG, :responsive_breakpoints => { :create_derived => false }, :tags => [TEST_TAG, TIMESTAMP_TAG])
       it 'should return a responsive_breakpoints in the response' do
         expect(result).to include('responsive_breakpoints')
       end
@@ -228,7 +261,7 @@ describe Cloudinary::Uploader do
     context ":invalidate" do
       it 'should pass the invalidate value to the server' do
         expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :invalidate] => 1))
-        Cloudinary::Uploader.explicit("cloudinary", :type=>"twitter_name", :eager=>[{:crop=>"scale", :width=>"2.0"}], :invalidate => true, :tags => TEST_TAG)
+        Cloudinary::Uploader.explicit("cloudinary", :type=>"twitter_name", :eager=>[{:crop=>"scale", :width=>"2.0"}], :invalidate => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
       end
     end
   end

data/spec/utils_spec.rb

@@ -349,6 +349,18 @@ describe Cloudinary::Utils do
             .and empty_options
   end
 
+  it "should support keyframe_interval" do
+    expect(["test", { :keyframe_interval => 10 }])
+      .to produce_url("#{upload_path}/ki_10/test")
+            .and empty_options
+  end
+
+  it "should support streaming_profile" do
+    expect(["test", { :streaming_profile => "some-profile" }])
+      .to produce_url("#{upload_path}/sp_some-profile/test")
+            .and empty_options
+  end
+
   shared_examples "a signed url" do |specific_options = {}, specific_transformation = ""|
     let(:expected_transformation) do
       (specific_transformation.blank? || specific_transformation.match(/\/$/)) ? specific_transformation : "#{specific_transformation}/"
@@ -361,23 +373,16 @@ describe Cloudinary::Utils do
     let(:options) { { :version => authenticated_image['version'], :sign_url => true, :type => :authenticated }.merge(specific_options) }
     let(:authenticated_path) { "#{root_path}/image/authenticated" }
 
-    it "should not serve resource with the wrong signature" do
-      expect(authenticated_image["url"].sub(/(?:s--)([\w-]+)(?:--)/) { |s| s.succ })
-        .not_to be_served_by_cloudinary
-    end
-
     it "should correctly sign URL with version" do
       expect(["#{authenticated_image['public_id']}.jpg", options])
         .to produce_url(%r"#{authenticated_path}/s--[\w-]+--/#{expected_transformation}v#{authenticated_image['version']}/#{authenticated_image['public_id']}.jpg")
               .and empty_options
-                     .and be_served_by_cloudinary
     end
     it "should correctly sign URL with transformation and version" do
       options[:transformation] = { :crop => "crop", :width => 10, :height => 20 }
       expect(["#{authenticated_image['public_id']}.jpg", options])
         .to produce_url(%r"#{authenticated_path}/s--[\w-]+--/c_crop,h_20,w_10/#{expected_transformation}v#{authenticated_image['version']}/#{authenticated_image['public_id']}.jpg")
               .and empty_options
-                     .and be_served_by_cloudinary
     end
     it "should correctly sign URL with transformation" do
       options[:transformation] = { :crop => "crop", :width => 10, :height => 20 }
@@ -391,7 +396,6 @@ describe Cloudinary::Utils do
       expect(["http://res.cloudinary.com/demo/sample.png", options])
         .to produce_url(%r"^#{root_path}/image/fetch/s--[\w-]+--/#{expected_transformation}v#{authenticated_image['version']}/http://res.cloudinary.com/demo/sample.png$")
               .and empty_options
-                     .and be_served_by_cloudinary
     end
   end
 
@@ -449,7 +453,7 @@ describe Cloudinary::Utils do
 
     include_context "cleanup"
 
-    { 'overlay' => 'l', 'underlay' => 'u' }.each do |param, short|
+    { 'overlay' => 'l' }.each do |param, short| # 'underlay' => 'u' behaves the same as overlay
       describe param do
         let(:root_path) { "http://res.cloudinary.com/#{cloud_name}" }
         # [name, options, result]
@@ -465,9 +469,9 @@ describe Cloudinary::Utils do
         layers_options.each do |name, options, result|
           it "should support #{name}" do
             expect(["sample.jpg", { param => options }]).to produce_url("#{upload_path}/#{short}_#{result}/sample.jpg").and empty_options
-            expect("#{upload_path}/#{short}_#{result}/sample.jpg").to be_served_by_cloudinary
+            # expect("#{upload_path}/#{short}_#{result}/sample.jpg").to be_served_by_cloudinary
           end
-          unless options.is_a? String
+          unless options.is_a? String || param == 'underlay'
             op        = Hash.new
             op[param] = options
             it_behaves_like "a signed url", op, "#{short}_#{result}"