cloudinary 1.13.0 → 1.13.1

data/spec/spec_helper.rb

@@ -1,273 +0,0 @@
-SUFFIX = ENV['TRAVIS_JOB_ID'] || rand(999999999).to_s
-
-require 'rspec'
-require 'rexml/parsers/ultralightparser'
-require 'nokogiri'
-require 'rspec/version'
-require 'rest_client'
-require 'active_storage/test_helper' if RUBY_VERSION >= '2.2.2'
-require 'cloudinary'
-
-Cloudinary.config.enhance_image_tag = true
-
-DUMMY_CLOUD = "test123"
-TEST_IMAGE_URL = "http://cloudinary.com/images/old_logo.png"
-TEST_IMG = "spec/logo.png"
-TEST_VIDEO = "spec/movie.mp4"
-TEST_RAW = "spec/docx.docx"
-TEST_IMG_W = 241
-TEST_IMG_H = 51
-TEST_TAG = 'cloudinary_gem_test'
-TIMESTAMP_TAG = "#{TEST_TAG}_#{SUFFIX}_#{RUBY_VERSION}_#{ defined? Rails::version ? Rails::version : 'no_rails'}"
-UNIQUE_TEST_FOLDER = "#{TEST_TAG}_#{SUFFIX}_folder"
-NEXT_CURSOR = "db27cfb02b3f69cb39049969c23ca430c6d33d5a3a7c3ad1d870c54e1a54ee0faa5acdd9f6d288666986001711759d10"
-GENERIC_FOLDER_NAME = "some_folder"
-
-# Auth token
-KEY     = "00112233FF99"
-ALT_KEY = "CCBB2233FF00"
-CACHE_KEY = "some_key" + SUFFIX
-
-module ResponsiveTest
-  TRANSFORMATION = {:angle => 45, :crop => "scale"}
-  FORMAT = "png"
-  IMAGE_BP_VALUES = [206, 50]
-  BREAKPOINTS = [100, 200, 300, 399]
-
-end
-Dir[File.join(File.dirname(__FILE__), '/support/**/*.rb')].each {|f| require f}
-
-module RSpec
-  def self.project_root
-    File.join(File.dirname(__FILE__), '..')
-  end
-end
-
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  unless RSpec::Version::STRING.match( /^3/)
-    config.treat_symbols_as_metadata_keys_with_true_values = true
-  end
-  config.run_all_when_everything_filtered = true
-  config.filter_run_excluding :delete_all => true
-end
-
-RSpec.shared_context "cleanup" do |tag|
-  tag ||= TEST_TAG
-  after :all do
-    Cloudinary::Api.delete_resources_by_tag(tag) unless Cloudinary.config.keep_test_products
-  end
-end
-
-module Cloudinary
-  def self.reset_config
-    @@config = nil
-  end
-
-end
-
-
-CALLS_SERVER_WITH_PARAMETERS = "calls server with parameters"
-RSpec.shared_examples CALLS_SERVER_WITH_PARAMETERS do |expected|
-  expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-end
-
-# Create a regexp with the given +tag+ name.
-def html_tag_matcher( tag)
-  /<#{tag}([\s]+([-[:word:]]+)[\s]*\=\s*\"([^\"]*)\")*\s*>.*<\s*\/#{tag}\s*>/
-end
-
-# Represents an HTML tag
-class TestTag
-  attr_accessor :element
-  # Creates a new +TestTag+ from a given +element+ string
-  def initialize(element)
-    @html_string = element
-    @element = valid_tag(element) unless element.is_a? Array
-
-  end
-
-  def name
-    @element.name
-  end
-
-  def attributes
-    @element.attributes
-  end
-
-  def children
-    @element.children
-  end
-  # Parses a given +tag+ in string format
-  def valid_tag(tag)
-    parser = Nokogiri::HTML::Document.parse( tag)
-    # Parsed code will be strctured as either html>body>tag or html>head>tag
-    parser.children[1].children[0].children[0]
-  end
-
-  # Returns attribute named +symbol_or_string+
-  def [](symbol_or_string)
-    begin
-      attributes[symbol_or_string.to_s].value
-    rescue
-      nil
-    end
-  end
-
-  def method_missing(symbol, *args)
-    if (m = /children_by_(\w+)/.match(symbol.to_s)) and !args.empty?
-      return unless children
-      children.select{ |c| c[m[1]] == args[0]}
-    else
-      super
-    end
-  end
-
-  def ==(other)
-    case other
-    when String
-      @text == other
-    else
-      other.respond_to?( :text) &&
-        other.respond_to?( :name) &&
-        other.respond_to?( :attributes) &&
-        other.respond_to?( :children) &&
-        @text == other.text &&
-        @name == other.name &&
-        @attributes == other.attributes &&
-        @children == other.children
-    end
-  end
-end
-
-RSpec::Matchers.define :produce_url do |expected_url|
-  match do |params|
-    public_id, options = params
-    actual_options = options.clone
-    @url = Cloudinary::Utils.cloudinary_url(public_id, actual_options)
-    values_match? expected_url, @url
-  end
-  failure_message do |actual|
-    "expected #{actual} to\nproduce: #{expected_url}\nbut got: #{@url}"
-  end
-end
-
-RSpec::Matchers.define :mutate_options_to do |expected_options|
-  match do |params|
-    public_id, options = params
-    options = options.clone
-    Cloudinary::Utils.cloudinary_url(public_id, options)
-    @actual = options
-    values_match? expected_options, @actual
-  end
-end
-
-RSpec::Matchers.define :empty_options do
-  match do |params|
-    public_id, options = params
-    options = options.clone
-    Cloudinary::Utils.cloudinary_url(public_id, options)
-    options.empty?
-  end
-end
-
-# Verify that the given URL can be served by Cloudinary by fetching the resource from the server
-RSpec::Matchers.define :be_served_by_cloudinary do
-  match do |url|
-    if url.is_a? Array
-      url, options = url
-      url = Cloudinary::Utils.cloudinary_url(url, options.clone)
-      if Cloudinary.config.upload_prefix
-        res_prefix_uri = URI.parse(Cloudinary.config.upload_prefix)
-        res_prefix_uri.path = '/res'
-        url.gsub!(/https?:\/\/res.cloudinary.com/, res_prefix_uri.to_s)
-      end
-    end
-    code = 0
-    @url = url
-    RestClient.get @url do |response, request, result|
-      @result = result
-      code = response.code
-    end
-    values_match? 200, code
-  end
-
-  failure_message do |actual|
-    if @result
-      "Couldn't serve #{actual}. #{@result["status"]}: #{@result["x-cld-error"]}"
-    else
-      "Couldn't serve #{actual}."
-    end
-  end
-  failure_message_when_negated do |actual|
-    if @result
-      "Expected #{@url} not to be served by cloudinary. #{@result["status"]}: #{@result["x-cld-error"]}"
-    else
-      "Expected #{@url} not to be served by cloudinary."
-    end
-
-  end
-end
-
-def deep_fetch(hash, path)
-  Array(path).reduce(hash) { |h, key| h && h.fetch(key, nil) }
-end
-
-# Matches deep values in the actual Hash, disregarding other keys and values.
-# @example
-#   expect( {:foo => { :bar => 'foobar'}}).to have_deep_hash_values_of( [:foo, :bar] => 'foobar')
-#   expect( foo_instance).to receive(:bar_method).with(deep_hash_values_of([:foo, :bar] => 'foobar'))
-RSpec::Matchers.define :deep_hash_value do |expected|
-  match do |actual|
-    expected.all? do |path, value|
-      Cloudinary.values_match? value, deep_fetch(actual, path)
-    end
-  end
-end
-
-RSpec::Matchers.alias_matcher :have_deep_hash_values_of, :deep_hash_value
-
-module Cloudinary
-  # @api private
-  def self.values_match?(expected, actual)
-    if Hash === actual
-      return hashes_match?(expected, actual) if Hash === expected
-    elsif Array === expected && Enumerable === actual && !(Struct === actual)
-      return arrays_match?(expected, actual.to_a)
-    elsif Regexp === expected
-      return expected.match actual.to_s
-    end
-
-
-    return true if actual == expected
-
-    begin
-      expected === actual
-    rescue ArgumentError
-      # Some objects, like 0-arg lambdas on 1.9+, raise
-      # ArgumentError for `expected === actual`.
-      false
-    end
-  end
-
-  # @private
-  def self.arrays_match?(expected_list, actual_list)
-    return false if expected_list.size != actual_list.size
-
-    expected_list.zip(actual_list).all? do |expected, actual|
-      values_match?(expected, actual)
-    end
-  end
-
-  # @private
-  def self.hashes_match?(expected_hash, actual_hash)
-    return false if expected_hash.size != actual_hash.size
-
-    expected_hash.all? do |expected_key, expected_value|
-      actual_value = actual_hash.fetch(expected_key) { return false }
-      values_match?(expected_value, actual_value)
-    end
-  end
-
-  private_class_method :arrays_match?, :hashes_match?
-end

data/spec/storage_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-
-module CarrierWave
-  module Storage
-    class Abstract
-      def initialize(uploader)
-        @uploader = uploader
-      end
-
-      attr_accessor :uploader
-    end
-  end
-  class SanitizedFile; end
-end
-
-RSpec.describe Cloudinary::CarrierWave::Storage do
-  describe '#store_cloudinary_identifier' do
-    let(:column) { 'example_field' }
-    let(:model) { double :model, _mounter: mount, write_attribute: true }
-    let(:mount) { double :mount, serialization_column: column }
-    let(:storage) { Cloudinary::CarrierWave::Storage.new(uploader) }
-    let(:store_identifier) { storage.store_cloudinary_identifier('1', 'test.png') }
-    let(:uploader) { double :uploader, model: model, mounted_as: :example, use_extended_identifier?: false }
-
-    describe 'when the ORM is Neo4j 5 and above' do
-      before { stub_const('Neo4j::VERSION', '5.0') }
-
-      subject! { store_identifier }
-
-      it 'writes the name to the datastore without triggering validations' do
-        expect(model).to have_received(:write_attribute).with(column, 'v1/test.png')
-      end
-    end
-
-    describe 'when the ORM is Neo4j 4' do
-      before { stub_const('Neo4j::VERSION', '4.0') }
-
-      it 'raises an unsupported exception' do
-        expect { store_identifier }.to raise_error(CloudinaryException)
-      end
-    end
-  end
-end

data/spec/streaminig_profiles_api_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-
-describe Cloudinary::Api do
-  PREDEFINED_PROFILES = %w(4k full_hd hd sd full_hd_wifi full_hd_lean hd_lean)
-  break puts('Please setup environment for api test to run') if Cloudinary.config.api_secret.blank?
-  include_context 'cleanup', TIMESTAMP_TAG
-
-  prefix = TEST_TAG + "_#{Time.now.to_i}"
-  test_id_1 = "#{prefix}_1"
-  test_id_2 = "#{prefix}_2"
-  test_id_3 = "#{prefix}_3"
-  before(:all) do
-
-    @api = Cloudinary::Api
-  end
-
-  describe 'create_streaming_profile' do
-    it 'should create a streaming profile with representations' do
-      result = @api.create_streaming_profile test_id_1, :representations =>
-          [{:transformation => {:crop => 'scale', :width => '1200', :height => '1200', :bit_rate => '5m'}}]
-      expect(result).not_to be_blank
-    end
-    it 'should create a streaming profile with an array of transformation' do
-      result = @api.create_streaming_profile test_id_1 + 'a', :representations =>
-          [{:transformation => [{:crop => 'scale', :width => '1200', :height => '1200', :bit_rate => '5m'}]}]
-      expect(result).not_to be_blank
-    end
-  end
-
-  describe 'list_streaming_profile' do
-    it 'should list streaming profile' do
-      result = @api.list_streaming_profiles
-      expect(result).to have_key('data')
-      expect(result['data'].map{|p| p['name']}).to include(*PREDEFINED_PROFILES)
-    end
-  end
-
-  describe 'delete_streaming_profile' do
-    it 'should delete a streaming profile' do
-      result = @api.create_streaming_profile test_id_2, :representations =>
-          [{:transformation => {:crop => 'scale', :width => '1200', :height => '1200', :bit_rate => '5m'}}]
-      expect(result).not_to be_blank
-      result = @api.delete_streaming_profile test_id_2
-      expect(result).to have_key('message')
-      expect(result['message']).to eq('deleted')
-      result = @api.list_streaming_profiles
-      expect(result['data'].map{|p| p['name']}).not_to include(test_id_2)
-    end
-  end
-
-  describe 'get_streaming_profile' do
-    it 'should get a specific streaming profile' do
-      result = @api.get_streaming_profile(PREDEFINED_PROFILES[1])
-      expect(result['data'].keys).to include('name', 'display_name', 'representations')
-    end
-  end
-
-  describe 'update_streaming_profile' do
-    it 'should create a streaming profile with representations' do
-      result = @api.create_streaming_profile test_id_3, :representations =>
-          [{:transformation => {:crop => 'scale', :width => '1200', :height => '1200', :bit_rate => '5m'}}]
-      expect(result).not_to be_blank
-      result = @api.update_streaming_profile test_id_3, :representations =>
-          [{:transformation => {:crop => 'scale', :width => '1000', :height => '1000', :bit_rate => '4m'}}]
-      expect(result).not_to be_blank
-      result = @api.get_streaming_profile(test_id_3)
-      result = result['data']
-      expect(result['representations'].length).to eq(1)
-      # Notice transformation is always returned as an array; numeric values represented as numbers, not strings
-      expect(result['representations'][0]).to eq({'transformation' => ['crop' => 'scale', 'width' => 1000, 'height' => 1000, 'bit_rate' => '4m']})
-    end
-  end
-end

data/spec/support/helpers/temp_file_helpers.rb

@@ -1,22 +0,0 @@
-module Helpers
-  module TempFileHelpers
-    def clean_up_temp_files!
-      FileUtils.remove_entry temp_root
-    end
-
-    def temp_root
-      @temp_root ||= Dir.mktmpdir 'test_root'
-    end
-
-    def copy_root_to_temp(source)
-      source = File.join(RSpec.project_root, source) unless Pathname.new(source).directory?
-      FileUtils.copy_entry source, temp_root
-    end
-
-    def copy_file_to_temp(source, dest)
-      dest_path = File.join(temp_root, dest)
-      FileUtils.mkdir_p(File.dirname(dest_path))
-      FileUtils.copy_entry(File.join(RSpec.project_root, source), dest_path)
-    end
-  end
-end

data/spec/support/shared_contexts/rake.rb

@@ -1,19 +0,0 @@
-require "rake"
-
-# From https://robots.thoughtbot.com/test-rake-tasks-like-a-boss
-shared_context "rake" do
-  let(:rake)      { Rake::Application.new }
-  let(:task_name) { self.class.top_level_description }
-  let(:task_path) { "lib/tasks/#{task_name.split(":").first}" }
-  subject         { rake[task_name] }
-
-  def loaded_files_excluding_current_rake_file
-     $".reject {|file| file == Pathname.new(RSpec.project_root).join("#{task_path}.rake").to_s }
-  end
-
-  before do
-    Rake.application = rake
-    Rake.application.rake_require(task_path, [RSpec.project_root], loaded_files_excluding_current_rake_file)
-    Rake::Task.define_task(:environment)
-  end
-end

data/spec/uploader_spec.rb

@@ -1,409 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-
-RSpec.configure do |c|
-  c.filter_run_excluding :large => true
-end
-
-describe Cloudinary::Uploader do
-  break puts("Please setup environment for api test to run") if Cloudinary.config.api_secret.blank?
-  include_context "cleanup", TIMESTAMP_TAG
-
-  it "should successfully upload file" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["width"]).to eq(TEST_IMG_W)
-    expect(result["height"]).to eq(TEST_IMG_H)
-    expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>result["public_id"], :version=>result["version"]}, Cloudinary.config.api_secret)
-    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(TEST_IMG), :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["width"]).to eq(TEST_IMG_W)
-  end
-
-  it "should successfully upload file by url" do
-    result = Cloudinary::Uploader.upload("http://cloudinary.com/images/old_logo.png", :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["width"]).to eq(TEST_IMG_W)
-    expect(result["height"]).to eq(TEST_IMG_H)
-    expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>result["public_id"], :version=>result["version"]}, Cloudinary.config.api_secret)
-    expect(result["signature"]).to eq(expected_signature)
-  end
-
-  it "should successfully upload file asynchronously" do
-    result = Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :async => true)
-    expect(result["status"]).to eq("pending")
-  end
-
-  it "should support the quality_analysis parameter" do
-    result = Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :quality_analysis => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result).to have_key("quality_analysis")
-    expect(result["quality_analysis"]).to have_key("focus")
-  end
-
-  it "should support the quality_override parameter" do
-    ['auto:advanced', 'auto:best', '80:420', 'none'].each do |q|
-      expected = {[:payload, :quality_override] => q}
-      expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-      Cloudinary::Uploader.upload Pathname.new(TEST_IMG), :quality_override => q
-    end
-  end
-
-  it "should support the cinemagraph_analysis parameter for upload" do
-    expected = {
-        [:payload, :cinemagraph_analysis] => 1,
-        [:method] => :post
-    }
-    expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-    Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :cinemagraph_analysis => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
-  end
-
-  it "should support the cinemagraph_analysis parameter for explicit" do
-    expected = {
-        [:payload, :cinemagraph_analysis] => 1,
-        [:method] => :post
-    }
-    expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-    Cloudinary::Uploader.explicit('sample', :type => "upload", :cinemagraph_analysis => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
-  end
-
-  describe '.rename' do
-    before(:all) do
-      @result        = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])
-      @resource_1_id = @result["public_id"]
-      @resource_1_type = @result["type"]
-      result         = Cloudinary::Uploader.upload("spec/favicon.ico", :tags => [TEST_TAG, TIMESTAMP_TAG])
-      @resource_2_id = result["public_id"]
-    end
-
-    it 'should rename a resource' do
-      Cloudinary::Uploader.rename(@resource_1_id, @resource_1_id+"2")
-      expect(Cloudinary::Api.resource(@resource_1_id+"2")).not_to be_nil
-      @resource_1_id = @resource_1_id+"2" # will not update if expect fails
-    end
-    it 'should not allow renaming to an existing ID' do
-      id             = @resource_2_id
-      @resource_2_id = @resource_1_id+"2" # if rename doesn't fail, this is the new ID
-      expect { Cloudinary::Uploader.rename(id, @resource_1_id+"2") }.to raise_error(CloudinaryException)
-      @resource_2_id = id
-    end
-    it 'should allow changing type of an uploaded resource' do
-      id = @resource_2_id
-      from_type = @resource_1_type
-      to_type = "private"
-      Cloudinary::Uploader.rename(id, id, :type => from_type, :to_type => to_type)
-      expect(Cloudinary::Api.resource(id, type: to_type)).to_not be_empty
-      Cloudinary::Uploader.rename(id, id, :type => to_type, :to_type => from_type)
-    end
-    context ':overwrite => true' do
-      it 'should rename to an existing ID' do
-        new_id = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])["public_id"]
-        Cloudinary::Uploader.rename(@resource_2_id, new_id, :overwrite => true)
-        expect(Cloudinary::Api.resource(new_id)["format"]).to eq("ico")
-        @resource_2_id = new_id # will not update if expect fails
-      end
-    end
-    context ':invalidate => true' do
-      it 'should notify the server to invalidate the resource in the CDN' do
-        # Can't test the result, so we just verify the parameter is send to the server
-        expected ={
-            :url => /.*\/rename$/,
-            [:payload, :invalidate] => 1,
-            [:payload, :from_public_id] => @resource_2_id,
-            [:payload, :to_public_id] => @resource_2_id+"2"
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-        Cloudinary::Uploader.rename(@resource_2_id, @resource_2_id+"2", :invalidate => true) # will not affect the server
-      end
-
-    end
-  end
-
-  it "should support explicit" do
-    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :public_id] => "sample", [:payload, :eager] => "c_scale,w_2.0"))
-    result = Cloudinary::Uploader.explicit("sample", :type=>"upload", :eager=>[{:crop=>"scale", :width=>"2.0"}])
-  end
-
-  it "should support eager" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :eager =>[{ :crop =>"scale", :width =>"2.0"}], :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["eager"].length).to be(1)
-    expect(result).to have_deep_hash_values_of(["eager", 0, "transformation"] => "c_scale,w_2.0")
-    result = Cloudinary::Uploader.upload(TEST_IMG, :eager =>"c_scale,w_2.0", :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["eager"].length).to be(1)
-    expect(result).to have_deep_hash_values_of(["eager", 0, "transformation"] => "c_scale,w_2.0")
-    result = Cloudinary::Uploader.upload(TEST_IMG, :eager =>[
-                          "c_scale,w_2.0",
-                          { :crop =>"crop", :width =>"0.5", :format => "tiff"},
-                          [[{:crop =>"crop", :width =>"0.5"},{:angle =>90}]],
-                          [[{:crop =>"crop", :width =>"0.5"},{:angle =>90}],"tiff"]
-                      ], :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["eager"].length).to be(4)
-    expect(result).to have_deep_hash_values_of(
-                          ["eager", 0, "transformation"] => "c_scale,w_2.0",
-                          ["eager", 1, "transformation"] => "c_crop,w_0.5/tiff",
-                          ["eager", 2, "transformation"] => "c_crop,w_0.5/a_90",
-                          ["eager", 3, "transformation"] => "c_crop,w_0.5/a_90/tiff"
-                      )
-  end
-
-  it "should support headers" do
-    Cloudinary::Uploader.upload(TEST_IMG, :headers =>["Link: 1"], :tags => [TEST_TAG, TIMESTAMP_TAG])
-    Cloudinary::Uploader.upload(TEST_IMG, :headers =>{ "Link" => "1"}, :tags => [TEST_TAG, TIMESTAMP_TAG])
-  end
-
-  it "should successfully generate text image" do
-    result = Cloudinary::Uploader.text("hello world", :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["width"]).to be > 1
-    expect(result["height"]).to be > 1
-  end
-
-  describe "tag" do
-    describe "add_tag" do
-      it "should correctly add tags" do
-        expected ={
-            :url => /.*\/tags/,
-            [:payload, :tag] => "new_tag",
-            [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
-            [:payload, :command] => "add"
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-
-        Cloudinary::Uploader.add_tag( "new_tag", ["some_public_id1", "some_public_id2"])
-      end
-    end
-
-    describe "remove_tag" do
-      it "should correctly remove tag" do
-        expected ={
-            :url => /.*\/tags/,
-            [:payload, :tag] => "tag",
-            [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
-            [:payload, :command] => "remove"
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-
-        Cloudinary::Uploader.remove_tag("tag", ["some_public_id1", "some_public_id2"])
-      end
-    end
-
-    describe "replace_tag" do
-      it "should correctly replace tag" do
-        expected ={
-            :url => /.*\/tags/,
-            [:payload, :tag] => "tag",
-            [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
-            [:payload, :command] => "replace"
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-
-        Cloudinary::Uploader.replace_tag("tag", ["some_public_id1", "some_public_id2"])
-      end
-    end
-
-    describe "remove_all_tags" do
-      it "should correctly remove all tags" do
-        expected ={
-            :url => /.*\/tags/,
-            [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
-            [:payload, :command] => "remove_all"
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-
-        Cloudinary::Uploader.remove_all_tags(["some_public_id1", "some_public_id2"])
-      end
-    end
-
-  end
-
-
-  describe "context" do
-    describe "add_context" do
-      it "should correctly add context" do
-        expected ={
-            :url => /.*\/context/,
-            [:payload, :context] => "key1=value1|key2=val\\|ue2",
-            [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
-            [:payload, :command] => "add"
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-
-        Cloudinary::Uploader.add_context( {:key1 => "value1", :key2 => "val|ue2"}, ["some_public_id1", "some_public_id2"])
-      end
-    end
-
-    describe "remove_all_context" do
-      it "should correctly remove all context" do
-        expected ={
-            :url => /.*\/context/,
-            [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
-            [:payload, :command] => "remove_all",
-            [:payload, :type] => "private"
-
-        }
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-
-        Cloudinary::Uploader.remove_all_context(["some_public_id1", "some_public_id2"], :type => "private")
-      end
-    end
-
-  end
-
-
-  
-  it "should correctly handle unique_filename" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :use_filename => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["public_id"]).to match(/logo_[a-zA-Z0-9]{6}/)
-    result = Cloudinary::Uploader.upload(TEST_IMG, :use_filename => true, :unique_filename => false, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["public_id"]).to eq("logo")
-  end
-  
-  it "should allow whitelisted formats if allowed_formats", :allowed=>true do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["png"], :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["format"]).to eq("png")
-  end
-  
-  it "should prevent non whitelisted formats from being uploaded if allowed_formats is specified", :allowed=>true do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["jpg"], :tags => [TEST_TAG, TIMESTAMP_TAG])}.to raise_error(CloudinaryException)
-  end
-  
-  it "should allow non whitelisted formats if type is specified and convert to that type", :allowed=>true do
-    result = Cloudinary::Uploader.upload(TEST_IMG, :allowed_formats => ["jpg"], :format => "jpg", :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["format"]).to eq("jpg")
-  end
-  
-  it "should allow sending face coordinates" do
-    coordinates = [[120, 30, 109, 150], [121, 31, 110, 151]]
-    result_coordinates = [[120, 30, 109, 51], [121, 31, 110, 51]] # actual boundaries fitted by the server
-    result = Cloudinary::Uploader.upload(TEST_IMG, { :face_coordinates => coordinates, :faces => true, :tags => [TEST_TAG, TIMESTAMP_TAG]})
-    expect(result["faces"]).to eq(result_coordinates)
-
-    different_coordinates = [[122, 32, 111, 152]]
-    Cloudinary::Uploader.explicit(result["public_id"], {:face_coordinates => different_coordinates, :faces => true, :type => "upload", :tags => [TEST_TAG, TIMESTAMP_TAG]})
-    info = Cloudinary::Api.resource(result["public_id"], {:faces => true})
-    expect(info["faces"]).to eq(different_coordinates)
-  end
-  
-  it "should allow sending context" do
-    context = {"key1"=>'value1', "key2" => 'valu\e2', "key3" => 'val=u|e3', "key4" => 'val\=ue'}
-    result = Cloudinary::Uploader.upload(TEST_IMG, { :context => context, :tags => [TEST_TAG, TIMESTAMP_TAG]})
-    info = Cloudinary::Api.resource(result["public_id"], {:context => true})
-    expect(info["context"]).to eq({"custom" => context})
-  end
-  
-  it "should support requesting manual moderation" do
-    result = Cloudinary::Uploader.upload(TEST_IMG, { :moderation => :manual, :tags => [TEST_TAG, TIMESTAMP_TAG]})
-    expect(result["moderation"][0]["status"]).to eq("pending")
-    expect(result["moderation"][0]["kind"]).to eq("manual")
-  end
-  
-  it "should support requesting ocr anlysis" do
-    expect(RestClient::Request).to receive(:execute) do |options|
-      expect(options[:payload][:ocr]).to eq(:adv_ocr)
-    end
-    Cloudinary::Uploader.upload(TEST_IMG, { :ocr => :adv_ocr, :tags => [TEST_TAG, TIMESTAMP_TAG]})
-  end
-    
-  it "should support requesting raw conversion" do
-    expect{Cloudinary::Uploader.upload(TEST_RAW, {:resource_type => :raw, :raw_convert => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid|is invalid/)
-  end
-  
-  it "should support requesting categorization" do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, { :categorization => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid|is not valid/)
-  end
-  
-  it "should support requesting detection" do
-    expect{Cloudinary::Uploader.upload(TEST_IMG, { :detection => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Detection is invalid/)
-  end
-
-  it "should support upload_large", :large => true do
-    io = StringIO.new
-    header = "BMJ\xB9Y\x00\x00\x00\x00\x00\x8A\x00\x00\x00|\x00\x00\x00x\x05\x00\x00x\x05\x00\x00\x01\x00\x18\x00\x00\x00\x00\x00\xC0\xB8Y\x00a\x0F\x00\x00a\x0F\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\xFF\x00\x00\x00\x00\x00\x00\xFFBGRs\x00\x00\x00\x00\x00\x00\x00\x00T\xB8\x1E\xFC\x00\x00\x00\x00\x00\x00\x00\x00fff\xFC\x00\x00\x00\x00\x00\x00\x00\x00\xC4\xF5(\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-    io.puts(header)
-    5880000.times{ io.write("\xFF") }
-    io.rewind
-    result = Cloudinary::Uploader.upload_large(io, :chunk_size => 5243000, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["resource_type"]).to eq('raw')
-    io.rewind
-    result = Cloudinary::Uploader.upload_large(io, :resource_type => 'image', :chunk_size => 5243000, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result["resource_type"]).to eq('image')
-    expect(result["width"]).to eq(1400)
-    expect(result["height"]).to eq(1400)
-    expect(result["format"]).to eq("bmp")
-  end
-
-  it "should allow fallback of upload large with remote url to regular upload" do
-    file = "http://cloudinary.com/images/old_logo.png"
-    result = Cloudinary::Uploader.upload_large(file, :chunk_size => 5243000, :tags => [TEST_TAG, TIMESTAMP_TAG])
-    expect(result).to_not be_nil
-    expect(result["width"]).to eq(TEST_IMG_W)
-    expect(result["height"]).to eq(TEST_IMG_H)
-  end
-
-  it "should include special headers in upload_large" do
-    expect(RestClient::Request).to receive(:execute) do |options|
-      expect(options[:headers]["Content-Range"]).to_not be_empty
-      expect(options[:headers]["X-Unique-Upload-Id"]).to_not be_empty
-    end
-    Cloudinary::Uploader.upload_large(TEST_IMG, { :tags => [TEST_TAG, TIMESTAMP_TAG]})
-  end
-  
-  context "unsigned" do
-    after do
-      Cloudinary.class_variable_set(:@@config, nil)
-    end
-    
-    it "should support unsigned uploading using presets", :upload_preset => true do
-      preset = Cloudinary::Api.create_upload_preset(:folder => "test_folder_upload", :unsigned => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
-
-      Cloudinary.config.api_key = nil
-      Cloudinary.config.api_secret = nil
-
-      result = Cloudinary::Uploader.unsigned_upload(TEST_IMG, preset["name"], :tags => [TEST_TAG, TIMESTAMP_TAG])
-      expect(result["public_id"]).to match(/^test_folder_upload\/[a-z0-9]+$/)
-
-      Cloudinary.class_variable_set(:@@config, nil)
-
-    end
-  end
-
-  describe ":timeout" do
-    before do
-      @timeout = Cloudinary.config.timeout
-      Cloudinary.config.timeout = 0.01
-    end
-    after do
-      Cloudinary.config.timeout = @timeout
-    end
-
-    it "should fail if timeout is reached" do
-      expect{Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :tags => [TEST_TAG, TIMESTAMP_TAG])}.to raise_error(RestClient::RequestTimeout)
-    end
-  end
-
-  context ":responsive_breakpoints" do
-    context ":create_derived with transformation and format conversion" do
-      expected ={
-          :url => /.*\/upload$/,
-          [:payload, :responsive_breakpoints] => %r("transformation":"e_sepia/jpg"),
-          [:payload, :responsive_breakpoints] => %r("transformation":"gif"),
-          [:payload, :responsive_breakpoints] => %r("create_derived":true)
-      }
-      it 'should return a proper responsive_breakpoints hash in the response' do
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-        Cloudinary::Uploader.upload(TEST_IMG, responsive_breakpoints:[{transformation:{effect: "sepia"}, format:"jpg", bytes_step:20000, create_derived: true, :min_width => 200, :max_width => 1000, :max_images => 20},{format:"gif", create_derived:true, bytes_step:20000, :min_width => 200, :max_width => 1000, :max_images => 20}], :tags => [TEST_TAG, TIMESTAMP_TAG])
-      end
-    end
-  end
-
-
-
-  describe 'explicit' do
-    context ":invalidate" do
-      it 'should pass the invalidate value to the server' do
-        expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :invalidate] => 1))
-        Cloudinary::Uploader.explicit("cloudinary", :type=>"twitter_name", :eager=>[{:crop=>"scale", :width=>"2.0"}], :invalidate => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
-      end
-    end
-  end
-end
-