cloudinary 1.11.1 → 1.18.0

data/spec/cloudinary_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-
-describe Cloudinary do
-  before :all do
-    @user_platform = Cloudinary.user_platform
-  end
-  after :all do
-    Cloudinary.user_platform = @user_platform
-  end
-
-  it 'should add a user platform to USER_AGENT' do
-    Cloudinary.user_platform = "Spec/1.0 (Test)"
-    expect(Cloudinary.USER_AGENT).to match( %r"Spec\/1.0 \(Test\) CloudinaryRuby/[\d.]+")
-
-  end
-
-  describe 'config' do
-    before do
-      @url_backup = ENV["CLOUDINARY_URL"]
-    end
-    after do
-      ENV["CLOUDINARY_URL"] = @url_backup
-      Cloudinary::config_from_url @url_backup
-    end
-    it "should allow nested values in CLOUDINARY_URL" do
-      ENV["CLOUDINARY_URL"]  = "cloudinary://key:secret@test123?foo[bar]=value"
-      Cloudinary::config_from_url ENV["CLOUDINARY_URL"]
-      expect(Cloudinary::config.foo.bar).to eq 'value'
-    end
-  end
-end

data/spec/data/sync_static/app/assets/javascripts/1.coffee

@@ -1 +0,0 @@
-coffeescript = true

data/spec/data/sync_static/app/assets/javascripts/1.js

@@ -1 +0,0 @@
-{ alert("I am javascript!");}

data/spec/data/sync_static/app/assets/stylesheets/1.css

@@ -1,3 +0,0 @@
-p#css {
-    color: red;
-}

data/spec/image_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-require 'action_view'
-require 'cloudinary/helper'
-
-COMMON_TRANS = {
-    effect: 'sepia',
-    cloud_name: DUMMY_CLOUD,
-    client_hints: false
-}
-COMMON_TRANSFORMATION_STR = 'e_sepia'
-
-def expected_srcset(public_id, path, common_trans, breakpoints)
-  breakpoints.map {|width| "#{path}/#{common_trans}/c_scale,w_#{width}/#{public_id} #{width}w"}.join(', ')
-end
-
-describe 'Responsive breakpoints' do
-
-
-  before :all do
-    # Test the helper in the context it runs in in production
-    ActionView::Base.send :include, CloudinaryHelper
-
-  end
-
-  before :each do
-    Cloudinary.reset_config
-  end
-
-  let(:cloud_name) {COMMON_TRANS[:cloud_name]}
-  let(:root_path) {"http://res.cloudinary.com/#{cloud_name}"}
-  let(:upload_path) {"#{root_path}/image/upload"}
-
-  let(:options) {COMMON_TRANS}
-  # let(:helper) {helper_class.new}
-  let(:helper) {
-    ActionView::Base.new
-  }
-  let(:test_tag) {TestTag.new(helper.cl_image_tag('sample.jpg', options))}
-  describe 'srcset' do
-    it 'Should create srcset attribute with provided breakpoints' do
-      options[:srcset] = {:breakpoints => ResponsiveTest::BREAKPOINTS}
-      srcset = test_tag['srcset'].split(", ")
-      expect(srcset.length).to eq(4)
-      expected_tag = expected_srcset('sample.jpg', upload_path, COMMON_TRANSFORMATION_STR, ResponsiveTest::BREAKPOINTS)
-      expect(test_tag['srcset']).to match(expected_tag)
-    end
-    it "Support srcset attribute defined by min width max width and max images" do
-      options[:srcset] = {:min_width => ResponsiveTest::BREAKPOINTS.first,
-                          :max_width => ResponsiveTest::BREAKPOINTS.last,
-                          :max_images => ResponsiveTest::BREAKPOINTS.length}
-
-      expected_tag = expected_srcset('sample.jpg', upload_path, COMMON_TRANSFORMATION_STR, ResponsiveTest::BREAKPOINTS)
-      expect(test_tag['srcset']).to match(expected_tag)
-    end
-    it "should generate a single srcset image" do
-      options[:srcset] = {:min_width => ResponsiveTest::BREAKPOINTS.first,
-                          :max_width => ResponsiveTest::BREAKPOINTS.last,
-                          :max_images => 1}
-
-      expected_tag = expected_srcset('sample.jpg', upload_path, COMMON_TRANSFORMATION_STR, [ResponsiveTest::BREAKPOINTS.last])
-      expect(test_tag['srcset']).to match(expected_tag)
-    end
-    it "Should support custom transformation for srcset items" do
-      options[:srcset] = {
-          :breakpoints => ResponsiveTest::BREAKPOINTS,
-          :transformation => {:crop => 'crop', :width => 10, :height => 20}
-      }
-
-      expected_tag = expected_srcset('sample.jpg', upload_path, 'c_crop,h_20,w_10', ResponsiveTest::BREAKPOINTS)
-      expect(test_tag['srcset']).to match(expected_tag)
-    end
-    it "Should populate sizes attribute" do
-      options[:srcset] = {
-          :breakpoints => ResponsiveTest::BREAKPOINTS,
-          :sizes => true
-      }
-      expected_sizes_attr = '(max-width: 100px) 100px, (max-width: 200px) 200px, ' +
-          '(max-width: 300px) 300px, (max-width: 399px) 399px'
-      expect(test_tag['sizes']).to match(expected_sizes_attr)
-    end
-    it "Should support srcset string value" do
-      raw_src_set = "some srcset data as is"
-      options[:srcset] = raw_src_set
-
-      expect(test_tag['srcset']).to match(raw_src_set)
-    end
-    it "Should remove width and height attributes in case srcset is specified, but passed to transformation" do
-      options.merge!({
-                         :srcset => {
-                             :breakpoints => ResponsiveTest::BREAKPOINTS,
-                         },
-                         :width => 500,
-                         :height => 500,
-                         :crop => 'scale'
-
-                     })
-
-      expected_tag = expected_srcset('sample.jpg', upload_path, 'c_scale,e_sepia,h_500,w_500', ResponsiveTest::BREAKPOINTS)
-      expect(test_tag['srcset']).to match(expected_tag)
-      expect(test_tag['width']).to be_nil
-    end
-
-  end
-
-
-end

data/spec/rake_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-
-require 'tmpdir'
-require 'pathname'
-
-describe 'cloudinary:sync_static' do
-  include_context 'rake' # context needs to have the exact rake task as name
-  include Helpers::TempFileHelpers
-
-  before(:all) do
-    copy_root_to_temp('spec/data/sync_static/')
-
-    # Reuse some existing spec assets so as not to add weight to the project
-    copy_file_to_temp('spec/logo.png', 'app/assets/images/logo1.png')
-    copy_file_to_temp('spec/logo.png', 'app/assets/images/logo2.png')
-    copy_file_to_temp('samples/basic/lake.jpg', 'app/assets/images/lake1.jpg')
-    copy_file_to_temp('samples/basic/lake.jpg', 'public/images/lake2.jpg')
-  end
-
-  after(:all) do
-    clean_up_temp_files!
-  end
-
-  before (:each) do
-    allow(Cloudinary).to receive(:app_root).and_return(Pathname.new(temp_root))
-    Cloudinary::Static.send(:reset_static_file_config!)
-  end
-
-  after (:each) do
-    # destroy all uploaded assets
-    Cloudinary::Static.send(:build_metadata).each do |_, data|
-      Cloudinary::Uploader.destroy(data['public_id'], {:type => :asset})
-    end
-    # delete metadata_file_path
-    FileUtils.rm_f(Cloudinary::Static.send(:metadata_file_path))
-    FileUtils.rm_f(Cloudinary::Static.send(:metadata_trash_file_path))
-  end
-
-  it 'should find correct file when running in default configuration' do
-    # with default settings, 4 images only will be uploaded
-    subject.invoke
-    expect(Cloudinary::Static.send(:build_metadata).size).to eq 4
-  end
-
-  it 'should respect deprecated static_image_dirs config setting' do
-    allow(Cloudinary.config).to receive(:static_image_dirs).and_return(['public/images'])
-    subject.invoke
-    expect(Cloudinary::Static.send(:build_metadata).size).to eq 1
-  end
-
-  it 'should allow to specify only dirs in images group, taking the file_mask from default' do
-    allow(Cloudinary.config).to receive(:static_files).and_return({
-                                                                    'images' => {
-                                                                      'dirs' => ['public/images']
-                                                                    }
-                                                                  })
-    subject.invoke
-    expect(Cloudinary::Static.send(:build_metadata).size).to eq 1
-  end
-
-  it 'should allow to specify only file_mask in images group, taking the dirs from default' do
-    allow(Cloudinary.config).to receive(:static_files).and_return({
-                                                                    'images' => {
-                                                                      'file_mask' => 'png'
-                                                                    }
-                                                                  })
-    subject.invoke
-    expect(Cloudinary::Static.send(:build_metadata).size).to eq 2
-  end
-
-  it 'should allow to specify regex expressions in file_mask' do
-    allow(Cloudinary.config).to receive(:static_files).and_return({
-                                                                    'images' => {
-                                                                      'file_mask' => 'p.?g|jp.?'
-                                                                    },
-                                                                    'javascripts' => {
-                                                                      'dirs' => ['app/assets/javascripts'],
-                                                                      'file_mask' => 'js'
-                                                                    },
-                                                                    'stylesheets' => {
-                                                                      'dirs' => ['app/assets/stylesheets'],
-                                                                      'file_mask' => 'css'
-                                                                    }
-                                                                  })
-    subject.invoke
-    expect(Cloudinary::Static.send(:build_metadata).size).to eq 6
-  end
-
-  context 'Cloudinary::Utils.cloudinary_url' do
-    def all_asset_forms_of(public_id)
-      [ "/#{public_id}", public_id.split('/').last]
-    end
-
-    RSpec::Matchers.define :be_asset_mapped_by_cloudinary_url_to do |expected|
-      match do |actual|
-        actual = [actual] unless actual.respond_to? :all?
-        actual.all? do |public_path|
-          @public_path = public_path
-          @actual = Cloudinary::Utils.cloudinary_url(public_path, :cloud_name => 'test', :type => 'asset')
-          @actual == expected
-        end
-      end
-      failure_message do |actual|
-        "URL for '#{@public_path}' should have been '#{expected}' but was '#{@actual}'.#{ differ.diff_as_string(@actual, expected)}"
-      end
-      failure_message_when_negated do |actual|
-        "URL for '#{@public_path}' should not have been '#{expected}'."
-      end
-      def differ
-        RSpec::Support::Differ.new(
-            :object_preparer => lambda { |object| RSpec::Matchers::Composable.surface_descriptions_in(object) },
-            :color => RSpec::Matchers.configuration.color?
-        )
-      end
-
-    end
-
-    before(:each) do
-      allow(Cloudinary.config).to receive(:static_files).and_return({
-                                                                      'images' => {
-                                                                        'dirs' => ['app/assets/images'],
-                                                                        'file_mask' => 'p.?g|jp.?'
-                                                                      },
-                                                                      'javascripts' => {
-                                                                        'dirs' => ['app/assets/javascripts'],
-                                                                        'file_mask' => 'js'
-                                                                      },
-                                                                      'stylesheets' => {
-                                                                        'dirs' => ['app/assets/stylesheets'],
-                                                                        'file_mask' => 'css'
-                                                                      }
-                                                                    })
-
-    end
-
-    it 'should return Cloudinary asset urls for assets when Cloudinary.config.static_file_support is true' do
-      allow(Cloudinary.config).to receive(:static_file_support).and_return(true)
-      subject.invoke
-
-      expect(['logo1.png', '/images/logo1.png']).to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/image/asset/logo1-7dc60722d4653261648038b579fdb89e.png')
-      expect('images/logo1.png').not_to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/image/asset/logo1-7dc60722d4653261648038b579fdb89e.png')
-      expect('1.js').to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/raw/asset/1-b01de57adb485efdde843154d030644e.js')
-      expect(['javascripts/1.js', '/javascripts/1.js']).not_to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/raw/asset/1-b01de57adb485efdde843154d030644e.js')
-      expect('1.css').to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/raw/asset/1-f24cc6123afd401ab86d8596cabc619f.css')
-      expect(['stylesheets/1.css', '/stylesheets/1.css']).not_to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/raw/asset/1-f24cc6123afd401ab86d8596cabc619f.css')
-
-      # without :type => 'asset'
-      expect(Cloudinary::Utils.cloudinary_url('logo1.png')).not_to include('7dc60722d4653261648038b579fdb89e')
-    end
-
-    it 'should return Cloudinary asset urls for assets when Cloudinary.config.static_image_support is true (backwards compatibility)' do
-      allow(Cloudinary.config).to receive(:static_image_support).and_return(true)
-      subject.invoke
-
-      expect(['logo1.png', '/images/logo1.png']).to be_asset_mapped_by_cloudinary_url_to('http://res.cloudinary.com/test/image/asset/logo1-7dc60722d4653261648038b579fdb89e.png')
-    end
-  end
-
-end

data/spec/sample_asset_file.tsv

@@ -1,4 +0,0 @@
-public_path	public_id	upload_time.to_i	version	width	height
-stylesheets/foo.css	css-foo	123	1	100	100
-javascripts/bar.js	bar	123	1	100	100
-images/foo.jpg	images-foo	123	1	100	100

data/spec/search_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-
-describe Cloudinary::Search do
-  context 'unit' do
-    it 'should create empty json' do
-      query_hash = Cloudinary::Search.to_h
-      expect(query_hash).to eq({})
-    end
-
-    it 'should always return same object in fluent interface' do
-      instance = Cloudinary::Search.new
-      %w(expression sort_by max_results next_cursor aggregate with_field).each do |method|
-        same_instance = instance.send(method, 'emptyarg')
-        expect(instance).to eq(same_instance)
-      end
-    end
-
-    it 'should add expression to query' do
-      query = Cloudinary::Search.expression('format:jpg').to_h
-      expect(query).to eq(expression: 'format:jpg')
-    end
-
-    it 'should add sort_by to query' do
-      query = Cloudinary::Search.sort_by('created_at', 'asc').sort_by('updated_at', 'desc').to_h
-      expect(query).to eq(sort_by: [{ 'created_at' => 'asc' }, { 'updated_at' => 'desc' }])
-    end
-
-    it 'should add max_results to query' do
-      query = Cloudinary::Search.max_results(10).to_h
-      expect(query).to eq(max_results: 10)
-    end
-
-    it 'should add next_cursor to query' do
-      query = Cloudinary::Search.next_cursor('ASDFIUHASF9832HAFSOF').to_h
-      expect(query).to eq(next_cursor: 'ASDFIUHASF9832HAFSOF')
-    end
-
-    it 'should add aggregations arguments as array to query' do
-      query = Cloudinary::Search.aggregate('format').aggregate('size_category').to_h
-      expect(query).to eq(aggregate: %w(format size_category))
-    end
-
-    it 'should add with_field to query' do
-      query = Cloudinary::Search.with_field('context').with_field('tags').to_h
-      expect(query).to eq(with_field: %w(context tags))
-    end
-  end
-
-  context 'integration' do
-    SEARCH_TAG = TIMESTAMP_TAG + "_search"
-    include_context 'cleanup', SEARCH_TAG
-    prefix = "api_test_#{SUFFIX}"
-    test_id_1 = "#{prefix}_1"
-    test_id_2   = "#{prefix}_2"
-    test_id_3   = "#{prefix}_3"
-    before(:all) do
-      Cloudinary::Uploader.upload(TEST_IMG, public_id: test_id_1, tags: [TEST_TAG, TIMESTAMP_TAG, SEARCH_TAG], context: 'stage=in_review')
-      Cloudinary::Uploader.upload(TEST_IMG, public_id: test_id_2, tags: [TEST_TAG, TIMESTAMP_TAG, SEARCH_TAG], context: 'stage=new')
-      Cloudinary::Uploader.upload(TEST_IMG, public_id: test_id_3, tags: [TEST_TAG, TIMESTAMP_TAG, SEARCH_TAG], context: 'stage=validated')
-      sleep(3)
-    end
-
-    it "should return all images tagged with #{SEARCH_TAG}" do
-      results = Cloudinary::Search.expression("tags:#{SEARCH_TAG}").execute
-      expect(results['resources'].count).to eq 3
-    end
-
-    it "should return resource #{test_id_1}" do
-      results = Cloudinary::Search.expression("public_id:#{test_id_1}").execute
-      expect(results['resources'].count).to eq 1
-    end
-
-    it 'should paginate resources limited by tag and ordered by ascending public_id' do
-      results = Cloudinary::Search.max_results(1).expression("tags:#{SEARCH_TAG}").sort_by('public_id', 'asc').execute
-      expect(results['resources'].count).to eq 1
-      expect(results['resources'][0]['public_id']).to eq test_id_1
-      expect(results['total_count']).to eq 3
-
-      results = Cloudinary::Search.max_results(1).expression("tags:#{SEARCH_TAG}").sort_by('public_id', 'asc').next_cursor(results['next_cursor']).execute
-      expect(results['resources'].count).to eq 1
-      expect(results['resources'][0]['public_id']).to eq test_id_2
-      expect(results['total_count']).to eq 3
-
-      results = Cloudinary::Search.max_results(1).expression("tags:#{SEARCH_TAG}").sort_by('public_id', 'asc').next_cursor(results['next_cursor']).execute
-      expect(results['resources'].count).to eq 1
-      expect(results['resources'][0]['public_id']).to eq test_id_3
-      expect(results['total_count']).to eq 3
-      expect(results['next_cursor']).to be_nil
-    end
-
-    it 'should include context' do
-      results = Cloudinary::Search.expression("tags:#{SEARCH_TAG}").with_field('context').execute
-      expect(results['resources'].count).to eq 3
-      results['resources'].each do |res|
-        expect(res['context'].keys).to eq ['stage']
-      end
-    end
-    it 'should include context, tags and image_metadata' do
-      results = Cloudinary::Search.expression("tags:#{SEARCH_TAG}").with_field('context').with_field('tags').with_field('image_metadata').execute
-      expect(results['resources'].count).to eq 3
-      results['resources'].each do |res|
-        expect(res['context'].keys).to eq ['stage']
-        expect(res.key?('image_metadata')).to eq true
-        expect(res['tags'].count).to eq 3
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,266 +0,0 @@
-require 'rspec'
-require 'rexml/parsers/ultralightparser'
-require 'nokogiri'
-require 'rspec/version'
-require 'rest_client'
-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_IMG_W = 241
-TEST_IMG_H = 51
-SUFFIX = ENV['TRAVIS_JOB_ID'] || rand(999999999).to_s
-TEST_TAG = 'cloudinary_gem_test'
-TIMESTAMP_TAG = "#{TEST_TAG}_#{SUFFIX}_#{RUBY_VERSION}_#{ defined? Rails::version ? Rails::version : 'no_rails'}"
-
-# 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