cloudinary 1.13.0 → 1.13.1

data/spec/archive_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-require 'rest_client'
-require 'zip'
-
-RSpec.shared_context 'archive' do
-
-  before :all do
-    Cloudinary::Uploader.upload(
-      "http://res.cloudinary.com/demo/image/upload/sample.jpg",
-      :public_id      => 'tag_samplebw',
-      :tags           => [TEST_TAG, TIMESTAMP_TAG],
-      :transformation => {
-        :effect => :blackwhite
-      }
-    )
-    Cloudinary::Uploader.upload(
-      "http://res.cloudinary.com/demo/image/upload/sample.jpg",
-      :public_id      => 'tag_sample',
-      :tags           => [TEST_TAG, TIMESTAMP_TAG],
-      :transformation => {
-        :effect => :blackwhite
-      }
-    )
-    Cloudinary::Uploader.upload(
-      "http://res.cloudinary.com/demo/image/upload/sample.jpg",
-      :public_id      => 'tag_sample_raw.jpg',
-      :resource_type  => 'raw',
-      :tags           => [TEST_TAG, TIMESTAMP_TAG],
-    )
-  end
-  include_context "cleanup", TIMESTAMP_TAG
-end
-
-describe Cloudinary::Utils do
-  include_context 'archive'
-
-  describe '.generate_zip_download_url' do
-    let(:options) { {} }
-    let!(:archive_result) {
-      Cloudinary::Utils.download_zip_url(
-        {
-          :target_public_id => 'gem_archive_test',
-          :public_ids       => %w(tag_sample tag_samplebw),
-          :target_tags      => [TEST_TAG, TIMESTAMP_TAG]
-        }.merge(options))
-    }
-
-    describe 'public_ids' do
-      it 'should generate a valid url' do
-        expect(archive_result).not_to be_empty
-      end
-      it 'should include two files' do
-        Zip::File.open_buffer(RestClient.get(archive_result)) do |zip_file|
-          list = zip_file.glob('*').map(&:name)
-          expect(list.length).to be(2)
-          expect(list).to include('tag_sample.jpg', 'tag_samplebw.jpg')
-        end
-      end
-    end
-  end
-end
-
-describe Cloudinary::Uploader do
-  include_context 'archive'
-
-  let(:options) { {} }
-
-  describe '.create_archive' do
-    let!(:target_public_id) {
-      "gem_test#{ SUFFIX}"
-    }
-    expected_keys = %w(
-              resource_type
-              type
-              public_id
-              version
-              url
-              secure_url
-              created_at
-              tags
-              signature
-              bytes
-              etag
-              resource_count
-              file_count
-            )
-    let!(:archive_result) {
-      Cloudinary::Uploader.create_archive(
-        {
-          :target_public_id => target_public_id,
-          :public_ids       => %w(tag_sample tag_samplebw),
-          :tags             => [TEST_TAG, TIMESTAMP_TAG],
-          :transformations   => [{width: 100, height: 100, crop: "fill"},{effect: "grayscale"}],
-          :skip_transformation_name => true
-        }.merge(options))
-    }
-    let(:options) { { :mode => :create } }
-    it 'should return a Hash with suitable set of keys' do
-      expect(archive_result).to be_a(Hash)
-      expect(archive_result.keys).to include(*expected_keys)
-    end
-  end
-  describe 'create archive based on raw resources and missing public IDs' do
-    let!(:target_public_id) {
-      "gem_test#{ SUFFIX}"
-    }
-    let!(:archive_result) {
-      Cloudinary::Uploader.create_archive(
-        {
-          :target_public_id => target_public_id,
-          :public_ids       => %w(tag_sample_raw.jpg non-wxisting-resource),
-          :resource_type    => 'raw',
-          :allow_missing    => true
-        }.merge(options))
-    }
-    let(:options) { { :mode => :create } }
-    it 'should skip missing public IDs and successfully generate the archive containing raw resources' do
-      expect(archive_result).to be_a(Hash)
-      expect(archive_result["resource_count"]).to equal(1)
-    end
-  end
-  describe '.create_zip' do
-    it 'should call create_archive with "zip" format' do
-      expect(Cloudinary::Uploader).to receive(:create_archive).with({ :tags => TEST_TAG }, "zip")
-      Cloudinary::Uploader.create_zip({ :tags => TEST_TAG })
-    end
-  end
-  describe '.create_archive based on fully_qualified_public_ids' do
-    it 'should allow you to generate an archive by specifying multiple resource_types' do
-      test_ids = %W(image/upload/#{TEST_IMG} video/upload/#{TEST_VIDEO} raw/upload/#{TEST_RAW})
-      expected = {
-        [:payload, :fully_qualified_public_ids] => test_ids,
-        [:url]                                  => %r"/auto/generate_archive$"
-      }
-      expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
-      Cloudinary::Uploader.create_archive(
-        {
-          :resource_type              => :auto,
-          :fully_qualified_public_ids => test_ids
-        }
-      )
-    end
-  end
-end

data/spec/auth_token_spec.rb

@@ -1,77 +0,0 @@
-require 'rspec'
-require 'spec_helper'
-require 'cloudinary'
-
-describe 'auth_token' do
-
-  before :each do
-    Cloudinary.reset_config
-    Cloudinary.config_from_url 'cloudinary://a:b@test123'
-    Cloudinary.config.auth_token = { :key => KEY, :duration => 300, :start_time => 11111111 }
-  end
-  it "should generate with start and duration" do
-    token = Cloudinary::Utils.generate_auth_token :start_time => 1111111111, :acl => "/image/*", :duration => 300
-    expect(token).to eq '__cld_token__=st=1111111111~exp=1111111411~acl=%2fimage%2f*~hmac=1751370bcc6cfe9e03f30dd1a9722ba0f2cdca283fa3e6df3342a00a7528cc51'
-  end
-
-  describe "authenticated url" do
-    before :each do
-      Cloudinary.class_variable_set :@@config, nil
-      Cloudinary.config_from_url 'cloudinary://a:b@test123'
-      Cloudinary.config :private_cdn => true
-      Cloudinary.config.auth_token = { :key => KEY, :duration => 300, :start_time => 11111111 }
-
-    end
-    it "should add token if authToken is globally set and signed = true" do
-      url = Cloudinary::Utils.cloudinary_url "sample.jpg", :sign_url => true, :resource_type => "image", :type => "authenticated", :version => "1486020273"
-      expect(url).to eq("http://test123-res.cloudinary.com/image/authenticated/v1486020273/sample.jpg?__cld_token__=st=11111111~exp=11111411~hmac=8db0d753ee7bbb9e2eaf8698ca3797436ba4c20e31f44527e43b6a6e995cfdb3")
-
-    end
-    it "should add token for 'public' resource" do
-      url = Cloudinary::Utils.cloudinary_url "sample.jpg", :sign_url => true, :resource_type => "image", :type => "public", :version => "1486020273"
-      expect(url).to eq("http://test123-res.cloudinary.com/image/public/v1486020273/sample.jpg?__cld_token__=st=11111111~exp=11111411~hmac=c2b77d9f81be6d89b5d0ebc67b671557e88a40bcf03dd4a6997ff4b994ceb80e")
-
-    end
-    it "should not add token if signed is false" do
-      url = Cloudinary::Utils.cloudinary_url "sample.jpg", :type => "authenticated", :version => "1486020273"
-      expect(url).to eq("http://test123-res.cloudinary.com/image/authenticated/v1486020273/sample.jpg")
-
-    end
-    it "should not add token if authToken is globally set but null auth token is explicitly set and signed = true" do
-      url = Cloudinary::Utils.cloudinary_url "sample.jpg", :auth_token => false, :sign_url => true, :type => "authenticated", :version => "1486020273"
-      expect(url).to eq("http://test123-res.cloudinary.com/image/authenticated/s--v2fTPYTu--/v1486020273/sample.jpg")
-
-    end
-    it "explicit authToken should override global setting" do
-      url = Cloudinary::Utils.cloudinary_url "sample.jpg", :sign_url => true, :auth_token => { :key => ALT_KEY, :start_time => 222222222, :duration => 100 }, :type => "authenticated", :transformation => { :crop => "scale", :width => 300 }
-      expect(url).to eq("http://test123-res.cloudinary.com/image/authenticated/c_scale,w_300/sample.jpg?__cld_token__=st=222222222~exp=222222322~hmac=55cfe516530461213fe3b3606014533b1eca8ff60aeab79d1bb84c9322eebc1f")
-
-    end
-    it "should compute expiration as start time + duration" do
-      token = { :key => KEY, :start_time => 11111111, :duration => 300 }
-      url   = Cloudinary::Utils.cloudinary_url "sample.jpg", :sign_url => true, :auth_token => token, :resource_type => "image", :type => "authenticated", :version => "1486020273"
-      expect(url).to eq("http://test123-res.cloudinary.com/image/authenticated/v1486020273/sample.jpg?__cld_token__=st=11111111~exp=11111411~hmac=8db0d753ee7bbb9e2eaf8698ca3797436ba4c20e31f44527e43b6a6e995cfdb3")
-
-    end
-    it "should raise if key is not provided" do
-      Cloudinary.config.auth_token[:key] = nil
-      token = { :expiration => 111111, :duration => 0 }
-      expect{Cloudinary::Utils.generate_auth_token(token)}.to raise_error(/Missing auth token key configuration/)
-    end
-    it "should raise if expiration and duration are not provided" do
-      token = { :key => KEY, :expiration => 0, :duration => 0 }
-      expect{Cloudinary::Utils.generate_auth_token(token)}.to raise_error(/Must provide either expiration or duration/)
-    end
-  end
-  describe "authentication token" do
-    it "should generate token string" do
-      user                      = "foobar" # we can't rely on the default "now" value in tests
-      tokenOptions              = { :key => KEY, :duration => 300, :acl => "/*/t_#{user}" }
-      tokenOptions[:start_time] = 222222222 # we can't rely on the default "now" value in tests
-      cookieToken               = Cloudinary::Utils.generate_auth_token tokenOptions
-      expect(cookieToken).to eq("__cld_token__=st=222222222~exp=222222522~acl=%2f*%2ft_foobar~hmac=8e39600cc18cec339b21fe2b05fcb64b98de373355f8ce732c35710d8b10259f")
-
-    end
-  end
-end
-

data/spec/cache_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'cloudinary'
-require 'cloudinary/cache'
-require 'rspec'
-require 'active_support/cache'
-
-describe 'Responsive cache' do
-
-  before :all do
-    Cloudinary.reset_config
-    unless defined? Rails and defined? Rails.cache
-      module Rails
-        class << self
-          attr_accessor :cache
-        end
-        Rails.cache = ActiveSupport::Cache::FileStore.new("#{Dir.getwd}/../tmp/cache")
-      end
-    end
-
-    Cloudinary::config.use_cache = true
-    Cloudinary::Cache.storage= Rails.cache
-    @i=0
-  end
-
-  after :all do
-    # Rails.cache.clear
-  end
-
-  def get_cache
-    Rails.cache.fetch CACHE_KEY do
-      @i = @i + 1
-    end
-  end
-  it 'should cache breakpoints' do
-    j = get_cache
-    j = get_cache
-
-    expect(j).to eql(1)
-    expect(@i).to eql(1)
-  end
-
-  it 'should cache upload results' do
-    result = Cloudinary::Uploader.upload(
-      TEST_IMG,
-      :tags => [TEST_TAG, TIMESTAMP_TAG],
-      responsive_breakpoints: [
-        {
-          create_derived: false,
-          transformation: {
-            angle: 90
-          },
-          format: 'gif'
-        },
-        {
-          create_derived: false,
-          transformation: {angle: 45, crop: 'scale'},
-          format: 'png'
-        },
-        {
-          create_derived: false,
-        }
-      ]
-    )
-    expect(result["responsive_breakpoints"]).to_not be_nil
-    expect(result["responsive_breakpoints"].length).to_not eql(0)
-    result["responsive_breakpoints"].each do |bp|
-      bp = Cloudinary::Cache.get(
-        result["public_id"],
-        {
-          type: bp["type"],
-          resource_type: bp["resource_type"],
-          raw_transformation: bp["transformation"]})
-      expect(bp).to_not be_nil
-    end
-  end
-  describe Cloudinary::Uploader do
-    let (:options) { {
-      :tags => [TEST_TAG, TIMESTAMP_TAG],
-        :use_cache => true,
-      :responsive_breakpoints => [
-        {
-          :create_derived => false,
-          :transformation => {
-            :angle => 90
-          },
-          :format => 'gif'
-        },
-        {
-          :create_derived => false,
-          :transformation => ResponsiveTest::TRANSFORMATION,
-          :format => ResponsiveTest::FORMAT
-        },
-        {
-          :create_derived => false
-        }
-      ]
-    }}
-    before :all do
-    end
-
-    it "Should save responsive breakpoints to cache after upload" do
-      result = Cloudinary::Uploader.upload( TEST_IMG, options)
-      cache_value = Cloudinary::Cache.get(result["public_id"], transformation: ResponsiveTest::TRANSFORMATION, format: ResponsiveTest::FORMAT)
-
-      expect(cache_value).to eql(ResponsiveTest::IMAGE_BP_VALUES)
-    end
-  end
-
-end

data/spec/cloudinary_helper_spec.rb

@@ -1,327 +0,0 @@
-require 'rspec'
-require 'spec_helper'
-require 'cloudinary'
-require 'action_view'
-require 'cloudinary/helper'
-require 'active_support/core_ext/kernel/reporting'
-
-RSpec.describe CloudinaryHelper do
-  before :all do
-    # Test the helper in the context it runs in in production
-    ActionView::Base.send :include, CloudinaryHelper
-  end
-
-  let(:helper) {
-    ActionView::Base.new
-  }
-  let(:cloud_name) {DUMMY_CLOUD}
-  let(:root_path) {"http://res.cloudinary.com/#{cloud_name}"}
-  let(:upload_path) {"#{root_path}/image/upload"}
-
-  let(:options) { {} }
-  before :each do
-    Cloudinary.reset_config
-    Cloudinary.config.enhance_image_tag = true
-  end
-  context "#cl_image_upload_tag" do
-    let(:options) {{:multiple => true}}
-    before do
-      if defined? allow
-        allow(Cloudinary::Utils).to receive_messages :cloudinary_api_url => '', :sign_request => Hash.new
-        allow(helper).to receive(:build_callback_url).and_return('')
-      else
-        Cloudinary::Utils.should_receive(:cloudinary_api_url).and_return('')
-        Cloudinary::Utils.should_receive(:sign_request).and_return(Hash.new)
-        helper.should_receive(:build_callback_url).and_return('')
-      end
-    end
-    let(:test_tag) { TestTag.new( helper.cl_image_upload_tag('image_id', options)) }
-
-    it "allow multiple upload" do
-      expect(test_tag['data-cloudinary-field']).to eq('image_id[]')
-      expect(test_tag['multiple']).to eq('multiple')
-    end
-  end
-  context "#cl_upload_tag" do
-    let(:options) {{:multiple => true}}
-    before do
-      if defined? allow
-        allow(Cloudinary::Utils).to receive_messages :cloudinary_api_url => '', :sign_request => Hash.new
-        allow(helper).to receive(:build_callback_url).and_return('')
-      else
-        Cloudinary::Utils.should_receive(:cloudinary_api_url).and_return('')
-        Cloudinary::Utils.should_receive(:sign_request).and_return(Hash.new)
-        helper.should_receive(:build_callback_url).and_return('')
-      end
-    end
-    let(:test_tag) { TestTag.new( helper.cl_upload_tag('image_id', options)) }
-
-    it "allow multiple upload" do
-      expect(test_tag['data-cloudinary-field']).to eq('image_id[]')
-      expect(test_tag['multiple']).to eq('multiple')
-    end
-  end
-
-  PUBLIC_ID = 'sample.jpg'
-  context "#cl_image_tag" do
-    let(:test_tag) { TestTag.new( helper.cl_image_tag(PUBLIC_ID, options)) }
-
-    context ":responsive_width" do
-      let(:options) { {:responsive_width => true, :cloud_name => "test"} }
-      it "should use data-src for responsive_width" do
-        expect(test_tag.name).to match( 'img')
-        expect(test_tag['class']).to eq("cld-responsive")
-        expect(test_tag['data-src']).to eq( "http://res.cloudinary.com/test/image/upload/c_limit,w_auto/sample.jpg")
-      end
-    end
-
-    context ":dpr_auto" do
-      let(:options) { {:dpr => :auto, :cloud_name => "test"} }
-      it "should use data-src for dpr auto" do
-        expect(test_tag.name).to match( 'img')
-        expect(test_tag['class']).to eq( 'cld-hidpi')
-        expect(test_tag['data-src']).to eq( "http://res.cloudinary.com/test/image/upload/dpr_auto/sample.jpg")
-      end
-    end
-
-    context ":client_hints" do
-      shared_examples "client_hints" do
-        it "should not use data-src or set responsive class" do
-          expect(test_tag.name).to match( 'img')
-          expect(test_tag['class']).to be_nil
-          expect(test_tag['data-src']).to be_nil
-          expect(test_tag['src']).to eq( "http://res.cloudinary.com/test/image/upload/dpr_auto,w_auto/sample.jpg")
-        end
-        it "should override :responsive" do
-          Cloudinary.config.responsive = true
-          expect(test_tag.name).to match( 'img')
-          expect(test_tag['class']).to be_nil
-          expect(test_tag['data-src']).to be_nil
-          expect(test_tag['src']).to eq( "http://res.cloudinary.com/test/image/upload/dpr_auto,w_auto/sample.jpg")
-        end
-      end
-      context "as option" do
-        let(:options) { {:dpr => :auto, :cloud_name => "test", :width => "auto", :client_hints => true} }
-        include_examples "client_hints"
-      end
-      context "as global configuration" do
-        before do
-          Cloudinary.config.client_hints = true
-        end
-        let(:options) { {:dpr => :auto, :cloud_name => "test", :width => "auto"} }
-        include_examples "client_hints"
-      end
-
-      context "false" do
-        let(:options) { {:width => :auto, :cloud_name => "test", :client_hints => false} }
-        it "should use normal responsive behaviour" do
-          expect(test_tag.name).to match( 'img')
-          expect(test_tag['class']).to eq( 'cld-responsive')
-          expect(test_tag['data-src']).to eq( "http://res.cloudinary.com/test/image/upload/w_auto/sample.jpg")
-        end
-      end
-      context "width" do
-        let(:options) { {:dpr => :auto, :cloud_name => "test", :width => "auto:breakpoints", :client_hints => true}}
-        it "supports auto width" do
-          expect(test_tag['src']).to eq( "http://res.cloudinary.com/test/image/upload/dpr_auto,w_auto:breakpoints/sample.jpg")
-        end
-      end
-    end
-  end
-  describe "Responsive methods" do
-    let (:options) {{
-      :cloud_name => DUMMY_CLOUD,
-      :width => ResponsiveTest::BREAKPOINTS.last,
-      :height => ResponsiveTest::BREAKPOINTS.last,
-      :crop => :fill}}
-
-    describe "generate_breakpoints" do
-      it "should accept breakpoint" do
-        expect(helper.generate_breakpoints(:breakpoints => [1,2,3])).to eq([1,2,3])
-      end
-      it "should accept min_width, max_width" do
-        expect(helper.generate_breakpoints(:min_width => 100, :max_width => 600, :max_images => 7)).to eq([ 100, 184, 268, 352, 436, 520, 600 ])
-      end
-    end
-    describe "generate_scaled_url" do
-      it "should generate url" do
-        url = helper.generate_scaled_url('sample.jpg', 101, {:width => 200, :crop => "scale"}, options)
-        expect(url).to eq("#{upload_path}/c_scale,w_200/c_scale,w_101/sample.jpg")
-      end
-      it "should generate url without a transformation" do
-        url = helper.generate_scaled_url('sample.jpg', 101, {}, options)
-        expect(url).to eq("#{upload_path}/c_scale,w_101/sample.jpg")
-      end
-    end
-    describe "generate_srcset" do
-      it "should generate a url for each breakpoint" do
-        srcset = helper.generate_srcset_attribute('sample', [1,2,3], {}, options)
-        expect(srcset.split(', ').length).to be(3)
-      end
-    end
-  end
-
-  context "#cl_picture_tag" do
-    let (:options) {{
-        :cloud_name => DUMMY_CLOUD,
-        :width => ResponsiveTest::BREAKPOINTS.last,
-        :height => ResponsiveTest::BREAKPOINTS.last,
-        :crop => :fill}}
-    let (:fill_trans_str) {Cloudinary::Utils.generate_transformation_string(options)}
-    let (:sources) {
-      [
-          {
-              :min_width => ResponsiveTest::BREAKPOINTS.third,
-              :transformation => {:effect => "sepia", :angle => 17, :width => ResponsiveTest::BREAKPOINTS.first, :crop => :scale}
-          },
-          {
-              :min_width => ResponsiveTest::BREAKPOINTS.second,
-              :transformation => {:effect => "colorize", :angle => 18, :width => ResponsiveTest::BREAKPOINTS.second, :crop => :scale}
-          },
-          {
-              :min_width => ResponsiveTest::BREAKPOINTS.first,
-              :transformation => {:effect => "blur", :angle => 19, :width => ResponsiveTest::BREAKPOINTS.first, :crop => :scale}
-          }
-      ]
-    }
-    let(:test_tag) {TestTag.new(helper.cl_picture_tag(PUBLIC_ID, options, sources))}
-    def source_url(t)
-      t = Cloudinary::Utils.generate_transformation_string(t)
-      upload_path + '/' + fill_trans_str + '/' + t + "/sample.jpg"
-    end
-    it "should create a picture tag" do
-      expect(test_tag[:attributes]).to be_nil
-      source_tags = test_tag.element.xpath('//source')
-      expect(source_tags.length).to be(3)
-      expect(test_tag.element.xpath('//img').length).to be(1)
-      sources.each_with_index do |source,i|
-        expect(source_tags[i].attribute('srcset').value).to eq(source_url(source[:transformation]))
-      end
-
-      [
-          "(min-width: #{ResponsiveTest::BREAKPOINTS.third}px)",
-          "(min-width: #{ResponsiveTest::BREAKPOINTS.second}px)",
-          "(min-width: #{ResponsiveTest::BREAKPOINTS.first}px)",
-      ].each_with_index do |expected, i|
-        expect(source_tags[i].attribute('media').value).to eq(expected)
-      end
-
-    end
-
-  end
-
-  context "#cl_source_tag" do
-    min_width = 100
-    max_width = 399
-    breakpoint_list = [min_width, 200, 300, max_width]
-    common_srcset = {breakpoints: breakpoint_list}
-    fill_transformation = {width: max_width, height: max_width, crop: "fill"}
-    fill_transformation_str = "c_fill,h_#{max_width},w_#{max_width}"
-    let (:options) {{
-      :cloud_name => DUMMY_CLOUD,
-      }}
-    let(:test_tag) {TestTag.new(helper.cl_source_tag(PUBLIC_ID, options))}
-    before(:each) do
-      Cloudinary.config(cloud_name: DUMMY_CLOUD, api_secret: "1234")
-    end
-
-    it "should generate a source tag" do
-      expect(test_tag.name).to eql("source")
-      expect(test_tag['srcset']).to eql("#{upload_path}/sample.jpg")
-    end
-
-    it "should generate source tag with media query" do
-      media = {min_width: min_width, max_width: max_width}
-      tag = helper.cl_source_tag("sample.jpg", media: media)
-      expected_media = "(min-width: #{min_width}px) and (max-width: #{max_width}px)".html_safe
-      expected_tag = "<source srcset=\"#{upload_path}/sample.jpg\" media=\"#{expected_media}\">"
-      expect(tag).to eql(expected_tag)
-    end
-
-    it "should generate source tag with responsive srcset" do
-    tag = helper.cl_source_tag(PUBLIC_ID, srcset: {breakpoints: breakpoint_list})
-    expect(tag).to eql(
-      "<source srcset=\"" +
-        "http://res.cloudinary.com/#{DUMMY_CLOUD}/image/upload/c_scale,w_100/sample.jpg 100w, " +
-        "http://res.cloudinary.com/#{DUMMY_CLOUD}/image/upload/c_scale,w_200/sample.jpg 200w, " +
-        "http://res.cloudinary.com/#{DUMMY_CLOUD}/image/upload/c_scale,w_300/sample.jpg 300w, " +
-        "http://res.cloudinary.com/#{DUMMY_CLOUD}/image/upload/c_scale,w_399/sample.jpg 399w" +
-        "\">")
-      end
-
-  end
-
-  context "#cl_client_hints_meta_tag" do
-    it "should create a meta tag" do
-      tag = TestTag.new( helper.cl_client_hints_meta_tag)
-      expect(tag.name).to match('meta')
-      expect(tag['content']).to eq('DPR, Viewport-Width, Width')
-      expect(tag['http-equiv']).to eq('Accept-CH')
-    end
-  end
-
-  context "auth_token" do
-    it "should add token to an image tag url" do
-      tag = helper.cl_image_tag "sample.jpg",
-                                :cloud_name => DUMMY_CLOUD,
-                                :sign_url => true,
-                                :type => "authenticated",
-                                :version => "1486020273",
-                                :auth_token => {key: KEY, start_time: 11111111, duration: 300}
-      expect(tag).to match /<img.*src="http:\/\/res.cloudinary.com\/#{DUMMY_CLOUD}\/image\/authenticated\/v1486020273\/sample.jpg\?__cld_token__=st=11111111~exp=11111411~hmac=9bd6f41e2a5893da8343dc8eb648de8bf73771993a6d1457d49851250caf3b80.*>/
-
-    end
-
-  end
-  describe "image_path" do
-
-    before :all do
-      class Cloudinary::Static
-        class << self
-          def reset_metadata
-            @metadata = nil
-            @static_file_config = nil
-            @public_prefixes = nil
-          end
-        end
-      end
-    end
-
-    before :each do
-      @static_support = Cloudinary.config.static_image_support
-      @static_file = Cloudinary::Static::METADATA_FILE
-      Cloudinary.reset_config
-      Cloudinary.config.enhance_image_tag = true
-      Cloudinary::Static.reset_metadata
-    end
-
-    after :each do
-      Cloudinary.reset_config
-      Cloudinary.config.static_image_support = @static_support
-      Kernel::silence_warnings {Cloudinary::Static::METADATA_FILE = @static_file}
-      Cloudinary::Static.reset_metadata
-    end
-
-    context 'type=="asset"' do
-      it "should not transform images staring with /" do
-        expect(helper.image_path('/bar')).to eq('/bar')
-      end
-      it "should not transform images staring with /images unless asset is found and static_support is true" do
-        skip if RUBY_VERSION >= '2.2.2'
-
-        Cloudinary.config.static_image_support = false
-        expect(helper.image_path('/images/foo.jpg')).to eq('/images/foo.jpg')
-        expect(helper.image_path('some-folder/foo.gif')).to eq("/images/some-folder/foo.gif")
-        Kernel::silence_warnings { Cloudinary::Static::METADATA_FILE = "spec/sample_asset_file.tsv"}
-        Cloudinary::Static.reset_metadata
-        expect(helper.image_path('/images/foo.jpg'))
-            .to eq("/images/foo.jpg")
-        expect(helper.image_path('some-folder/foo.gif')).to eq("/images/some-folder/foo.gif")
-        Cloudinary.config.static_image_support = true
-        expect(helper.image_path('/images/foo.jpg')).to eq("http://res.cloudinary.com/#{Cloudinary.config.cloud_name}/image/asset/images-foo.jpg")
-        expect(helper.image_path('foo.jpg')).to eq("http://res.cloudinary.com/#{Cloudinary.config.cloud_name}/image/asset/images-foo.jpg")
-        expect(helper.image_path('some-folder/foo.gif')).to eq('/images/some-folder/foo.gif')
-      end
-    end
-  end
-end