cloudinary 1.9.1 → 1.10.0

data/spec/cloudinary_helper_spec.rb

@@ -3,16 +3,25 @@ require 'spec_helper'
 require 'cloudinary'
 require 'action_view'
 require 'cloudinary/helper'
-
-helper_class = Class.new do
-  include CloudinaryHelper
-end
+require 'active_support/core_ext/kernel/reporting'
 
 RSpec.describe CloudinaryHelper do
-  let(:helper) { helper_class.new }
+  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.config({})
+    Cloudinary.reset_config
+    Cloudinary.config.enhance_image_tag = true
   end
   context "#cl_image_upload_tag" do
     let(:options) {{:multiple => true}}
@@ -53,8 +62,9 @@ RSpec.describe CloudinaryHelper do
     end
   end
 
+  PUBLIC_ID = 'sample.jpg'
   context "#cl_image_tag" do
-    let(:test_tag) { TestTag.new( helper.cl_image_tag('sample.jpg', options)) }
+    let(:test_tag) { TestTag.new( helper.cl_image_tag(PUBLIC_ID, options)) }
 
     context ":responsive_width" do
       let(:options) { {:responsive_width => true, :cloud_name => "test"} }
@@ -118,6 +128,128 @@ RSpec.describe CloudinaryHelper do
       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
@@ -131,12 +263,12 @@ RSpec.describe CloudinaryHelper do
   context "auth_token" do
     it "should add token to an image tag url" do
       tag = helper.cl_image_tag "sample.jpg",
-                                :cloud_name => 'test123',
+                                :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\/test123\/image\/authenticated\/v1486020273\/sample.jpg\?__cld_token__=st=11111111~exp=11111411~hmac=9bd6f41e2a5893da8343dc8eb648de8bf73771993a6d1457d49851250caf3b80.*>/
+      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
 
@@ -158,12 +290,15 @@ RSpec.describe CloudinaryHelper do
     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 }
+      Kernel::silence_warnings {Cloudinary::Static::METADATA_FILE = @static_file}
       Cloudinary::Static.reset_metadata
     end
 
@@ -181,8 +316,8 @@ RSpec.describe CloudinaryHelper do
             .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/sdk-test/image/asset/images-foo.jpg")
-        expect(helper.image_path('foo.jpg')).to eq("http://res.cloudinary.com/sdk-test/image/asset/images-foo.jpg")
+        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

data/spec/image_spec.rb

@@ -0,0 +1,107 @@
+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/spec_helper.rb

@@ -1,11 +1,13 @@
 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
@@ -17,8 +19,15 @@ TIMESTAMP_TAG = "#{TEST_TAG}_#{SUFFIX}_#{RUBY_VERSION}_#{ defined? Rails::versio
 # 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
@@ -41,6 +50,12 @@ RSpec.shared_context "cleanup" do |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
 
@@ -57,39 +72,45 @@ end
 
 # Represents an HTML tag
 class TestTag
-  attr_accessor :name, :attributes, :children, :text, :html_string
+  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
-    case element[0]
-    when :start_element
-      @name = element[2]
-      @attributes = element[3]
-      @children = (Array(element[4..-1]) || []).map {|c | TestTag.new c}
-    when :text
-      @text = element[1]
-      @name = "text"
-      @attributes = []
-      @children = []
-    end
+    @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 = REXML::Parsers::UltraLightParser.new( tag)
-    parser.parse[0]
+    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)
-    attributes[symbol_or_string.to_s]
+    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?
-      @children.select{ |c| c[m[1]] == args[0]}
+      return unless children
+      children.select{ |c| c[m[1]] == args[0]}
     else
       super
     end

data/spec/uploader_spec.rb

@@ -184,23 +184,23 @@ describe Cloudinary::Uploader do
   end
 
 
-  describe "context", :focus => true do
+  describe "context" do
     describe "add_context" do
-      it "should correctly add context", :focus => true do
+      it "should correctly add context" do
         expected ={
             :url => /.*\/context/,
-            [:payload, :context] => "key1=value1|key2=value2",
+            [: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 => :value2}, ["some_public_id1", "some_public_id2"])
+        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", :focus => true do
+      it "should correctly remove all context" do
         expected ={
             :url => /.*\/context/,
             [:payload, :public_ids] => ["some_public_id1", "some_public_id2"],
@@ -241,7 +241,7 @@ describe Cloudinary::Uploader do
   
   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]]
+    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)
 
@@ -263,9 +263,16 @@ describe Cloudinary::Uploader do
     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("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid/)
+    expect{Cloudinary::Uploader.upload("spec/docx.docx", {: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
@@ -292,13 +299,21 @@ describe Cloudinary::Uploader do
     expect(result["format"]).to eq("bmp")
   end
 
-  it "should allow fallback of upload large with remote url to regular upload", :focus => true do
+  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