cloudinary 1.0.78 → 1.0.79

data/spec/uploader_spec.rb

@@ -6,41 +6,41 @@ describe Cloudinary::Uploader do
 
   it "should successfully upload file" do
     result = Cloudinary::Uploader.upload("spec/logo.png")    
-    result["width"].should == 241
-    result["height"].should == 51
+    expect(result["width"]).to eq(241)
+    expect(result["height"]).to eq(51)
     expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>result["public_id"], :version=>result["version"]}, Cloudinary.config.api_secret)
-    result["signature"].should == expected_signature
+    expect(result["signature"]).to eq(expected_signature)
   end
   
   it "should successfully upload a file from pathname", :pathname => true do
     result = Cloudinary::Uploader.upload(Pathname.new("spec/logo.png"))
-    result["width"].should == 241
+    expect(result["width"]).to eq(241)
   end
 
   it "should successfully upload file by url" do
     result = Cloudinary::Uploader.upload("http://cloudinary.com/images/logo.png")
-    result["width"].should == 241
-    result["height"].should == 51
+    expect(result["width"]).to eq(241)
+    expect(result["height"]).to eq(51)
     expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>result["public_id"], :version=>result["version"]}, Cloudinary.config.api_secret)
-    result["signature"].should == expected_signature
+    expect(result["signature"]).to eq(expected_signature)
   end
   
   it "should successfully rename a file" do
     result = Cloudinary::Uploader.upload("spec/logo.png")
     Cloudinary::Uploader.rename(result["public_id"], result["public_id"]+"2")
-    Cloudinary::Api.resource(result["public_id"]+"2").should_not be_nil
+    expect(Cloudinary::Api.resource(result["public_id"]+"2")).not_to be_nil
 
     result2 = Cloudinary::Uploader.upload("spec/favicon.ico")
-    lambda{Cloudinary::Uploader.rename(result2["public_id"], result["public_id"]+"2")}.should raise_error
+    expect{Cloudinary::Uploader.rename(result2["public_id"], result["public_id"]+"2")}.to raise_error
     Cloudinary::Uploader.rename(result2["public_id"], result["public_id"]+"2", :overwrite=>true)
 
-    Cloudinary::Api.resource(result["public_id"]+"2")["format"].should == "ico"
+    expect(Cloudinary::Api.resource(result["public_id"]+"2")["format"]).to eq("ico")
   end
 
   it "should support explicit" do
     result = Cloudinary::Uploader.explicit("cloudinary", :type=>"twitter_name", :eager=>[{:crop=>"scale", :width=>"2.0"}])
     url = Cloudinary::Utils.cloudinary_url("cloudinary", :type=>"twitter_name", :crop=>"scale", :width=>"2.0", :format=>"png", :version=>result["version"])
-    result["eager"][0]["url"].should == url
+    expect(result["eager"][0]["url"]).to eq(url)
   end
   
   it "should support eager" do
@@ -54,85 +54,85 @@ describe Cloudinary::Uploader do
 
   it "should successfully generate text image" do
     result = Cloudinary::Uploader.text("hello world")
-    result["width"].should > 1
-    result["height"].should > 1
+    expect(result["width"]).to be > 1
+    expect(result["height"]).to be > 1
   end
 
   it "should correctly handle tags" do
     result = Cloudinary::Uploader.upload("spec/logo.png")
     Cloudinary::Uploader.add_tag("tag1", result["public_id"])
     Cloudinary::Uploader.add_tag("tag2", result["public_id"])
-    Cloudinary::Api.resource(result["public_id"])["tags"].should == ["tag1", "tag2"]
+    expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to eq(["tag1", "tag2"])
     Cloudinary::Uploader.remove_tag("tag1", result["public_id"])
-    Cloudinary::Api.resource(result["public_id"])["tags"].should == ["tag2"]
+    expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to eq(["tag2"])
     Cloudinary::Uploader.replace_tag("tag3", result["public_id"])
-    Cloudinary::Api.resource(result["public_id"])["tags"].should == ["tag3"]
+    expect(Cloudinary::Api.resource(result["public_id"])["tags"]).to eq(["tag3"])
   end
   
   it "should correctly handle unique_filename" do
     result = Cloudinary::Uploader.upload("spec/logo.png", :use_filename => true)
-    result["public_id"].should match(/logo_[a-zA-Z0-9]{6}/)
+    expect(result["public_id"]).to match(/logo_[a-zA-Z0-9]{6}/)
     result = Cloudinary::Uploader.upload("spec/logo.png", :use_filename => true, :unique_filename => false)
-    result["public_id"].should  == "logo"
+    expect(result["public_id"]).to eq("logo")
   end
   
   it "should allow whitelisted formats if allowed_formats", :allowed=>true do
     result = Cloudinary::Uploader.upload("spec/logo.png", :allowed_formats => ["png"])
-    result["format"].should == "png"
+    expect(result["format"]).to eq("png")
   end
   
   it "should prevent non whitelisted formats from being uploaded if allowed_formats is specified", :allowed=>true do
-    lambda{Cloudinary::Uploader.upload("spec/logo.png", :allowed_formats => ["jpg"])}.should raise_error
+    expect{Cloudinary::Uploader.upload("spec/logo.png", :allowed_formats => ["jpg"])}.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("spec/logo.png", :allowed_formats => ["jpg"], :format => "jpg")
-    result["format"].should == "jpg"
+    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("spec/logo.png", {:face_coordinates => coordinates, :faces => true})
-    result["faces"].should == coordinates
+    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"})
     info = Cloudinary::Api.resource(result["public_id"], {:faces => true})
-    info["faces"].should == different_coordinates
+    expect(info["faces"]).to eq(different_coordinates)
   end
   
   it "should allow sending context" do
     context = {"caption" => "some caption", "alt" => "alternative"}
     result = Cloudinary::Uploader.upload("spec/logo.png", {:context => context})
     info = Cloudinary::Api.resource(result["public_id"], {:context => true})
-    info["context"].should == {"custom" => context}
+    expect(info["context"]).to eq({"custom" => context})
   end
   
   it "should support requesting manual moderation" do
     result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
-    result["moderation"][0]["status"].should == "pending"
-    result["moderation"][0]["kind"].should == "manual"
+    expect(result["moderation"][0]["status"]).to eq("pending")
+    expect(result["moderation"][0]["kind"]).to eq("manual")
   end
     
   it "should support requesting raw conversion" do
-    lambda{Cloudinary::Uploader.upload("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal})}.should raise_error(CloudinaryException, /Illegal value|not a valid/)
+    expect{Cloudinary::Uploader.upload("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
   end
   
   it "should support requesting categorization" do
-    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:categorization => :illegal})}.should raise_error(CloudinaryException, /Illegal value|not a valid/)
+    expect{Cloudinary::Uploader.upload("spec/logo.png", {:categorization => :illegal})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
   end
   
   it "should support requesting detection" do
-    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:detection => :illegal})}.should raise_error(CloudinaryException, /Illegal value|not a valid/)
+    expect{Cloudinary::Uploader.upload("spec/logo.png", {:detection => :illegal})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
   end
   
   it "should support requesting auto_tagging" do
-    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:auto_tagging => 0.5})}.should raise_error(CloudinaryException, /Must use/)
+    expect{Cloudinary::Uploader.upload("spec/logo.png", {:auto_tagging => 0.5})}.to raise_error(CloudinaryException, /Must use/)
   end
 
   it "should support upload_large" do
     result = Cloudinary::Uploader.upload_large("spec/logo.png")
-    result["public_id"].should match(/^[a-z0-9]+.png$/)
+    expect(result["public_id"]).to match(/^[a-z0-9]+.png$/)
   end
   
   context "unsigned" do
@@ -141,13 +141,13 @@ describe Cloudinary::Uploader do
     end
     
     it "should support unsigned uploading using presets", :upload_preset => true do
-      preset = Cloudinary::Api.create_upload_preset(:folder => "upload_folder", :unsigned => true)
+      preset = Cloudinary::Api.create_upload_preset(:folder => "test_folder_upload", :unsigned => true)
 
       Cloudinary.config.api_key = nil
       Cloudinary.config.api_secret = nil
 
       result = Cloudinary::Uploader.unsigned_upload("spec/logo.png", preset["name"])
-      result["public_id"].should match(/^upload_folder\/[a-z0-9]+$/)
+      expect(result["public_id"]).to match(/^test_folder_upload\/[a-z0-9]+$/)
 
       Cloudinary.class_variable_set(:@@config, nil)
 

data/spec/utils_spec.rb

@@ -16,415 +16,319 @@ describe Cloudinary::Utils do
     end
   end
   
+  def test_cloudinary_url(public_id, options, expected_url, expected_options)
+    url = Cloudinary::Utils.cloudinary_url(public_id, options)
+    expect(url).to eq(expected_url)
+    expect(options).to eq(expected_options)
+    url
+  end
+
   it "should use cloud_name from config" do    
-    result = Cloudinary::Utils.cloudinary_url("test")
-    result.should == "http://res.cloudinary.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {}, "http://res.cloudinary.com/test123/image/upload/test", {})
   end
 
   it "should allow overriding cloud_name in options" do
-    options = {:cloud_name=>"test321"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test321/image/upload/test" 
+    test_cloudinary_url("test", {:cloud_name=>"test321"}, "http://res.cloudinary.com/test321/image/upload/test", {})
   end
   
   it "should use default secure distribution if secure=true" do    
-    options = {:secure=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://res.cloudinary.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:secure=>true}, "https://res.cloudinary.com/test123/image/upload/test", {})
   end
 
   it "should allow overriding secure distribution if secure=true" do    
-    options = {:secure=>true, :secure_distribution=>"something.else.com"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://something.else.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:secure=>true, :secure_distribution=>"something.else.com"}, "https://something.else.com/test123/image/upload/test", {})
   end
 
   it "should take secure distribution from config if secure=true" do
-    Cloudinary.config.secure_distribution = "config.secure.distribution.com"    
-    options = {:secure=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://config.secure.distribution.com/test123/image/upload/test" 
+    Cloudinary.config.secure_distribution = "config.secure.distribution.com"
+    test_cloudinary_url("test", {:secure=>true}, "https://config.secure.distribution.com/test123/image/upload/test", {})
   end
 
   it "should default to akamai if secure is given with private_cdn and no secure_distribution" do
-    options = {:secure=>true, :private_cdn=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://test123-res.cloudinary.com/image/upload/test" 
+    test_cloudinary_url("test", {:secure=>true, :private_cdn=>true}, "https://test123-res.cloudinary.com/image/upload/test", {})
   end
 
   it "should not add cloud_name if secure private_cdn and secure non akamai secure_distribution" do
-    options = {:secure=>true, :private_cdn=>true, :secure_distribution=>"something.cloudfront.net"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://something.cloudfront.net/image/upload/test" 
+    test_cloudinary_url("test", {:secure=>true, :private_cdn=>true, :secure_distribution=>"something.cloudfront.net"}, "https://something.cloudfront.net/image/upload/test", {})
   end
 
   it "should allow overriding private_cdn if private_cdn=true" do
-    result = Cloudinary::Utils.cloudinary_url("test", :private_cdn => true)
-    result.should == "http://test123-res.cloudinary.com/image/upload/test"
+    test_cloudinary_url("test", {:private_cdn => true}, "http://test123-res.cloudinary.com/image/upload/test", {})
   end
 
   it "should allow overriding private_cdn if private_cdn=false" do
     Cloudinary.config.private_cdn = true
-    result = Cloudinary::Utils.cloudinary_url("test", :private_cdn => false)
-    result.should == "http://res.cloudinary.com/test123/image/upload/test"
+    test_cloudinary_url("test", {:private_cdn => false}, "http://res.cloudinary.com/test123/image/upload/test", {})
   end
 
   it "should allow overriding cname if cname=example.com" do
-    result = Cloudinary::Utils.cloudinary_url("test", :cname => "example.com")
-    result.should == "http://example.com/test123/image/upload/test"
+    test_cloudinary_url("test", {:cname => "example.com"}, "http://example.com/test123/image/upload/test", {})
   end
 
   it "should allow overriding cname if cname=false" do
     Cloudinary.config.cname = "example.com"
-    result = Cloudinary::Utils.cloudinary_url("test", :cname => nil)
-    result.should == "http://res.cloudinary.com/test123/image/upload/test"
+    test_cloudinary_url("test", {:cname => nil}, "http://res.cloudinary.com/test123/image/upload/test", {})
   end
 
   it "should use format from options" do    
-    options = {:format=>:jpg}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/test.jpg" 
+    test_cloudinary_url("test", {:format=>:jpg}, "http://res.cloudinary.com/test123/image/upload/test.jpg", {})
+  end
+
+  it "should disallow url_suffix in shared distribution" do
+    expect{Cloudinary::Utils.cloudinary_url("test", {:url_suffix=>"hello"})}.to raise_error(CloudinaryException)
+  end
+
+  it "should disallow url_suffix in non upload types" do
+    expect{Cloudinary::Utils.cloudinary_url("test", {:url_suffix=>"hello", :private_cdn=>true, :type=>:facebook})}.to raise_error(CloudinaryException)
+  end
+
+  it "should disallow url_suffix with / or ." do
+    expect{Cloudinary::Utils.cloudinary_url("test", {:url_suffix=>"hello/world", :private_cdn=>true})}.to raise_error(CloudinaryException)
+    expect{Cloudinary::Utils.cloudinary_url("test", {:url_suffix=>"hello.world", :private_cdn=>true})}.to raise_error(CloudinaryException)
+  end
+
+  it "should support url_suffix for private_cdn" do    
+    test_cloudinary_url("test", {:url_suffix=>"hello", :private_cdn=>true}, "http://test123-res.cloudinary.com/images/test/hello", {})
+    test_cloudinary_url("test", {:url_suffix=>"hello", :angle=>0, :private_cdn=>true}, "http://test123-res.cloudinary.com/images/a_0/test/hello", {})
+  end
+
+  it "should put format after url_suffix" do
+    test_cloudinary_url("test", {:url_suffix=>"hello", :private_cdn=>true, :format=>"jpg"}, "http://test123-res.cloudinary.com/images/test/hello.jpg", {})
+  end
+
+  it "should not sign the url_suffix" do
+    expected_signture = Cloudinary::Utils.cloudinary_url("test", :format=>"jpg", :sign_url=>true).match(/s--[0-9A-Za-z_-]{8}--/).to_s
+    test_cloudinary_url("test", {:url_suffix=>"hello", :private_cdn=>true, :format=>"jpg", :sign_url=>true}, "http://test123-res.cloudinary.com/images/#{expected_signture}/test/hello.jpg", {})
+
+    expected_signture = Cloudinary::Utils.cloudinary_url("test", :format=>"jpg", :angle=>0, :sign_url=>true).match(/s--[0-9A-Za-z_-]{8}--/).to_s
+    test_cloudinary_url("test", {:url_suffix=>"hello", :private_cdn=>true, :format=>"jpg", :angle=>0, :sign_url=>true}, "http://test123-res.cloudinary.com/images/#{expected_signture}/a_0/test/hello.jpg", {})
+  end
+
+  it "should support url_suffix for raw uploads" do    
+    test_cloudinary_url("test", {:url_suffix=>"hello", :private_cdn=>true, :resource_type=>:raw}, "http://test123-res.cloudinary.com/files/test/hello", {})
+  end
+
+  it "should disllow use_root_path in shared distribution" do
+    expect{Cloudinary::Utils.cloudinary_url("test", {:use_root_path=>true})}.to raise_error(CloudinaryException)
+  end
+
+  it "should support use_root_path for private_cdn" do
+    test_cloudinary_url("test", {:use_root_path=>true, :private_cdn=>true}, "http://test123-res.cloudinary.com/test", {})
+    test_cloudinary_url("test", {:use_root_path=>true, :private_cdn=>true, :angle=>0}, "http://test123-res.cloudinary.com/a_0/test", {})
+  end
+
+  it "should support use_root_path together with url_suffix for private_cdn" do
+    test_cloudinary_url("test", {:use_root_path=>true, :url_suffix=>"hello", :private_cdn=>true}, "http://test123-res.cloudinary.com/test/hello", {})
+  end
+
+  it "should disllow use_root_path if not image/upload" do
+    expect{Cloudinary::Utils.cloudinary_url("test", {:use_root_path=>true, :private_cdn=>true, :type=>:facebook})}.to raise_error(CloudinaryException)
+    expect{Cloudinary::Utils.cloudinary_url("test", {:use_root_path=>true, :private_cdn=>true, :resource_type=>:raw})}.to raise_error(CloudinaryException)
   end
 
   it "should use width and height from options only if crop is given" do
-    options = {:width=>100, :height=>100}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    result.should == "http://res.cloudinary.com/test123/image/upload/test" 
-    options.should == {:width=>100, :height=>100}
-    options = {:width=>100, :height=>100, :crop=>:crop}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {:width=>100, :height=>100}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_crop,h_100,w_100/test" 
+    test_cloudinary_url("test", {:width=>100, :height=>100}, "http://res.cloudinary.com/test123/image/upload/test", {:width=>100, :height=>100})
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:crop}, "http://res.cloudinary.com/test123/image/upload/c_crop,h_100,w_100/test", {:width=>100, :height=>100})
   end
 
   it "should not pass width and height to html in case of fit, lfill or limit crop" do
-    options = {:width=>100, :height=>100, :crop=>:limit}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_limit,h_100,w_100/test" 
-    options = {:width=>100, :height=>100, :crop=>:lfill}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_lfill,h_100,w_100/test" 
-    options = {:width=>100, :height=>100, :crop=>:fit}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_fit,h_100,w_100/test" 
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:limit}, "http://res.cloudinary.com/test123/image/upload/c_limit,h_100,w_100/test", {})
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:lfill}, "http://res.cloudinary.com/test123/image/upload/c_lfill,h_100,w_100/test", {})
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:fit}, "http://res.cloudinary.com/test123/image/upload/c_fit,h_100,w_100/test", {})
   end
 
   it "should not pass width and height to html in case angle was used" do
-    options = {:width=>100, :height=>100, :crop=>:scale, :angle=>:auto}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/a_auto,c_scale,h_100,w_100/test" 
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:scale, :angle=>:auto}, "http://res.cloudinary.com/test123/image/upload/a_auto,c_scale,h_100,w_100/test", {})
   end
     
   it "should use x, y, radius, prefix, gravity and quality from options" do    
-    options = {:x=>1, :y=>2, :radius=>3, :gravity=>:center, :quality=>0.4, :prefix=>"a"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/g_center,p_a,q_0.4,r_3,x_1,y_2/test" 
+    test_cloudinary_url("test", {:x=>1, :y=>2, :radius=>3, :gravity=>:center, :quality=>0.4, :prefix=>"a"}, "http://res.cloudinary.com/test123/image/upload/g_center,p_a,q_0.4,r_3,x_1,y_2/test", {})
   end
   
   it "should support named tranformation" do    
-    options = {:transformation=>"blip"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/t_blip/test" 
+    test_cloudinary_url("test", {:transformation=>"blip"}, "http://res.cloudinary.com/test123/image/upload/t_blip/test", {})
   end
 
   it "should support array of named tranformations" do    
-    options = {:transformation=>["blip", "blop"]}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/t_blip.blop/test" 
+    test_cloudinary_url("test", {:transformation=>["blip", "blop"]}, "http://res.cloudinary.com/test123/image/upload/t_blip.blop/test", {})
   end
 
   it "should support base tranformation" do    
-    options = {:transformation=>{:x=>100, :y=>100, :crop=>:fill}, :crop=>:crop, :width=>100}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {:width=>100}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_fill,x_100,y_100/c_crop,w_100/test" 
+    test_cloudinary_url("test", {:transformation=>{:x=>100, :y=>100, :crop=>:fill}, :crop=>:crop, :width=>100}, "http://res.cloudinary.com/test123/image/upload/c_fill,x_100,y_100/c_crop,w_100/test", {:width=>100})
   end
 
   it "should support array of base tranformations" do    
-    options = {:transformation=>[{:x=>100, :y=>100, :width=>200, :crop=>:fill}, {:radius=>10}], :crop=>:crop, :width=>100}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {:width=>100}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_fill,w_200,x_100,y_100/r_10/c_crop,w_100/test" 
+    test_cloudinary_url("test", {:transformation=>[{:x=>100, :y=>100, :width=>200, :crop=>:fill}, {:radius=>10}], :crop=>:crop, :width=>100}, "http://res.cloudinary.com/test123/image/upload/c_fill,w_200,x_100,y_100/r_10/c_crop,w_100/test", {:width=>100})
   end
 
   it "should support array of tranformations" do    
-    options = [{:x=>100, :y=>100, :width=>200, :crop=>:fill}, {:radius=>10}]
-    result = Cloudinary::Utils.generate_transformation_string(options)
-    result.should == "c_fill,w_200,x_100,y_100/r_10" 
+    result = Cloudinary::Utils.generate_transformation_string([{:x=>100, :y=>100, :width=>200, :crop=>:fill}, {:radius=>10}])
+    expect(result).to eq("c_fill,w_200,x_100,y_100/r_10")
   end
 
   it "should not include empty tranformations" do    
-    options = {:transformation=>[{}, {:x=>100, :y=>100, :crop=>:fill}, {}]}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_fill,x_100,y_100/test" 
+    test_cloudinary_url("test", {:transformation=>[{}, {:x=>100, :y=>100, :crop=>:fill}, {}]}, "http://res.cloudinary.com/test123/image/upload/c_fill,x_100,y_100/test", {})
   end
 
   it "should support size" do    
-    options = {:size=>"10x10", :crop=>:crop}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {:width=>"10", :height=>"10"}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_crop,h_10,w_10/test" 
+    test_cloudinary_url("test", {:size=>"10x10", :crop=>:crop}, "http://res.cloudinary.com/test123/image/upload/c_crop,h_10,w_10/test", {:width=>"10", :height=>"10"})
   end
 
   it "should use type from options" do
-    options = {:type=>:facebook}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/facebook/test" 
+    test_cloudinary_url("test", {:type=>:facebook}, "http://res.cloudinary.com/test123/image/facebook/test", {})
   end
 
   it "should use resource_type from options" do
-    options = {:resource_type=>:raw}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/raw/upload/test" 
+    test_cloudinary_url("test", {:resource_type=>:raw}, "http://res.cloudinary.com/test123/raw/upload/test", {})
   end
 
   it "should ignore http links only if type is not given or is asset" do
-    options = {:type=>nil}
-    result = Cloudinary::Utils.cloudinary_url("http://test", options)
-    options.should == {}
-    result.should == "http://test" 
-    options = {:type=>:asset}
-    result = Cloudinary::Utils.cloudinary_url("http://test", options)
-    options.should == {}
-    result.should == "http://test" 
-    options = {:type=>:fetch}
-    result = Cloudinary::Utils.cloudinary_url("http://test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/fetch/http://test" 
+    test_cloudinary_url("http://test", {:type=>nil}, "http://test", {})
+    test_cloudinary_url("http://test", {:type=>:asset}, "http://test", {})
+    test_cloudinary_url("http://test", {:type=>:fetch}, "http://res.cloudinary.com/test123/image/fetch/http://test" , {})
   end
 
   it "should use allow absolute links to /images" do
-    options = {}
-    result = Cloudinary::Utils.cloudinary_url("/images/test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/test" 
+    test_cloudinary_url("/images/test", {}, "http://res.cloudinary.com/test123/image/upload/test", {})
   end 
 
   it "should use ignore absolute links not to /images" do
-    options = {}
-    result = Cloudinary::Utils.cloudinary_url("/js/test", options)
-    options.should == {}
-    result.should == "/js/test" 
+    test_cloudinary_url("/js/test", {}, "/js/test", {})
   end 
 
   it "should escape fetch urls" do
-    options = {:type=>:fetch}
-    result = Cloudinary::Utils.cloudinary_url("http://blah.com/hello?a=b", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/fetch/http://blah.com/hello%3Fa%3Db" 
+    test_cloudinary_url("http://blah.com/hello?a=b", {:type=>:fetch}, "http://res.cloudinary.com/test123/image/fetch/http://blah.com/hello%3Fa%3Db", {})
   end 
 
   it "should should escape http urls" do
-    options = {:type=>:youtube}
-    result = Cloudinary::Utils.cloudinary_url("http://www.youtube.com/watch?v=d9NF2edxy-M", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/youtube/http://www.youtube.com/watch%3Fv%3Dd9NF2edxy-M" 
+    test_cloudinary_url("http://www.youtube.com/watch?v=d9NF2edxy-M", {:type=>:youtube}, "http://res.cloudinary.com/test123/image/youtube/http://www.youtube.com/watch%3Fv%3Dd9NF2edxy-M", {})
   end 
 
   it "should support background" do
-    options = {:background=>"red"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/b_red/test" 
-    options = {:background=>"#112233"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/b_rgb:112233/test" 
+    test_cloudinary_url("test", {:background=>"red"}, "http://res.cloudinary.com/test123/image/upload/b_red/test", {})
+    test_cloudinary_url("test", {:background=>"#112233"}, "http://res.cloudinary.com/test123/image/upload/b_rgb:112233/test", {})
   end
   
   it "should support default_image" do
-    options = {:default_image=>"default"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/d_default/test" 
+    test_cloudinary_url("test", {:default_image=>"default"}, "http://res.cloudinary.com/test123/image/upload/d_default/test", {})
   end
 
   it "should support angle" do
-    options = {:angle=>"55"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/a_55/test" 
-
-    options = {:angle=>["auto", "55"]}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/a_auto.55/test" 
+    test_cloudinary_url("test", {:angle=>"55"}, "http://res.cloudinary.com/test123/image/upload/a_55/test", {})
+    test_cloudinary_url("test", {:angle=>["auto", "55"]}, "http://res.cloudinary.com/test123/image/upload/a_auto.55/test", {})
   end
   
   it "should support format for fetch urls" do
-    options = {:format=>"jpg", :type=>:fetch}
-    result = Cloudinary::Utils.cloudinary_url("http://cloudinary.com/images/logo.png", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/fetch/f_jpg/http://cloudinary.com/images/logo.png" 
+    test_cloudinary_url("http://cloudinary.com/images/logo.png", {:format=>"jpg", :type=>:fetch}, "http://res.cloudinary.com/test123/image/fetch/f_jpg/http://cloudinary.com/images/logo.png", {})
   end
   
   it "should support effect" do
-    options = {:effect=>"sepia"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/e_sepia/test" 
+    test_cloudinary_url("test", {:effect=>"sepia"}, "http://res.cloudinary.com/test123/image/upload/e_sepia/test", {})
   end
 
   it "should support effect with hash param" do
-    options = {:effect=>{"sepia"=>10}}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/e_sepia:10/test" 
+    test_cloudinary_url("test", {:effect=>{"sepia"=>10}}, "http://res.cloudinary.com/test123/image/upload/e_sepia:10/test", {})
   end
 
   it "should support effect with array param" do
-    options = {:effect=>["sepia", 10]}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/e_sepia:10/test" 
+    test_cloudinary_url("test", {:effect=>["sepia", 10]}, "http://res.cloudinary.com/test123/image/upload/e_sepia:10/test", {}) 
   end
 
   {:overlay=>:l, :underlay=>:u}.each do |param, letter|
     it "should support #{param}" do
-      options = {param=>"text:hello"}
-      result = Cloudinary::Utils.cloudinary_url("test", options)
-      options.should == {}
-      result.should == "http://res.cloudinary.com/test123/image/upload/#{letter}_text:hello/test" 
+      test_cloudinary_url("test", {param=>"text:hello"}, "http://res.cloudinary.com/test123/image/upload/#{letter}_text:hello/test", {})
     end
     
     it "should not pass width/height to html for #{param}" do
-      options = {param=>"text:hello", :height=>100, :width=>100}
-      result = Cloudinary::Utils.cloudinary_url("test", options)
-      options.should == {}
-      result.should == "http://res.cloudinary.com/test123/image/upload/h_100,#{letter}_text:hello,w_100/test" 
+      test_cloudinary_url("test", {param=>"text:hello", :height=>100, :width=>100}, "http://res.cloudinary.com/test123/image/upload/h_100,#{letter}_text:hello,w_100/test", {})
     end
   end
 
   it "should use ssl_detected if secure is not given as parameter and not set to true in configuration" do    
-    options = {:ssl_detected=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://res.cloudinary.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:ssl_detected=>true}, "https://res.cloudinary.com/test123/image/upload/test", {})
   end 
 
   it "should use secure if given over ssl_detected and configuration" do    
-    options = {:ssl_detected=>true, :secure=>false}
     Cloudinary.config.secure = true
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:ssl_detected=>true, :secure=>false}, "http://res.cloudinary.com/test123/image/upload/test", {})
   end 
 
   it "should use secure: true from configuration over ssl_detected" do    
-    options = {:ssl_detected=>false}
     Cloudinary.config.secure = true
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "https://res.cloudinary.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:ssl_detected=>false}, "https://res.cloudinary.com/test123/image/upload/test", {})
   end 
 
   it "should support extenal cname" do
-    options = {:cname=>"hello.com"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://hello.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:cname=>"hello.com"}, "http://hello.com/test123/image/upload/test", {})
   end
 
   it "should support extenal cname with cdn_subdomain on" do
-    options = {:cname=>"hello.com", :cdn_subdomain=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://a2.hello.com/test123/image/upload/test" 
+    test_cloudinary_url("test", {:cname=>"hello.com", :cdn_subdomain=>true}, "http://a2.hello.com/test123/image/upload/test", {})
   end
   
+  it "should support cdn_subdomain with secure on if using shared_domain" do
+    test_cloudinary_url("test", {:secure=>true, :cdn_subdomain=>true}, "https://res-2.cloudinary.com/test123/image/upload/test", {})
+  end
+
+  it "should support secure_cdn_subdomain false override with secure" do
+    test_cloudinary_url("test", {:secure=>true, :cdn_subdomain=>true, :secure_cdn_subdomain=>false}, "https://res.cloudinary.com/test123/image/upload/test", {})
+  end
+
+  it "should support secure_cdn_subdomain true override with secure" do
+    test_cloudinary_url("test", {:secure=>true, :cdn_subdomain=>true, :secure_cdn_subdomain=>true, :private_cdn=>true}, "https://test123-res-2.cloudinary.com/image/upload/test", {})
+  end
+
   it "should support string param" do
-    options = {"effect"=>{"sepia"=>10}}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/e_sepia:10/test" 
+    test_cloudinary_url("test", {"effect"=>{"sepia"=>10}}, "http://res.cloudinary.com/test123/image/upload/e_sepia:10/test", {})
   end
   
   it "should support border" do
-    options = {"border"=>{:width=>5}}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/bo_5px_solid_black/test"     
-    options = {"border"=>{:width=>5, :color=>"#ffaabbdd"}}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/bo_5px_solid_rgb:ffaabbdd/test"     
-    options = {"border"=>"1px_solid_blue"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/bo_1px_solid_blue/test"     
-    options = {"border"=>"2"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {:border=>"2"}
-    result.should == "http://res.cloudinary.com/test123/image/upload/test"     
+    test_cloudinary_url("test", {"border"=>{:width=>5}}, "http://res.cloudinary.com/test123/image/upload/bo_5px_solid_black/test", {})
+    test_cloudinary_url("test", {"border"=>{:width=>5, :color=>"#ffaabbdd"}}, "http://res.cloudinary.com/test123/image/upload/bo_5px_solid_rgb:ffaabbdd/test", {})
+    test_cloudinary_url("test", {"border"=>"1px_solid_blue"}, "http://res.cloudinary.com/test123/image/upload/bo_1px_solid_blue/test", {})
+    test_cloudinary_url("test", {"border"=>"2"}, "http://res.cloudinary.com/test123/image/upload/test", {:border=>"2"})
   end
   
   it "should support flags" do
-    options = {"flags"=>"abc"}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/fl_abc/test"     
-    options = {"flags"=>["abc", "def"]}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {}
-    result.should == "http://res.cloudinary.com/test123/image/upload/fl_abc.def/test"     
+    test_cloudinary_url("test", {"flags"=>"abc"}, "http://res.cloudinary.com/test123/image/upload/fl_abc/test", {})
+    test_cloudinary_url("test", {"flags"=>["abc", "def"]}, "http://res.cloudinary.com/test123/image/upload/fl_abc.def/test", {})
   end
 
   it "build_upload_params should not destroy options" do
     options = {:width=>100, :crop=>:scale}
-    Cloudinary::Uploader.build_upload_params(options)[:transformation].should == "c_scale,w_100"
-    options.length.should == 2
+    expect(Cloudinary::Uploader.build_upload_params(options)[:transformation]).to eq("c_scale,w_100")
+    expect(options.length).to eq(2)
   end
 
   it "build_upload_params canonize booleans" do
     options = {:backup=>true, :use_filename=>false, :colors=>"true", :exif=>"false", :colors=>:true, 
                :image_metadata=>:false, :invalidate=>1, :eager_async=>"1"}
     params = Cloudinary::Uploader.build_upload_params(options)
-    Cloudinary::Api.only(params, *options.keys).should == {
+    expect(Cloudinary::Api.only(params, *options.keys)).to eq(
       :backup=>1, :use_filename=>0, :colors=>1, :exif=>0, :colors=>1, 
                :image_metadata=>0, :invalidate=>1, :eager_async=>1
-    }
-    Cloudinary::Uploader.build_upload_params(:backup=>nil)[:backup].should be_nil
-    Cloudinary::Uploader.build_upload_params({})[:backup].should be_nil
+    )
+    expect(Cloudinary::Uploader.build_upload_params(:backup=>nil)[:backup]).to be_nil
+    expect(Cloudinary::Uploader.build_upload_params({})[:backup]).to be_nil
   end
   
   it "should add version if public_id contains /" do
-    result = Cloudinary::Utils.cloudinary_url("folder/test")
-    result.should == "http://res.cloudinary.com/test123/image/upload/v1/folder/test"         
-    result = Cloudinary::Utils.cloudinary_url("folder/test", :version=>123)
-    result.should == "http://res.cloudinary.com/test123/image/upload/v123/folder/test"         
+    test_cloudinary_url("folder/test", {}, "http://res.cloudinary.com/test123/image/upload/v1/folder/test", {})
+    test_cloudinary_url("folder/test", {:version=>123}, "http://res.cloudinary.com/test123/image/upload/v123/folder/test", {})
   end
 
   it "should not add version if public_id contains version already" do
-    result = Cloudinary::Utils.cloudinary_url("v1234/test")
-    result.should == "http://res.cloudinary.com/test123/image/upload/v1234/test"         
+    test_cloudinary_url("v1234/test", {}, "http://res.cloudinary.com/test123/image/upload/v1234/test", {})
   end
 
   it "should allow to shorted image/upload urls" do
-    result = Cloudinary::Utils.cloudinary_url("test", :shorten=>true)
-    result.should == "http://res.cloudinary.com/test123/iu/test"         
+    test_cloudinary_url("test", {:shorten=>true}, "http://res.cloudinary.com/test123/iu/test", {})
   end
   
   it "should allow to use folders in PreloadedFile" do
     signature = Cloudinary::Utils.api_sign_request({:public_id=>"folder/file", :version=>"1234"}, Cloudinary.config.api_secret)
     preloaded = Cloudinary::PreloadedFile.new("image/upload/v1234/folder/file.jpg#" + signature)
-    preloaded.should be_valid
+    expect(preloaded).to be_valid
   end
   
   it "should escape public_ids" do
@@ -437,50 +341,38 @@ describe Cloudinary::Utils do
       ["parentheses(interject)", "parentheses%28interject%29"]
     ].each do
       |source, target|
-      Cloudinary::Utils.cloudinary_url(source).should == "http://res.cloudinary.com/test123/image/upload/#{target}"   
+      expect(Cloudinary::Utils.cloudinary_url(source)).to eq("http://res.cloudinary.com/test123/image/upload/#{target}")
     end      
   end
   
   it "should correctly sign URLs", :signed => true do
-    options = {:version => 1234, :transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true}
-    expected = "http://res.cloudinary.com/test123/image/upload/s--MaRXzoEC--/c_crop,h_20,w_10/v1234/image.jpg"
-    actual = Cloudinary::Utils.cloudinary_url("image.jpg", options)
-    actual.should == expected
-    
-    options = {:version => 1234, :sign_url => true}
-    expected = "http://res.cloudinary.com/test123/image/upload/s--ZlgFLQcO--/v1234/image.jpg"
-    actual = Cloudinary::Utils.cloudinary_url("image.jpg", options)
-    actual.should == expected
-    
-    options = {:transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true}
-    expected = "http://res.cloudinary.com/test123/image/upload/s--Ai4Znfl3--/c_crop,h_20,w_10/image.jpg"
-    actual = Cloudinary::Utils.cloudinary_url("image.jpg", options)
-    actual.should == expected
-    
-    expected = "http://res.cloudinary.com/test123/image/fetch/s--_GAUclyB--/v1234/http://google.com/path/to/image.png"
-    actual = Cloudinary::Utils.cloudinary_url("http://google.com/path/to/image.png", :type => "fetch", :version => 1234, :sign_url => true)
-    actual.should == expected    
+    test_cloudinary_url("image.jpg", {:version => 1234, :transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true}, "http://res.cloudinary.com/test123/image/upload/s--Ai4Znfl3--/c_crop,h_20,w_10/v1234/image.jpg", {})
+    test_cloudinary_url("image.jpg", {:version => 1234, :sign_url => true}, "http://res.cloudinary.com/test123/image/upload/s----SjmNDA--/v1234/image.jpg", {})
+    test_cloudinary_url("image.jpg", {:transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true}, "http://res.cloudinary.com/test123/image/upload/s--Ai4Znfl3--/c_crop,h_20,w_10/image.jpg", {})
+    test_cloudinary_url("image.jpg", {:transformation => {:crop => "crop", :width => 10, :height => 20}, :type => :authenticated, :sign_url => true}, "http://res.cloudinary.com/test123/image/authenticated/s--Ai4Znfl3--/c_crop,h_20,w_10/image.jpg", {})
+    test_cloudinary_url("http://google.com/path/to/image.png", {:type => "fetch", :version => 1234, :sign_url => true}, "http://res.cloudinary.com/test123/image/fetch/s--hH_YcbiS--/v1234/http://google.com/path/to/image.png", {})
+  end
+
+  it "should correctly sign URLs in deprecated sign_version mode", :signed => true do
+    test_cloudinary_url("image.jpg", {:version => 1234, :transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true, :sign_version => true}, "http://res.cloudinary.com/test123/image/upload/s--MaRXzoEC--/c_crop,h_20,w_10/v1234/image.jpg", {})
+    test_cloudinary_url("image.jpg", {:version => 1234, :sign_url => true, :sign_version => true}, "http://res.cloudinary.com/test123/image/upload/s--ZlgFLQcO--/v1234/image.jpg", {})
+    test_cloudinary_url("image.jpg", {:transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true, :sign_version => true}, "http://res.cloudinary.com/test123/image/upload/s--Ai4Znfl3--/c_crop,h_20,w_10/image.jpg", {})
+    test_cloudinary_url("http://google.com/path/to/image.png", {:type => "fetch", :version => 1234, :sign_url => true, :sign_version => true}, "http://res.cloudinary.com/test123/image/fetch/s--_GAUclyB--/v1234/http://google.com/path/to/image.png", {})
   end
   
   it "should correctly sign_request" do
     params = Cloudinary::Utils.sign_request({:public_id=>"folder/file", :version=>"1234"})
-    params.should == {:public_id=>"folder/file", :version=>"1234", :signature=>"7a3349cbb373e4812118d625047ede50b90e7b67", :api_key=>"1234"}
+    expect(params).to eq(:public_id=>"folder/file", :version=>"1234", :signature=>"7a3349cbb373e4812118d625047ede50b90e7b67", :api_key=>"1234")
   end
 
   it "should support responsive width" do
-    options = {:width=>100, :height=>100, :crop=>:crop, :responsive_width=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {responsive: true}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_crop,h_100,w_100/c_limit,w_auto/test" 
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:crop, :responsive_width=>true}, "http://res.cloudinary.com/test123/image/upload/c_crop,h_100,w_100/c_limit,w_auto/test", {responsive: true})
     Cloudinary.config.responsive_width_transformation = {:width => :auto, :crop => :pad}
-    options = {:width=>100, :height=>100, :crop=>:crop, :responsive_width=>true}
-    result = Cloudinary::Utils.cloudinary_url("test", options)
-    options.should == {responsive: true}
-    result.should == "http://res.cloudinary.com/test123/image/upload/c_crop,h_100,w_100/c_pad,w_auto/test"     
+    test_cloudinary_url("test", {:width=>100, :height=>100, :crop=>:crop, :responsive_width=>true}, "http://res.cloudinary.com/test123/image/upload/c_crop,h_100,w_100/c_pad,w_auto/test", {responsive: true})
   end
 
   it "should correctly encode double arrays" do
-    Cloudinary::Utils.encode_double_array([1,2,3,4]).should == "1,2,3,4"
-    Cloudinary::Utils.encode_double_array([[1,2,3,4],[5,6,7,8]]).should == "1,2,3,4|5,6,7,8"
+    expect(Cloudinary::Utils.encode_double_array([1,2,3,4])).to eq("1,2,3,4")
+    expect(Cloudinary::Utils.encode_double_array([[1,2,3,4],[5,6,7,8]])).to eq("1,2,3,4|5,6,7,8")
   end
 end