cloudinary 1.1.1 → 1.1.2

data/lib/cloudinary/utils.rb

@@ -3,6 +3,8 @@ require 'digest/sha1'
 require 'zlib'
 require 'uri'
 require 'aws_cf_signer'
+require 'json'
+require 'cgi'
 
 class Cloudinary::Utils
   # @deprecated Use Cloudinary::SHARED_CDN
@@ -10,9 +12,9 @@ class Cloudinary::Utils
   DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION = {:width => :auto, :crop => :limit}
 
   # Warning: options are being destructively updated!
-  def self.generate_transformation_string(options={})
+  def self.generate_transformation_string(options={}, allow_implicit_crop_mode = false)
     if options.is_a?(Array)
-      return options.map{|base_transformation| generate_transformation_string(base_transformation.clone)}.join("/")
+      return options.map{|base_transformation| generate_transformation_string(base_transformation.clone, allow_implicit_crop_mode)}.join("/")
     end
 
     symbolize_keys!(options)
@@ -32,7 +34,7 @@ class Cloudinary::Utils
     options.delete(:width) if width && (width.to_f < 1 || no_html_sizes || width == "auto" || responsive_width)
     options.delete(:height) if height && (height.to_f < 1 || no_html_sizes || responsive_width)
 
-    width=height=nil if crop.nil? && !has_layer && width != "auto"
+    width=height=nil if crop.nil? && !has_layer && width != "auto" && !allow_implicit_crop_mode
 
     background = options.delete(:background)
     background = background.sub(/^#/, 'rgb:') if background
@@ -44,7 +46,7 @@ class Cloudinary::Utils
     if base_transformations.any?{|base_transformation| base_transformation.is_a?(Hash)}
       base_transformations = base_transformations.map do
         |base_transformation|
-        base_transformation.is_a?(Hash) ? generate_transformation_string(base_transformation.clone) : generate_transformation_string(:transformation=>base_transformation)
+        base_transformation.is_a?(Hash) ? generate_transformation_string(base_transformation.clone, allow_implicit_crop_mode) : generate_transformation_string({:transformation=>base_transformation}, allow_implicit_crop_mode)
       end
     else
       named_transformation = base_transformations.join(".")
@@ -87,6 +89,7 @@ class Cloudinary::Utils
       :w   => width
     }
     {
+      :ar => :aspect_ratio,
       :ac => :audio_codec,
       :br => :bit_rate,
       :cs => :color_space,
@@ -125,7 +128,7 @@ class Cloudinary::Utils
     transformations = base_transformations << transformation
     if responsive_width
       responsive_width_transformation = Cloudinary.config.responsive_width_transformation || DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION
-      transformations << generate_transformation_string(responsive_width_transformation.clone)
+      transformations << generate_transformation_string(responsive_width_transformation.clone, allow_implicit_crop_mode)
     end
 
     if width.to_s == "auto" || responsive_width
@@ -207,6 +210,8 @@ class Cloudinary::Utils
     end
     letter_spacing = layer[:letter_spacing]
     keywords.push("letter_spacing_#{letter_spacing}") unless letter_spacing.blank?
+    line_spacing = layer[:line_spacing]
+    keywords.push("line_spacing_#{line_spacing}") unless line_spacing.blank?
     if !font_size.blank? || !font_family.blank? || !keywords.empty?
       raise(CloudinaryException, "Must supply font_family for text in overlay/underlay") if font_family.blank?
       raise(CloudinaryException, "Must supply font_size for text in overlay/underlay") if font_size.blank?
@@ -225,6 +230,23 @@ class Cloudinary::Utils
     Digest::SHA1.hexdigest("#{to_sign}#{api_secret}")
   end
 
+  def self.generate_responsive_breakpoints_string(breakpoints)
+    return nil if breakpoints.nil?
+    breakpoints = build_array(breakpoints)
+
+    breakpoints.map do |breakpoint_settings|
+      unless breakpoint_settings.nil?
+        breakpoint_settings = breakpoint_settings.clone
+        transformation =  breakpoint_settings.delete(:transformation) || breakpoint_settings.delete("transformation")
+        if transformation
+          breakpoint_settings[:transformation] = Cloudinary::Utils.generate_transformation_string(transformation.clone, true)
+        end 
+      end
+      breakpoint_settings
+
+    end.to_json
+  end
+
   # Warning: options are being destructively updated!
   def self.unsigned_download_url(source, options = {})
 
@@ -354,14 +376,21 @@ class Cloudinary::Utils
     [resource_type, type]
   end
 
+  # Creates the URL prefix for the cloudinary resource URL
+  #
   # cdn_subdomain and secure_cdn_subdomain
-  # 1) Customers in shared distribution (e.g. res.cloudinary.com)
-  #   if cdn_domain is true uses res-[1-5].cloudinary.com for both http and https. Setting secure_cdn_subdomain to false disables this for https.
-  # 2) Customers with private cdn
-  #   if cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for http
-  #   if secure_cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for https (please contact support if you require this)
-  # 3) Customers with cname
-  #   if cdn_domain is true uses a[1-5].cname for http. For https, uses the same naming scheme as 1 for shared distribution and as 2 for private distribution.
+  # 1. Customers in shared distribution (e.g. res.cloudinary.com)
+  #
+  #    if cdn_domain is true uses res-[1-5 ].cloudinary.com for both http and https. Setting secure_cdn_subdomain to false disables this for https.
+  # 2. Customers with private cdn
+  #
+  #    if cdn_domain is true uses cloudname-res-[1-5 ].cloudinary.com for http
+  #
+  #    if secure_cdn_domain is true uses cloudname-res-[1-5 ].cloudinary.com for https (please contact support if you require this)
+  # 3. Customers with cname
+  #
+  #    if cdn_domain is true uses a\[1-5\]\.cname for http. For https, uses the same naming scheme as 1 for shared distribution and as 2 for private distribution.
+  # @private
   def self.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
     return "/res#{cloud_name}" if cloud_name.start_with?("/") # For development
 
@@ -417,12 +446,53 @@ class Cloudinary::Utils
         :expires_at=>options[:expires_at] && options[:expires_at].to_i
       }, options)
 
-    return Cloudinary::Utils.cloudinary_api_url("download", options) + "?" + cloudinary_params.to_query
+    return Cloudinary::Utils.cloudinary_api_url("download", options) + "?" + hash_query_params(cloudinary_params)
   end
 
+  # Utility method that uses the deprecated ZIP download API. 
+  # @deprecated Replaced by {download_zip_url} that uses the more advanced and robust archive generation and download API
   def self.zip_download_url(tag, options = {})
+    warn "zip_download_url is deprecated. Please use download_zip_url instead."
     cloudinary_params = sign_request({:timestamp=>Time.now.to_i, :tag=>tag, :transformation=>generate_transformation_string(options)}, options)
-    return Cloudinary::Utils.cloudinary_api_url("download_tag.zip", options) + "?" + cloudinary_params.to_query
+    return Cloudinary::Utils.cloudinary_api_url("download_tag.zip", options) + "?" + hash_query_params(cloudinary_params)
+  end
+
+  # Returns a URL that when invokes creates an archive and returns it.
+  # @param options [Hash]
+  # @option options [String|Symbol] :resource_type  The resource type of files to include in the archive. Must be one of :image | :video | :raw
+  # @option options [String|Symbol] :type (:upload) The specific file type of resources: :upload|:private|:authenticated
+  # @option options [String|Symbol|Array] :tags (nil) list of tags to include in the archive
+  # @option options [String|Array<String>] :public_ids (nil) list of public_ids to include in the archive
+  # @option options [String|Array<String>] :prefixes (nil) Optional list of prefixes of public IDs (e.g., folders).
+  # @option options [String|Array<String>] :transformations Optional list of transformations.
+  #   The derived images of the given transformations are included in the archive. Using the string representation of
+  #   multiple chained transformations as we use for the 'eager' upload parameter.
+  # @option options [String|Symbol] :mode (:create) return the generated archive file or to store it as a raw resource and
+  #   return a JSON with URLs for accessing the archive. Possible values: :download, :create
+  # @option options [String|Symbol] :target_format (:zip)
+  # @option options [String] :target_public_id Optional public ID of the generated raw resource.
+  #   Relevant only for the create mode. If not specified, random public ID is generated.
+  # @option options [boolean] :flatten_folders (false) If true, flatten public IDs with folders to be in the root of the archive.
+  #   Add numeric counter to the file name in case of a name conflict.
+  # @option options [boolean] :flatten_transformations (false) If true, and multiple transformations are given,
+  #   flatten the folder structure of derived images and store the transformation details on the file name instead.
+  # @option options [boolean] :use_original_filename Use the original file name of included images (if available) instead of the public ID.
+  # @option options [boolean] :async (false) If true, return immediately and perform the archive creation in the background.
+  #   Relevant only for the create mode.
+  # @option options [String] :notification_url Optional URL to send an HTTP post request (webhook) when the archive creation is completed.
+  # @option options [String|Array<String] :target_tags Optional array. Allows assigning one or more tag to the generated archive file (for later housekeeping via the admin API).
+  # @option options [String] :keep_derived (false) keep the derived images used for generating the archive
+  # @return [String] archive url
+  def self.download_archive_url(options = {})
+    cloudinary_params = sign_request(Cloudinary::Utils.archive_params(options.merge(:mode => "download")), options)
+    return Cloudinary::Utils.cloudinary_api_url("generate_archive", options) + "?" + hash_query_params(cloudinary_params)
+  end
+
+
+  # Returns a URL that when invokes creates an zip archive and returns it.
+  # @see download_archive_url
+  def self.download_zip_url(options = {})
+    download_archive_url(options.merge(:target_format => "zip"))
   end
 
   def self.signed_download_url(public_id, options = {})
@@ -591,8 +661,62 @@ class Cloudinary::Utils
     end
   end
 
+  # Returns a Hash of parameters used to create an archive
+  # @param [Hash] options
+  # @private
+  def self.archive_params(options = {})
+    options = Cloudinary::Utils.symbolize_keys options
+    {
+      :timestamp=>(options[:timestamp] || Time.now.to_i),
+      :type=>options[:type],
+      :mode => options[:mode],
+      :target_format => options[:target_format],
+      :target_public_id=> options[:target_public_id],
+      :flatten_folders=>Cloudinary::Utils.as_safe_bool(options[:flatten_folders]),
+      :flatten_transformations=>Cloudinary::Utils.as_safe_bool(options[:flatten_transformations]),
+      :use_original_filename=>Cloudinary::Utils.as_safe_bool(options[:use_original_filename]),
+      :async=>Cloudinary::Utils.as_safe_bool(options[:async]),
+      :notification_url=>options[:notification_url],
+      :target_tags=>options[:target_tags] && Cloudinary::Utils.build_array(options[:target_tags]),
+      :keep_derived=>Cloudinary::Utils.as_safe_bool(options[:keep_derived]),
+      :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]),
+      :public_ids=>options[:public_ids] && Cloudinary::Utils.build_array(options[:public_ids]),
+      :prefixes=>options[:prefixes] && Cloudinary::Utils.build_array(options[:prefixes]),
+      :transformations => build_eager(options[:transformations])
+    }
+  end
+
+  # @private
+  def self.build_eager(eager)
+    return nil if eager.nil?
+    Cloudinary::Utils.build_array(eager).map do
+    |transformation, format|
+      transformation = transformation.clone
+      format = transformation.delete(:format) || format
+      [Cloudinary::Utils.generate_transformation_string(transformation, true), format].compact.join("/")
+    end.join("|")
+  end
+
   private
 
+  def self.hash_query_params(hash)
+    if hash.respond_to?("to_query")
+      hash.to_query
+    else
+      flat_hash_to_query_params(hash)      
+    end
+  end
+
+  def self.flat_hash_to_query_params(hash)
+    hash.collect do |key, value|      
+      if value.is_a?(Array)
+        value.map{|v| "#{CGI.escape(key.to_s)}[]=#{CGI.escape(v.to_s)}"}.join("&")
+      else  
+        "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+      end        
+    end.compact.sort!.join('&')
+  end  
+
   def self.number_pattern
     "([0-9]*)\\.([0-9]+)|([0-9]+)"
   end

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end

data/spec/api_spec.rb

@@ -3,29 +3,25 @@ require 'cloudinary'
 
 describe Cloudinary::Api do
   break puts("Please setup environment for api test to run") if Cloudinary.config.api_secret.blank?
+  include_context "cleanup"
 
+  prefix = "api_test_#{Time.now.to_i}"
+  test_id_1 = "#{prefix}_1"
+  test_id_2   = "#{prefix}_2"
   before(:all) do
     @timestamp_tag = "api_test_tag_#{Time.now.to_i}"
     @api = Cloudinary::Api
-    Cloudinary::Uploader.destroy("api_test")
-    Cloudinary::Uploader.destroy("api_test2")
-    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test", :tags=> ["api_test_tag", @timestamp_tag], :context => "key=value", :eager=>[:width=>100,:crop=>:scale])
-    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test2", :tags=> ["api_test_tag", @timestamp_tag], :context => "key=value", :eager=>[:width=>100,:crop=>:scale])
-    @api.delete_transformation("api_test_transformation") rescue nil
-    @api.delete_transformation("api_test_transformation2") rescue nil
-    @api.delete_transformation("api_test_transformation3") rescue nil
-    @api.delete_upload_preset("api_test_upload_preset") rescue nil
-    @api.delete_upload_preset("api_test_upload_preset2") rescue nil
-    @api.delete_upload_preset("api_test_upload_preset3") rescue nil
-    @api.delete_upload_preset("api_test_upload_preset4") rescue nil
+    Cloudinary::Uploader.upload("spec/logo.png", :public_id => test_id_1, :tags => [TEST_TAG, @timestamp_tag], :context => "key=value", :eager =>[:width =>100, :crop =>:scale])
+    Cloudinary::Uploader.upload("spec/logo.png", :public_id => test_id_2, :tags => [TEST_TAG, @timestamp_tag], :context => "key=value", :eager =>[:width =>100, :crop =>:scale])
   end
-  
+
   it "should allow listing resource_types" do
     expect(@api.resource_types()["resource_types"]).to include("image")
   end
 
   it "should allow listing resources" do
-    resource = @api.resources()["resources"].find{|resource| resource["public_id"] == "api_test"}
+    resource = @api.resources()["resources"].find{|resource| resource["public_id"] == test_id_1
+    }
     expect(resource).not_to be_blank
     expect(resource["type"]).to eq("upload")
   end
@@ -43,30 +39,33 @@ describe Cloudinary::Api do
 
 
   it "should allow listing resources by type" do
-    resource = @api.resources(:type=>"upload", :tags=>true)["resources"].find{|resource| resource["public_id"] == "api_test"}
+    resource = @api.resources(:type=>"upload", :tags=>true)["resources"].find{|resource| resource["public_id"] == test_id_1
+    }
     expect(resource).not_to be_blank
-    expect(resource["tags"]).to eq(["api_test_tag", @timestamp_tag])
+    expect(resource["tags"]).to match_array([TEST_TAG, @timestamp_tag])
   end
 
   it "should allow listing resources by prefix" do
-    resources = @api.resources(:type=>"upload", :prefix=>"api_test", :tags => true, :context => true)["resources"]
-    expect(resources.map{|resource| resource["public_id"]}).to include("api_test", "api_test2")
-    expect(resources.map{|resource| resource["tags"]}).to include(["api_test_tag", @timestamp_tag])
+    resources = @api.resources(:type =>"upload", :prefix => prefix, :tags => true, :context => true)["resources"]
+    expect(resources.map{|resource| resource["public_id"]}).to include(test_id_1, test_id_2)
+    expect(resources.map{|resource| resource["tags"]}.flatten).to include(TEST_TAG, @timestamp_tag)
     expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
 
   it "should allow listing resources by tag" do
-    resources = @api.resources_by_tag("api_test_tag", :tags => true, :context => true)["resources"]
-    expect(resources.find{|resource| resource["public_id"] == "api_test"}).not_to be_blank
-    expect(resources.map{|resource| resource["tags"]}).to include(["api_test_tag", @timestamp_tag])
+    resources = @api.resources_by_tag(TEST_TAG, :tags => true, :context => true)["resources"]
+    expect(resources.find{|resource| resource["public_id"] == test_id_1
+    }).not_to be_blank
+    expect(resources.map{|resource| resource["tags"]}.flatten).to include(TEST_TAG, @timestamp_tag)
     expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
   
   it "should allow listing resources by public ids" do
-    resources = @api.resources_by_ids(["api_test", "api_test2"], :tags => true, :context => true)["resources"]
+    resources = @api.resources_by_ids([test_id_1, test_id_2], :tags => true, :context => true)["resources"]
     expect(resources.length).to eq(2)
-    expect(resources.find{|resource| resource["public_id"] == "api_test"}).not_to be_blank
-    expect(resources.map{|resource| resource["tags"]}).to include(["api_test_tag", @timestamp_tag])
+    expect(resources.find{|resource| resource["public_id"] == test_id_1
+    }).not_to be_blank
+    expect(resources.map{|resource| resource["tags"]}.flatten).to include(TEST_TAG, @timestamp_tag)
     expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
   
@@ -93,9 +92,9 @@ describe Cloudinary::Api do
   end
 
   it "should allow get resource metadata" do
-    resource = @api.resource("api_test")
+    resource = @api.resource(test_id_1)
     expect(resource).not_to be_blank
-    expect(resource["public_id"]).to eq("api_test")
+    expect(resource["public_id"]).to eq(test_id_1)
     expect(resource["bytes"]).to eq(3381)
     expect(resource["derived"].length).to eq(1)
   end
@@ -116,7 +115,7 @@ describe Cloudinary::Api do
     Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test3")
     resource = @api.resource("api_test3")
     expect(resource).not_to be_blank
-    @api.delete_resources(["apit_test", "api_test2", "api_test3"])
+    @api.delete_resources(["apit_test", test_id_2, "api_test3"])
     expect{@api.resource("api_test3")}.to raise_error(Cloudinary::Api::NotFound)
   end
 
@@ -129,7 +128,7 @@ describe Cloudinary::Api do
   end
 
   it "should allow deleting resources by tags" do
-    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test4", :tags=>["api_test_tag_for_delete"])
+    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test4", :tags=>[TEST_TAG, "api_test_tag_for_delete"])
     resource = @api.resource("api_test4")
     expect(resource).not_to be_blank
     @api.delete_resources_by_tag("api_test_tag_for_delete")
@@ -138,86 +137,91 @@ describe Cloudinary::Api do
 
   it "should allow listing tags" do
     tags = @api.tags()["tags"]
-    expect(tags).to include('api_test_tag')
+    expect(tags).to include(TEST_TAG)
   end
 
   it "should allow listing tag by prefix" do
-    tags = @api.tags(:prefix=>"api_test")["tags"]
-    expect(tags).to include('api_test_tag')
+    tags = @api.tags(:prefix=> "api_test_tag")["tags"]
+    expect(tags).to include(@timestamp_tag)
     tags = @api.tags(:prefix=>"api_test_no_such_tag")["tags"]
     expect(tags).to be_blank
   end
   
-  it "should allow listing transformations" do
-    transformation = @api.transformations()["transformations"].find{|transformation| transformation["name"] == "c_scale,w_100"}
-    expect(transformation).not_to be_blank
-    expect(transformation["used"]).to eq(true)
-  end
-
-  it "should allow getting transformation metadata" do
-    transformation = @api.transformation("c_scale,w_100")
-    expect(transformation).not_to be_blank  
-    expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>100]     )
-    transformation = @api.transformation("crop"=>"scale", "width"=>100)
-    expect(transformation).not_to be_blank  
-    expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>100]     )
-  end
-  
-  it "should allow updating transformation allowed_for_strict" do
-    @api.update_transformation("c_scale,w_100", :allowed_for_strict=>true)
-    transformation = @api.transformation("c_scale,w_100")
-    expect(transformation).not_to be_blank  
-    expect(transformation["allowed_for_strict"]).to eq(true)
-    @api.update_transformation("c_scale,w_100", :allowed_for_strict=>false)
-    transformation = @api.transformation("c_scale,w_100")
-    expect(transformation).not_to be_blank  
-    expect(transformation["allowed_for_strict"]).to eq(false)
-  end
-  describe "named transformations" do
-    it "should allow creating named transformation" do
-      @api.create_transformation("api_test_transformation", "crop"=>"scale", "width"=>102)
-      transformation = @api.transformation("api_test_transformation")
+  describe 'transformations' do
+    it "should allow listing transformations" do
+      transformation = @api.transformations()["transformations"].find { |transformation| transformation["name"] == "c_scale,w_100" }
       expect(transformation).not_to be_blank
-      expect(transformation["allowed_for_strict"]).to eq(true)
-      expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>102])
-      expect(transformation["used"]).to eq(false)
+      expect(transformation["used"]).to eq(true)
     end
 
-    it "should allow deleting named transformation" do
-      @api.create_transformation("api_test_transformation2", "crop"=>"scale", "width"=>103)
-      @api.transformation("api_test_transformation2")
-      @api.delete_transformation("api_test_transformation2")
-      expect{@api.transformation("api_test_transformation2")}.to raise_error(Cloudinary::Api::NotFound)
+    it "should allow getting transformation metadata" do
+      transformation = @api.transformation("c_scale,w_100")
+      expect(transformation).not_to be_blank
+      expect(transformation["info"]).to eq(["crop" => "scale", "width" => 100])
+      transformation = @api.transformation("crop" => "scale", "width" => 100)
+      expect(transformation).not_to be_blank
+      expect(transformation["info"]).to eq(["crop" => "scale", "width" => 100])
     end
 
-    it "should allow unsafe update of named transformation" do
-      @api.create_transformation("api_test_transformation3", "crop"=>"scale", "width"=>102)
-      @api.update_transformation("api_test_transformation3", :unsafe_update=>{"crop"=>"scale", "width"=>103})
-      transformation = @api.transformation("api_test_transformation3")
+    it "should allow updating transformation allowed_for_strict" do
+      @api.update_transformation("c_scale,w_100", :allowed_for_strict => true)
+      transformation = @api.transformation("c_scale,w_100")
+      expect(transformation).not_to be_blank
+      expect(transformation["allowed_for_strict"]).to eq(true)
+      @api.update_transformation("c_scale,w_100", :allowed_for_strict => false)
+      transformation = @api.transformation("c_scale,w_100")
       expect(transformation).not_to be_blank
-      expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>103])
-      expect(transformation["used"]).to eq(false)
+      expect(transformation["allowed_for_strict"]).to eq(false)
     end
 
-  end
-  it "should allow deleting implicit transformation" do
-    @api.transformation("c_scale,w_100")
-    @api.delete_transformation("c_scale,w_100")
-    expect{@api.transformation("c_scale,w_100")}.to raise_error(Cloudinary::Api::NotFound)
+    describe "named transformations" do
+      it "should allow creating named transformation" do
+        public_id = "api_test_transformation_#{Time.now.to_i}"
+        @api.create_transformation(public_id, "crop" => "scale", "width" => 102, :tags => TEST_TAG)
+        transformation = @api.transformation(public_id)
+        expect(transformation).not_to be_blank
+        expect(transformation["allowed_for_strict"]).to eq(true)
+        expect(transformation["info"]).to eq(["crop" => "scale", "width" => 102])
+        expect(transformation["used"]).to eq(false)
+      end
+
+      it "should allow deleting named transformation" do
+        public_id = "api_test_transformation_#{Time.now.to_i}"
+        @api.create_transformation(public_id, "crop" => "scale", "width" => 103, :tags => TEST_TAG)
+        @api.transformation(public_id)
+        @api.delete_transformation(public_id)
+        expect { @api.transformation(public_id) }.to raise_error(Cloudinary::Api::NotFound)
+      end
+
+      it "should allow unsafe update of named transformation" do
+        public_id = "api_test_transformation_#{Time.now.to_i}"
+        @api.create_transformation(public_id, "crop" => "scale", "width" => 102, :tags => TEST_TAG)
+        @api.update_transformation(public_id, :unsafe_update => { "crop" => "scale", "width" => 103 })
+        transformation = @api.transformation(public_id)
+        expect(transformation).not_to be_blank
+        expect(transformation["info"]).to eq(["crop" => "scale", "width" => 103])
+        expect(transformation["used"]).to eq(false)
+      end
+
+    end
+    it "should allow deleting implicit transformation" do
+      @api.transformation("c_scale,w_100")
+      @api.delete_transformation("c_scale,w_100")
+      expect { @api.transformation("c_scale,w_100") }.to raise_error(Cloudinary::Api::NotFound)
+    end
   end
   
   it "should allow creating and listing upload_presets", :upload_preset => true do
-    @api.create_upload_preset(:name => "api_test_upload_preset", :folder => "folder")
-    @api.create_upload_preset(:name => "api_test_upload_preset2", :folder => "folder2")
-    @api.create_upload_preset(:name => "api_test_upload_preset3", :folder => "folder3")
-    expect(@api.upload_presets["presets"].first(3).map{|p| p["name"]}).to eq(["api_test_upload_preset3", "api_test_upload_preset2", "api_test_upload_preset"])
-    @api.delete_upload_preset("api_test_upload_preset")
-    @api.delete_upload_preset("api_test_upload_preset2")
-    @api.delete_upload_preset("api_test_upload_preset3")
+    name = []
+    3.times { |i| name.push( "api_test_#{Time.now.to_i}_#{i}")}
+    @api.create_upload_preset(:name => name[0], :folder => "folder", :tags => TEST_TAG)
+    @api.create_upload_preset(:name => name[1], :folder => "folder2", :tags => TEST_TAG)
+    @api.create_upload_preset(:name => name[2], :folder => "folder3", :tags => TEST_TAG)
+    expect(@api.upload_presets["presets"].first(3).map{|p| p["name"]}).to match_array(name)
   end
   
   it "should allow getting a single upload_preset", :upload_preset => true do
-    result = @api.create_upload_preset(:unsigned => true, :folder => "folder", :width => 100, :crop => :scale, :tags => ["a","b","c"], :context => {:a => "b", :c => "d"})
+    result = @api.create_upload_preset(:unsigned => true, :folder => "folder", :width => 100, :crop => :scale, :tags => ["a","b","c", TEST_TAG], :context => {:a => "b", :c => "d"})
     name = result["name"]
     preset = @api.upload_preset(name)
     expect(preset["name"]).to eq(name)
@@ -225,31 +229,29 @@ describe Cloudinary::Api do
     expect(preset["settings"]["folder"]).to eq("folder")
     expect(preset["settings"]["transformation"]).to eq([{"width" => 100, "crop" => "scale"}])
     expect(preset["settings"]["context"]).to eq({"a" => "b", "c" => "d"})
-    expect(preset["settings"]["tags"]).to eq(["a","b","c"])
-    @api.delete_upload_preset(name)
+    expect(preset["settings"]["tags"]).to eq(["a","b","c", TEST_TAG])
   end
   
   it "should allow deleting upload_presets", :upload_preset => true do
-    @api.create_upload_preset(:name => "api_test_upload_preset4", :folder => "folder")
+    @api.create_upload_preset(:name => "api_test_upload_preset4", :folder => "folder", :tags => TEST_TAG)
     preset = @api.upload_preset("api_test_upload_preset4")
     @api.delete_upload_preset("api_test_upload_preset4")
     expect{preset = @api.upload_preset("api_test_upload_preset4")}.to raise_error
   end
   
   it "should allow updating upload_presets", :upload_preset => true do
-    name = @api.create_upload_preset(:folder => "folder")["name"]
+    name = @api.create_upload_preset(:folder => "folder", :tags => TEST_TAG)["name"]
     preset = @api.upload_preset(name)
     @api.update_upload_preset(name, preset["settings"].merge(:colors => true, :unsigned => true, :disallow_public_id => true))
     preset = @api.upload_preset(name)
     expect(preset["name"]).to eq(name)
     expect(preset["unsigned"]).to eq(true)
-    expect(preset["settings"]).to eq({"folder" => "folder", "colors" => true, "disallow_public_id" => true})
-    @api.delete_upload_preset(name)
+    expect(preset["settings"]).to eq({"folder" => "folder", "colors" => true, "disallow_public_id" => true, "tags" => [TEST_TAG]})
   end
   
   # this test must be last because it deletes (potentially) all dependent transformations which some tests rely on. Excluded by default.
-  it "should allow deleting all resources", :delete_all=>true do
-    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test5", :eager=>[:width=>101,:crop=>:scale])
+  skip "should allow deleting all resources", :delete_all=>true do
+    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test5", :eager=>[:width=>101,:crop=>:scale], :tags => TEST_TAG)
     resource = @api.resource("api_test5")
     expect(resource).not_to be_blank
     expect(resource["derived"].length).to eq(1)
@@ -260,7 +262,7 @@ describe Cloudinary::Api do
   end
   
   it "should support setting manual moderation status" do
-    result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
+    result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual, :tags => TEST_TAG})
     expect(result["moderation"][0]["status"]).to eq("pending")
     expect(result["moderation"][0]["kind"]).to eq("manual")
     api_result = Cloudinary::Api.update(result["public_id"], {:moderation_status => :approved})
@@ -269,29 +271,29 @@ describe Cloudinary::Api do
   end
     
   it "should support requesting raw conversion" do
-    result = Cloudinary::Uploader.upload("spec/docx.docx", :resource_type => :raw)
+    result = Cloudinary::Uploader.upload("spec/docx.docx", :resource_type => :raw, :tags => TEST_TAG)
     expect{Cloudinary::Api.update(result["public_id"], {:resource_type => :raw, :raw_convert => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value|not a valid/)
   end
   
   it "should support requesting categorization" do
-    result = Cloudinary::Uploader.upload("spec/logo.png")
+    result = Cloudinary::Uploader.upload("spec/logo.png", :tags => TEST_TAG)
     expect{Cloudinary::Api.update(result["public_id"], {:categorization => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
   end
   
   it "should support requesting detection" do
-    result = Cloudinary::Uploader.upload("spec/logo.png")
+    result = Cloudinary::Uploader.upload("spec/logo.png", :tags => TEST_TAG)
     expect{Cloudinary::Api.update(result["public_id"], {:detection => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
   end
   
   it "should support requesting auto_tagging" do
-    result = Cloudinary::Uploader.upload("spec/logo.png")
+    result = Cloudinary::Uploader.upload("spec/logo.png", :tags => TEST_TAG)
     expect{Cloudinary::Api.update(result["public_id"], {:auto_tagging => 0.5})}.to raise_error(Cloudinary::Api::BadRequest, /^Must use/)
   end
   
   it "should support listing by moderation kind and value" do
-    result1 = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
-    result2 = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
-    result3 = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
+    result1 = Cloudinary::Uploader.upload("spec/logo.png", { :moderation => :manual, :tags => TEST_TAG})
+    result2 = Cloudinary::Uploader.upload("spec/logo.png", { :moderation => :manual, :tags => TEST_TAG})
+    result3 = Cloudinary::Uploader.upload("spec/logo.png", { :moderation => :manual, :tags => TEST_TAG})
     Cloudinary::Api.update(result1["public_id"], {:moderation_status => :approved})
     Cloudinary::Api.update(result2["public_id"], {:moderation_status => :rejected})
     approved = Cloudinary::Api.resources_by_moderation(:manual, :approved, :max_results => 1000)["resources"].map{|r| r["public_id"]}
@@ -309,20 +311,71 @@ describe Cloudinary::Api do
   end
 
   it "should support listing folders" do
-    pending("For this test to work, 'Auto-create folders' should be enabled in the Upload Settings, " + 
-            "and the account should be empty of folders. " +
-            "Comment out this line if you really want to test it.")
-    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/item"})
-    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder2/item"})
-    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/test_subfolder1/item"})
-    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/test_subfolder2/item"})
+    # pending("For this test to work, 'Auto-create folders' should be enabled in the Upload Settings, " +
+    #         "and the account should be empty of folders. " +
+    #         "Comment out this line if you really want to test it.")
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/item", :tags => TEST_TAG})
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder2/item", :tags => TEST_TAG})
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/test_subfolder1/item", :tags => TEST_TAG})
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/test_subfolder2/item", :tags => TEST_TAG})
     result = Cloudinary::Api.root_folders
-    expect(result["folders"][0]["name"]).to eq("test_folder1")
-    expect(result["folders"][1]["name"]).to eq("test_folder2")
+    expect(result["folders"]).not_to be_empty, "Folders should have been created. Make sure that 'Auto-create folders' is enabled for this cloud"
+    names = result["folders"].map{|f| f["name"]}
+    expect(names).to include("test_folder1")
+    expect(names).to include("test_folder2")
     result = Cloudinary::Api.subfolders("test_folder1")
-    expect(result["folders"][0]["path"]).to eq("test_folder1/test_subfolder1")
-    expect(result["folders"][1]["path"]).to eq("test_folder1/test_subfolder2")
+
+    paths = result["folders"].map{|f| f["path"]}
+    expect(paths).to include("test_folder1/test_subfolder1")
+    expect(paths).to include("test_folder1/test_subfolder2")
     expect{Cloudinary::Api.subfolders("test_folder")}.to raise_error(Cloudinary::Api::NotFound)
-    Cloudinary::Api.delete_resources_by_prefix("test_folder")
+  end
+
+  describe '.restore'  do
+    before :each do
+      Cloudinary::Uploader.upload("spec/logo.png", :public_id => "api_test_restore", :backup => true, :tags => TEST_TAG)
+      resource = Cloudinary::Api.resource("api_test_restore")
+      expect(resource).not_to be_nil
+      expect(resource["bytes"]).to eq(3381)
+      Cloudinary::Api.delete_resources("api_test_restore")
+      resource = Cloudinary::Api.resource("api_test_restore")
+      expect(resource).not_to be_nil
+      expect(resource["bytes"]).to eq(0)
+      expect(resource["placeholder"]).to eq(true)
+    end
+    it 'should restore a deleted resource' do
+      response = Cloudinary::Api.restore("api_test_restore")
+      info     = response["api_test_restore"]
+      expect(info).not_to be_nil
+      expect(info["bytes"]).to eq(3381)
+      resource = Cloudinary::Api.resource("api_test_restore")
+      expect(resource).not_to be_nil
+      expect(resource["bytes"]).to eq(3381)
+    end
+  end
+
+  describe 'mapping' do
+    mapping = "api_test_upload_mapping#{rand(100000)}"
+    after :all do
+      begin
+        Cloudinary::Api.delete_upload_mapping(mapping)
+      rescue
+        puts "Could not delete #{mapping}"
+      end
+    end
+
+    it 'should create mapping' do
+      result = Cloudinary::Api.create_upload_mapping(mapping, :template =>"http://cloudinary.com")
+      result = Cloudinary::Api.upload_mapping(mapping)
+      expect(result['template']).to eq("http://cloudinary.com")
+      Cloudinary::Api.update_upload_mapping(mapping, "template" =>"http://res.cloudinary.com")
+      result = Cloudinary::Api.upload_mapping(mapping)
+      expect(result["template"]).to eq("http://res.cloudinary.com")
+      result = Cloudinary::Api.upload_mappings
+      expect(result["mappings"]).to include("folder" => mapping, "template" =>"http://res.cloudinary.com" )
+      Cloudinary::Api.delete_upload_mapping(mapping)
+      result = Cloudinary::Api.upload_mappings()
+      expect(result["mappings"]).not_to include(mapping )
+    end
   end
 end