cloudinary 1.1.6 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58c3479c59e20893f65ba55c52498183ebce293a
-  data.tar.gz: 45b5a9f416a2522b820ebd2f5229024bb5e055a2
+  metadata.gz: 8c21572d5ca0363eb07c0a226e92498d90d9f2b9
+  data.tar.gz: ab8a7a05057dbf409296897576f69745d9516a8a
 SHA512:
-  metadata.gz: fd74bfe3c3f91408cfdb0de65add6249c51c8828d61ea3bb3831efcb02219551ccabbf67b99e3a47c6cbfc8d1540974f75aa8e40aad67b51c33177b1bb58954f
-  data.tar.gz: 36ff909b5ef5903ef1ffec3ba61ec21f7807d27f0e933ca0b807bb653551f858ded73a9f3ad8d7f49f2e3f6c95e9767f38ce0652b37fe576417de9a48b0d0f09
+  metadata.gz: d609e1b2f396d259645df469f7ec94769f31bae9e49571b77530aa73521bbece7dcdff545309db03f8486ff4c566a68179b26f3d3473a7db444554fd1cdddcca
+  data.tar.gz: 3496b66de2e36abdde1e9b28e30c392807f784295ed4de76f4f0e87e5362fb9be2202e625cd6ffe85c6e8b4c8d01a70127c6c29ff5a4c6b278e8c0999be7412c

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+- 1.9.3
+- 2.2.3
+env:
+  matrix:
+    secure: OTtg+CpNgfqJYqJk4rRZRvljss2p6nLTgBLrdUt/4hpSFLFueo0m7Jdu2zeEDPLEzMKo6zZlBp1/BPjCHtnjda7qpOQpMutEzD5EG60BG5LiMDsoAHL6apiL4zNUy8Sjcp/QslpKRozcYzogHjCnxM8RtSnW9wqiCehM5yivlj4JwU/e2x7XZGRbwW2jj4kr/BAdylYYftAaVOrl/3vqngE2tciq6YRL5GFR6o1L5ty435jsyDwEWAPs6vTLwJuEmPLJ4pEOVPOI08zOgVWKHyAWiCc7WYyBxKDmDUU9Xth922ko7nhptQUJeJuxh2dTvrPuTkibNzX1QLugX8RwzJ7pXG9iuhx14lmFbfZZtl+g2SEh5Hem5GFCVOlxpULuxZUKDcNwYURWwuoeBYpGOrOu7xn70o6cF3bNfenUJEl/ts1YgAZ/pcHmbeW95ovb+vTHj8uPk1J17FKOtXjbgblzYLwrl68ika1QfWJEYq1DcI7BT7AwsEeThPmvQ03y+lH8DrYQVprzTpjGICvMyMQSZdA8woXMeEFV0CzKew1+Q0JgjLpYDTQ6U51HEvzCZFTNoN2ZDdsdMRtkxmjBwgEQAY5+SA5icI6/uxAvloScl+7SnNiAhqyPaA2YlwZ/xhI8plvydkmK805Z1uZztGUNu0yn47FzGDC286RF/rI=
+script: bundle exec rspec

data/CHANGELOG.md

@@ -1,4 +1,35 @@
 
+1.1.7 / 2016-06-06
+==================
+
+New functionality and features
+------------------------------
+  * Add TravisCI configuration and label
+  * Add `keyframe_interval` and `streaming_profile` transformation parameters
+  * Add `expires_at` parameter to `Utils#download_archive_url`
+  * Add `CONTRIBUTING.md`
+  * Add `next_cursor` to `transformation()`
+  * Update Readme with information on the Cloudinary JavaScript library. Related to #199
+
+Other Changes
+-------------
+  
+  * Ensuring rails environment is loaded as a dependency of running sync_static rake task, so anything initializer that sets up Cloudinary.config takes affect
+  * Refactor tests to allow parallel runs.
+  * Fix `deep_hash_values` matcher.
+  * Mock heavy tests
+  * Remove upload_presets created during the tests
+  * Merge pull request #177 from Buyapowa/fix-rake-task-config-loading
+  * Merge pull request #185 from gunterja/patch-1
+  * Merge pull request #186 from gunterja/patch-2
+  * Merge pull request #187 from gunterja/patch-3
+  * Merge pull request #189 from gunterja/patch-5
+  * Merge branch 'task/add-next-cursor-to-transformation'
+  * adding tests for next_cursor with transformation 
+  * Merge pull request #192 from thedrow/patch-1
+  * exists? must return booleans
+  * `File.exists?` is deprecated in favor of `File.exist?`
+
 1.1.6 / 2016-04-20
 ==================
 

data/CONTRIBUTING.md

@@ -0,0 +1,136 @@
+# Contributing to Cloudinary GEM
+
+Contributions are welcome and greatly appreciated!
+
+## Reporting a bug
+
+- Ensure that the bug was not already reported by searching in GitHub under [Issues](https://github.com/cloudinary/cloudinary_gem) and the Cloudinary [Support forms](https://support.cloudinary.com).
+- If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/cloudinary/cloudinary_gem/issues/new).
+  Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.
+- If you require assistance in the implementation of cloudinary_gem please [submit a request](https://support.cloudinary.com/hc/en-us/requests/new) in the Cloudinary web site.
+
+## Requesting a feature
+
+We would love to hear your requests!
+Please be aware that the GEM is used in a wide variety of environments and that some features may not be applicable to all users.
+
+- Open a GitHub [issue](https://github.com/cloudinary/cloudinary_gem) describing the benefits (and possible drawbacks) of the requested feature
+
+## Fixing a bug / Implementing a new feature
+
+- Follow the instructions detailed in [Code contribution](#code-contribution)
+- Open a new GitHub pull request
+- Ensure the PR description clearly describes the bug / feature. Include the relevant issue number if applicable.
+- Provide test code that covers the new code
+- Make sure that your code works both with and without Rails
+- The code should support:
+  - Ruby >= 1.8
+  - Rails >= 3.0
+
+## Code contribution
+
+When contributing code, either to fix a bug or to implement a new feature, please follow these guidelines:
+
+#### Fork the Project
+
+Fork [project on Github](https://github.com/cloudinary/cloudinary_gem) and check out your copy.
+
+```
+git clone https://github.com/contributor/cloudinary_gem.git
+cd cloudinary_gem
+git remote add upstream https://github.com/cloudinary/cloudinary_gem.git
+```
+
+#### Create a Topic Branch
+
+Make sure your fork is up-to-date and create a topic branch for your feature or bug fix.
+
+```
+git checkout master
+git pull upstream master
+git checkout -b my-feature-branch
+```
+#### Rebase
+
+If you've been working on a change for a while, rebase with upstream/master.
+
+```
+git fetch upstream
+git rebase upstream/master
+git push origin my-feature-branch -f
+```
+
+
+#### Write Tests
+
+Try to write a test that reproduces the problem you're trying to fix or describes a feature that you want to build. Add to [test](test).
+
+We definitely appreciate pull requests that highlight or reproduce a problem, even without a fix.
+
+#### Write Code
+
+Implement your feature or bug fix.
+Follow the following [style guide](https://github.com/styleguide/ruby).
+Make sure that your code works both with and without Rails
+The code should support:
+
+  - Ruby >= 1.8
+  - Rails >= 3.0
+
+Make sure that `bundle exec rake test` completes without errors.
+
+#### Write Documentation
+
+Document any external behavior in the [README](README.md).
+
+#### Commit Changes
+
+Make sure git knows your name and email address:
+
+```
+git config --global user.name "Your Name"
+git config --global user.email "contributor@example.com"
+```
+
+Writing good commit logs is important. A commit log should describe what changed and why.
+
+```
+git add ...
+git commit
+```
+
+
+> Please squash your commits into a single commit when appropriate. This simplifies future cherry picks and keeps the git log clean.
+
+#### Push
+
+```
+git push origin my-feature-branch
+```
+
+#### Make a Pull Request
+
+Go to https://github.com/contributor/cloudinary_gem and select your feature branch. Click the 'Pull Request' button and fill out the form. Pull requests are usually reviewed within a few days.
+Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
+
+#### Rebase
+
+If you've been working on a change for a while, rebase with upstream/master.
+
+```
+git fetch upstream
+git rebase upstream/master
+git push origin my-feature-branch -f
+```
+
+#### Check on Your Pull Request
+
+Go back to your pull request after a few minutes and see whether it passed muster with Travis-CI. Everything should look green, otherwise fix issues and amend your commit as described above.
+
+#### Be Patient
+
+It's likely that your change will not be merged and that the nitpicky maintainers will ask you to do more, or fix seemingly benign problems. Hang on there!
+
+#### Thank You
+
+Please do know that we really appreciate and value your time and work. We love you, really.

data/README.md

@@ -1,3 +1,4 @@
+[![Build Status](https://travis-ci.org/cloudinary/cloudinary_gem.svg?branch=master)](https://travis-ci.org/cloudinary/cloudinary_gem)
 Cloudinary
 ==========
 
@@ -175,10 +176,54 @@ Cloudinary's Ruby GEM includes an optional plugin for [CarrierWave](https://gith
 
 We also published an interesting blog post about [Ruby on Rails image uploads with CarrierWave and Cloudinary](http://cloudinary.com/blog/ruby_on_rails_image_uploads_with_carrierwave_and_cloudinary).
 
-## Neo4j integration
+#### Neo4j integration
 
 Starting from version 1.1.1 Cloudinary's Ruby GEM supports the use of carrierwave with Neo4j.
 
+### JavaScript support library
+
+During the installation or update of the Cloudinary GEM, the latest Cloudinary JavaScript library is automatically fetched and bundled with the GEM.
+
+To use the JavaScript files you need to include them in your application, for example:
+
+```
+<%= javascript_include_tag("jquery.ui.widget", "jquery.iframe-transport", 
+                           "jquery.fileupload", "jquery.cloudinary") %>
+```
+
+Alternatively, if you use Asset Pipeline, simply edit your application.js file and add the following line:
+
+```
+//= require cloudinary
+```
+
+To automatically set-up Cloudinary's configuration, include the following line in your view or layout:
+
+```
+<%= cloudinary_js_config %>
+```
+
+#### Uploading images from the browser
+
+The Cloudinary JavaScript library utilizes the Blueimp File Upload library to support image uploading from the browser. See the [documentation](http://cloudinary.com/documentation/jquery_image_upload) for more details.
+
+|Important|
+|---------|
+|Starting with version 2.0 of the Cloudinary JavaScript library, the Cloudinary extension to the Blueimp File Upload library is no longer initialized automatically. Instead you need to explicitly set it up as described below.|
+
+To initialize the File Upload library with Cloudinary include the following code in your page:
+
+```javascript
+$(function() {
+      if($.fn.cloudinary_fileupload !== undefined) {
+        $("input.cloudinary-fileupload[type=file]").cloudinary_fileupload();
+      }
+    });
+```
+
+
+(`cloudinary_fileupload()` internally calls Blueimp's `fileupload()` so there's no need to call both.)
+
 ### Samples
 
 You can find our simple and ready-to-use samples projects, along with documentation in the [samples folder](https://github.com/cloudinary/cloudinary_gem/tree/master/samples). 

data/Rakefile

@@ -16,7 +16,8 @@ namespace :cloudinary do
   task :fetch_assets do
     index_files      = %w[jquery.ui.widget.js jquery.iframe-transport.js jquery.fileupload.js jquery.cloudinary.js]
     processing_files = %w[canvas-to-blob.min.js load-image.all.min.js jquery.fileupload-process.js jquery.fileupload-image.js jquery.fileupload-validate.js]
-    files            = index_files + processing_files
+    other_files      = %w[jquery.cloudinary.coffee jquery.cloudinary.js.map]
+    files            = index_files + processing_files + other_files
 
     release = JSON(RestClient.get("https://api.github.com/repos/cloudinary/cloudinary_js/releases/latest"))
 

data/lib/cloudinary/api.rb

@@ -137,7 +137,7 @@ class Cloudinary::Api
   end
 
   def self.transformation(transformation, options={})
-    call_api(:get, "transformations/#{transformation_string(transformation)}", only(options, :max_results), options)
+    call_api(:get, "transformations/#{transformation_string(transformation)}", only(options, :max_results, :next_cursor), options)
   end
 
   def self.delete_transformation(transformation, options={})

data/lib/cloudinary/carrier_wave/process.rb

@@ -6,7 +6,7 @@ module Cloudinary::CarrierWave
 
     def process_all_versions(*args)
       @all_versions ||= Class.new(self)
-      @all_versions.process *args
+      @all_versions.process(*args)
     end
 
     def eager

data/lib/cloudinary/migrator.rb

@@ -164,7 +164,7 @@ class Cloudinary::Migrator
   def update_row(row, values)    
     values.merge!("updated_at"=>Time.now.to_i)
     query = ["update queue set #{values.keys.map{|key| "#{key}=?"}.join(",")} where id=?"] + values.values + [row["id"]]
-    result = @db.execute(*query)
+    @db.execute(*query)
     values.each{|key, value| row[key.to_s] = value}
     row    
   end

data/lib/cloudinary/uploader.rb

@@ -149,7 +149,8 @@ class Cloudinary::Uploader
   def self.exists?(public_id, options={})
     cloudinary_url = Cloudinary::Utils.cloudinary_url(public_id, options)
     begin
-      RestClient::Request.execute(:method => :head, :url => cloudinary_url, :timeout => 5).code.to_s =~ /2\d{2}/
+      code = RestClient::Request.execute(:method => :head, :url => cloudinary_url, :timeout => 5).code
+      code >= 200 && code < 300
     rescue RestClient::ResourceNotFound
       return false
     end

data/lib/cloudinary/utils.rb

@@ -121,6 +121,7 @@ class Cloudinary::Utils
       :eo => :end_offset,
       :f  => :fetch_format,
       :g  => :gravity,
+      :ki => :keyframe_interval,
       :o  => :opacity,
       :p  => :prefix,
       :pg => :page,
@@ -128,6 +129,7 @@ class Cloudinary::Utils
       :r  => :radius,
       :af => :audio_frequency,
       :so => :start_offset,
+      :sp => :streaming_profile,
       :vc => :video_codec,
       :vs => :video_sampling,
       :x  => :x,
@@ -741,6 +743,7 @@ class Cloudinary::Utils
       :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]),
+      :expires_at=>options[:expires_at],
       :transformations => build_eager(options[:transformations])
     }
   end

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.1.6"
+  VERSION = "1.1.7"
 end

data/lib/tasks/cloudinary.rake

@@ -1,7 +1,7 @@
 namespace :cloudinary do
   desc "Sync static resources with cloudinary"
-  task :sync_static do
+  task :sync_static => :environment do
     delete_missing = ENV["DELETE_MISSING"] == 'true' || ENV["DELETE_MISSING"] == '1'
     Cloudinary::Static.sync(:delete_missing=>delete_missing)
   end
-end
+end

data/spec/api_spec.rb

@@ -3,16 +3,32 @@ 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"
+  include_context "cleanup", TIMESTAMP_TAG
 
   prefix = "api_test_#{Time.now.to_i}"
   test_id_1 = "#{prefix}_1"
   test_id_2   = "#{prefix}_2"
+  test_id_3   = "#{prefix}_3"
   before(:all) do
-    @timestamp_tag = "api_test_tag_#{Time.now.to_i}"
+
     @api = Cloudinary::Api
-    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])
+    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])
+    Cloudinary::Uploader.upload("spec/logo.png", :public_id => test_id_3, :tags => [TEST_TAG, TIMESTAMP_TAG], :context => "key=value", :eager =>[:width =>100, :crop =>:scale])
+  end
+
+  after(:all) do
+    # in addition to "cleanup" context
+    unless Cloudinary.config.keep_test_products
+      up = Cloudinary::Api.upload_presets max_results: 500
+      up["presets"].each do |u|
+        tags = u["settings"]["tags"]
+        name = u["name"]
+        if tags =~ /.*#{TIMESTAMP_TAG}.*/
+          Cloudinary::Api.delete_upload_preset(name)
+        end
+      end
+    end
   end
 
   it "should allow listing resource_types" do
@@ -37,18 +53,17 @@ describe Cloudinary::Api do
     expect(result2["resources"][0]["public_id"]).not_to eq(result["resources"][0]["public_id"] )
   end
 
-
   it "should allow listing resources by type" do
     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 match_array([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 => 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["tags"]}.flatten).to include(TEST_TAG, TIMESTAMP_TAG)
     expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
 
@@ -56,7 +71,7 @@ describe Cloudinary::Api do
     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["tags"]}.flatten).to include(TEST_TAG, TIMESTAMP_TAG)
     expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
   
@@ -65,29 +80,35 @@ describe Cloudinary::Api do
     expect(resources.length).to eq(2)
     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["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 start date", :start_at => true do
-    sleep(1)
-    response = Cloudinary::Uploader.upload("spec/logo.png", :tags => TEST_TAG)
-    start_at = Time.parse( response["created_at"]) - 0.5
-    resources = @api.resources(:type=>"upload", :start_at=>start_at, :direction => "asc")["resources"]
-    expect(resources.map{|resource| resource["public_id"]}).to eq([response["public_id"]])
+    start_at = Time.now
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( {[:payload, :start_at] => start_at, [:payload, :direction] => "asc"}))
+    @api.resources(:type=>"upload", :start_at=>start_at, :direction => "asc")
   end
-  
-  it "should allow listing resources in both directions" do
-    asc_resources = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => "asc")["resources"]
-    desc_resources = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => "desc")["resources"]
-    # NOTE: this assumes the full list fits in a page which is the case unless resources with 'api_test' prefix were
-    # uploaded to the account against which this test runs
-    expect(asc_resources.reverse).to eq(desc_resources)
-    asc_resources_alt = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => 1)["resources"]
-    desc_resources_alt = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => -1)["resources"]
-    expect(asc_resources_alt.reverse).to eq(desc_resources_alt)
-    expect(asc_resources).to eq(asc_resources_alt)
-    expect{@api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => "anythingelse")["resources"]}.to raise_error(Cloudinary::Api::BadRequest)
+
+  describe ":direction" do
+
+    it "should accept a string 'desc' and 'asc'" do
+      expected = {
+          :url => /.*\/resources\/image\/tags\/#{TIMESTAMP_TAG}/,
+          [:payload, :direction] => "asc"
+      }
+      expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+
+      @api.resources_by_tag(TIMESTAMP_TAG, :type=>"upload", :direction => "asc")
+    end
+    it "should accept an integer of '1' or '-1'" do
+      expected = {
+          :url => /.*\/resources\/image\/tags\/#{TIMESTAMP_TAG}/,
+          [:payload, :direction] => "-1"
+      }
+      expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+      @api.resources_by_tag(TIMESTAMP_TAG, :type=>"upload", :direction => "-1")
+    end
   end
 
   it "should allow get resource metadata" do
@@ -99,39 +120,24 @@ describe Cloudinary::Api do
   end
   
   it "should allow deleting derived resource" do
-    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test3", :eager=>[:width=>101,:crop=>:scale])
-    resource = @api.resource("api_test3")
-    expect(resource).not_to be_blank
-    expect(resource["derived"].length).to eq(1)
-    derived_resource_id = resource["derived"][0]["id"]
+    derived_resource_id = "derived_id"
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( {[:payload, :derived_resource_ids] => derived_resource_id}))
     @api.delete_derived_resources(derived_resource_id)
-    resource = @api.resource("api_test3")
-    expect(resource).not_to be_blank
-    expect(resource["derived"].length).to eq(0)
   end
 
   it "should allow deleting resources" 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", test_id_2, "api_test3"])
-    expect{@api.resource("api_test3")}.to raise_error(Cloudinary::Api::NotFound)
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( {[:payload, :public_ids] => ["apit_test", "test_id_2", "api_test3"]}))
+    @api.delete_resources(["apit_test", "test_id_2", "api_test3"])
   end
 
   it "should allow deleting resources by prefix" do
-    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test_by_prefix")
-    resource = @api.resource("api_test_by_prefix")
-    expect(resource).not_to be_blank
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( {[:payload, :prefix] => "api_test_by"}))
     @api.delete_resources_by_prefix("api_test_by")
-    expect{@api.resource("api_test_by_prefix")}.to raise_error(Cloudinary::Api::NotFound)
   end
 
   it "should allow deleting resources by tags" do
-    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
+    expect(RestClient::Request).to receive(:execute).with(hash_including( :url => /.*\/tags\/api_test_tag_for_delete$/))
     @api.delete_resources_by_tag("api_test_tag_for_delete")
-    expect{@api.resource("api_test4")}.to raise_error(Cloudinary::Api::NotFound)
   end
 
   it "should allow listing tags" do
@@ -140,8 +146,8 @@ describe Cloudinary::Api do
   end
 
   it "should allow listing tag by prefix" do
-    tags = @api.tags(:prefix=> "api_test_tag")["tags"]
-    expect(tags).to include(@timestamp_tag)
+    tags = @api.tags(:prefix=> 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
@@ -173,10 +179,21 @@ describe Cloudinary::Api do
       expect(transformation["allowed_for_strict"]).to eq(false)
     end
 
+    it "should fetch two different derived images using next_cursor" do
+      result = @api.transformation("c_scale,w_100", :max_results=>1)
+      expect(result["derived"]).not_to be_blank
+      expect(result["derived"].length).to eq(1)
+      expect(result["next_cursor"]).not_to be_blank
+      result2 = @api.transformation("c_scale,w_100", :max_results=>1, :next_cursor=>result["next_cursor"])
+      expect(result2["derived"]).not_to be_blank
+      expect(result2["derived"].length).to eq(1)
+      expect(result2["derived"][0]["id"]).not_to eq(result["derived"][0]["id"] )
+    end
+
     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)
+        @api.create_transformation(public_id, "crop" => "scale", "width" => 102)
         transformation = @api.transformation(public_id)
         expect(transformation).not_to be_blank
         expect(transformation["allowed_for_strict"]).to eq(true)
@@ -186,20 +203,18 @@ describe Cloudinary::Api do
 
       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)
+        expect(RestClient::Request).to receive(:execute).with(deep_hash_value( :url => /.*\/transformations\/#{public_id}/, :method => :delete))
         @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)
+        expected = {
+            :url => /.*\/transformations\/#{public_id}$/,
+            :method => :put,
+            [:payload, :unsafe_update] => "c_scale,w_103"}
+        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
         @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
@@ -210,17 +225,29 @@ describe Cloudinary::Api do
     end
   end
   
-  it "should allow creating and listing upload_presets", :upload_preset => true do
-    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)
+  it "should allow creating upload_presets" do
+    expected = {:url => /.*\/upload_presets$/,
+                [:payload, :name] => "new_preset",
+                [:payload, :folder] => "some_folder"}
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+
+    @api.create_upload_preset(:name => "new_preset", :folder => "some_folder", :tags => [TEST_TAG, TIMESTAMP_TAG])
+  end
+
+  describe "upload_presets" do
+    it 'should not accept parameters' do
+      expected = {
+          :url => /.*\/upload_presets/,
+          [:payload, :next_cursor] => 1234567,
+          [:payload, :max_results] => 10
+      }
+      expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+      @api.upload_presets :next_cursor => 1234567, :max_results => 10
+
+    end
   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", TEST_TAG], :context => {:a => "b", :c => "d"})
+    result = @api.create_upload_preset(:unsigned => true, :folder => "folder", :width => 100, :crop => :scale, :tags => ["a","b","c", TEST_TAG, TIMESTAMP_TAG], :context => {:a => "b", :c => "d"})
     name = result["name"]
     preset = @api.upload_preset(name)
     expect(preset["name"]).to eq(name)
@@ -228,29 +255,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", TEST_TAG])
+    expect(preset["settings"]["tags"]).to eq(["a","b","c", TEST_TAG, TIMESTAMP_TAG])
   end
   
   it "should allow deleting upload_presets", :upload_preset => true do
-    @api.create_upload_preset(:name => "api_test_upload_preset4", :folder => "folder", :tags => TEST_TAG)
+    @api.create_upload_preset(:name => "api_test_upload_preset4", :folder => "folder", :tags => [TEST_TAG, TIMESTAMP_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", :tags => TEST_TAG)["name"]
+    name = @api.create_upload_preset(:folder => "folder", :tags => [TEST_TAG, TIMESTAMP_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, "tags" => [TEST_TAG]})
+    expect(preset["settings"]).to eq({"folder" => "folder", "colors" => true, "disallow_public_id" => true, "tags" => [TEST_TAG, TIMESTAMP_TAG]})
   end
   
   # this test must be last because it deletes (potentially) all dependent transformations which some tests rely on. Excluded by default.
   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)
+    Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test5", :eager=>[:width=>101,:crop=>:scale], :tags => [TEST_TAG, TIMESTAMP_TAG])
     resource = @api.resource("api_test5")
     expect(resource).not_to be_blank
     expect(resource["derived"].length).to eq(1)
@@ -261,7 +288,7 @@ describe Cloudinary::Api do
   end
   
   it "should support setting manual moderation status" do
-    result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual, :tags => TEST_TAG})
+    result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual, :tags => [TEST_TAG, TIMESTAMP_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})
@@ -270,111 +297,53 @@ describe Cloudinary::Api do
   end
     
   it "should support requesting raw conversion" do
-    result = Cloudinary::Uploader.upload("spec/docx.docx", :resource_type => :raw, :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload("spec/docx.docx", :resource_type => :raw, :tags => [TEST_TAG, TIMESTAMP_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", :tags => TEST_TAG)
+    result = Cloudinary::Uploader.upload("spec/logo.png", :tags => [TEST_TAG, TIMESTAMP_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", :tags => TEST_TAG)
-    expect{Cloudinary::Api.update(result["public_id"], {:detection => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :detection] => "adv_face"))
+    Cloudinary::Api.update("public_id", {:detection => "adv_face"})
   end
   
   it "should support requesting auto_tagging" do
-    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/)
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :auto_tagging] => 0.5))
+    Cloudinary::Api.update("public_id", {:auto_tagging => 0.5})
   end
   
   it "should support listing by moderation kind and value" do
-    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"]}
-    expect(approved).to include(result1["public_id"])
-    expect(approved).not_to include(result2["public_id"])
-    expect(approved).not_to include(result3["public_id"])
-    rejected = Cloudinary::Api.resources_by_moderation(:manual, :rejected, :max_results => 1000)["resources"].map{|r| r["public_id"]}
-    expect(rejected).to include(result2["public_id"])
-    expect(rejected).not_to include(result1["public_id"])
-    expect(rejected).not_to include(result3["public_id"])
-    pending = Cloudinary::Api.resources_by_moderation(:manual, :pending, :max_results => 1000)["resources"].map{|r| r["public_id"]}
-    expect(pending).to include(result3["public_id"])
-    expect(pending).not_to include(result1["public_id"])
-    expect(pending).not_to include(result2["public_id"])
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value([:url] => /.*manual\/approved$/, [:payload, :max_results] => 1000))
+    Cloudinary::Api.resources_by_moderation(:manual, :approved, :max_results => 1000)
   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", :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"]).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")
-
-    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)
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:url] => /.*\/folders$/, [:method] => :get))
+    Cloudinary::Api.root_folders
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:url] => /.*\/folders\/test_folder1$/, [:method] => :get))
+    Cloudinary::Api.subfolders("test_folder1")
   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)
+      expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :public_ids] => "api_test_restore", [:url] => /.*\/restore$/))
+      Cloudinary::Api.restore("api_test_restore")
     end
   end
 
-  describe 'mapping' do
+  describe 'create_upload_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")
+      expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :template] => "http://cloudinary.com"))
+      Cloudinary::Api.create_upload_mapping(mapping, :template =>"http://cloudinary.com")
+      expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :template] => "http://res.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("folder" => mapping )
     end
+
+
   end
 end