cloudinary 1.9.1 → 1.20.0

data/spec/video_tag_spec.rb

@@ -1,251 +0,0 @@
-require 'rspec'
-require 'spec_helper'
-require 'cloudinary'
-require 'action_view'
-require 'cloudinary/helper'
-require 'rails/version'
-
-if ::Rails::VERSION::MAJOR < 4
-  def config
-    @config ||= {}
-  end
-  def controller
-    @controller ||={}
-  end
-end
-describe CloudinaryHelper 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.config do |config|
-      config.cloud_name          = "test123"
-      config.secure_distribution = nil
-      config.private_cdn         = false
-      config.secure              = false
-      config.cname               = nil
-      config.cdn_subdomain       = false
-      config.api_key             = "1234"
-      config.api_secret          = "b"
-    end
-  end
-
-  let(:helper) {
-    ActionView::Base.new
-  }
-  let(:root_path) { "http://res.cloudinary.com/test123" }
-  let(:upload_path) { "#{root_path}/video/upload" }
-
-  describe 'cl_video_tag' do
-    let(:basic_options) { { :cloud_name => "test123"} }
-    let(:options) { basic_options }
-    let(:test_tag) { TestTag.new helper.cl_video_tag("movie", options) }
-    context "when options include video tag attributes" do
-      let(:options) { basic_options.merge({ :autoplay => true,
-                                            :controls => true,
-                                            :loop     => true,
-                                            :muted    => true,
-                                            :preload  => true }) }
-      it "should support video tag parameters" do
-        expect(test_tag.attributes.keys).to include("autoplay", "controls", "loop", "muted", "preload")
-      end
-    end
-
-    context 'when given transformations' do
-      let(:options) {
-        basic_options.merge(
-          :source_types => "mp4",
-          :html_height  => "100",
-          :html_width   => "200",
-          :crop         => :scale,
-          :height       => "200",
-          :width        => "400",
-          :video_codec  => { :codec => 'h264' },
-          :audio_codec  => 'acc',
-          :start_offset => 3) }
-
-      it 'should create a tag with "src" attribute that includes the transformations' do
-        expect(test_tag["src"]).to be_truthy
-        expect(test_tag["src"]).to include("ac_acc")
-        expect(test_tag["src"]).to include("vc_h264")
-        expect(test_tag["src"]).to include("so_3")
-        expect(test_tag["src"]).to include("w_400")
-        expect(test_tag["src"]).to include("h_200")
-      end
-      it 'should have the correct tag height' do
-        expect(test_tag["src"]).to include("ac_acc")
-        expect(test_tag["height"]).to eq("100")
-      end
-    end
-
-    describe ":source_types" do
-      context "when a single source type is provided" do
-        let(:options) { basic_options.merge(:source_types => "mp4") }
-        it "should create a video tag" do
-          expect(test_tag.name).to eq("video")
-          expect(test_tag['src']).to eq( "#{upload_path}/movie.mp4")
-        end
-        it "should not have a `type` attribute" do
-          expect(test_tag.attributes).not_to include("type")
-        end
-        it "should not have inner `source` tags" do
-          expect(test_tag.children.map(&:name)).not_to include("source")
-        end
-      end
-
-      context 'when provided with multiple source types' do
-        let(:options) { basic_options.merge(:source_types => %w(mp4 webm ogv)) }
-        it "should create a tag with multiple source tags" do
-          expect(test_tag.children.length).to eq(3)
-          expect(test_tag.children[0].name).to eq("source")
-          expect(test_tag.children[1].name).to eq("source")
-          expect(test_tag.children.map{|c| c['src']}).to all( include("video/upload"))
-        end
-        it "should order the source tags according to the order of the source_types" do
-          expect(test_tag.children[0][:type]).to eq("video/mp4")
-          expect(test_tag.children[1][:type]).to eq("video/webm")
-          expect(test_tag.children[2][:type]).to eq("video/ogg")
-        end
-      end
-    end
-
-    describe ":poster" do
-      context "when poster is not provided" do
-        it "should default to jpg with the video transformation" do
-          expect(test_tag[:poster]).to eq(helper.cl_video_thumbnail_path("movie", { :format => 'jpg' }))
-        end
-      end
-
-      context "when given a string" do
-        let(:options) { basic_options.merge(:poster => TEST_IMAGE_URL) }
-        it "should include a poster attribute with the given string as url" do
-          expect(test_tag.attributes).to include('poster')
-          expect(test_tag[:poster]).to eq(TEST_IMAGE_URL)
-        end
-      end
-
-      context "when poster is a hash" do
-        let(:options) { basic_options.merge(:poster => { :gravity => "north" }) }
-        it "should include a poster attribute with the given options" do
-          expect(test_tag[:poster]).to eq("#{upload_path}/g_north/movie.jpg")
-        end
-        context "when a public id is provided" do
-          let(:options) { basic_options.merge(:poster => { :public_id => 'myposter.jpg', :gravity => "north" }) }
-          it "should include a poster attribute with an image path and the given options" do
-            expect(test_tag[:poster]).to eq("#{root_path}/image/upload/g_north/myposter.jpg")
-          end
-
-
-        end
-      end
-
-      context "when poster parameter is nil or false" do
-        let(:options) { basic_options.merge(:poster => nil) }
-        it "should not include a poster attribute in the tag for nil" do
-          expect(test_tag.attributes).not_to include('poster')
-        end
-        let(:options) { basic_options.merge(:poster => false) }
-        it "should not include a poster attribute in the tag for false" do
-          expect(test_tag.attributes).not_to include('poster')
-        end
-      end
-    end
-
-    context ":source_transformation" do
-      let(:options) { basic_options.merge(:source_types          => %w(mp4 webm),
-                                          :source_transformation => { 'mp4'  => { 'quality' => 70 },
-                                                                      'webm' => { 'quality' => 30 } }
-      ) }
-      it "should produce the specific transformation for each type" do
-        expect(test_tag.children_by_type("video/mp4")[0][:src]).to include("q_70")
-        expect(test_tag.children_by_type("video/webm")[0][:src]).to include("q_30")
-      end
-
-    end
-
-    describe ':fallback_content' do
-      context 'when given fallback_content parameter' do
-        let(:fallback) { "<span id=\"spanid\">Cannot display video</span>" }
-        let(:options) { basic_options.merge(:fallback_content => fallback) }
-        it "should include fallback content in the tag" do
-          expect(test_tag.children).to include(TestTag.new(fallback))
-        end
-      end
-
-      context "when given a block" do
-        let(:test_tag) do
-          # Actual code being tested ----------------
-          html = helper.cl_video_tag("movie", options) do
-            "Cannot display video!"
-          end
-          # -----------------------------------
-          TestTag.new(html)
-        end
-        it 'should treat the block return value as fallback content' do
-          expect(test_tag.children).to include("Cannot display video!")
-        end
-      end
-      describe "dimensions" do
-        context "when `:crop => 'fit'`" do
-          let(:options) { basic_options.merge(:crop => 'fit') }
-          it "should not include a width and height attributes" do
-            expect(test_tag.attributes.keys).not_to include("width", "height")
-          end
-        end
-        context "when `:crop => 'limit'`" do
-          let(:options) { basic_options.merge(:crop => 'limit') }
-          it "should not include a width and height attributes" do
-            expect(test_tag.attributes.keys).not_to include("width", "height")
-          end
-        end
-      end
-    end
-  end
-  describe 'cl_video_thumbnail_path' do
-    let(:source) { "movie_id" }
-    let(:options) { {} }
-    let(:path) { helper.cl_video_thumbnail_path(source, options) }
-    it "should generate a cloudinary URI to the video thumbnail" do
-      expect(path).to eq("#{upload_path}/movie_id.jpg")
-    end
-  end
-  describe 'cl_video_thumbnail_tag' do
-    let(:source) { "movie_id" }
-    let(:options) { {} }
-    let(:result_tag) { TestTag.new(helper.cl_video_thumbnail_tag(source, options)) }
-    describe ":resource_type" do
-      context "'video' (default)" do
-        let(:options) { { :resource_type => 'video' } }
-        it "should have a 'video/upload' path" do
-          expect(result_tag.name).to eq('img')
-          expect(result_tag[:src]).to include("video/upload")
-        end
-        it "should generate an img tag with file extension `jpg`" do
-          expect(result_tag[:src]).to end_with("movie_id.jpg")
-        end
-      end
-      context "'image'" do
-        let(:options) { { :resource_type => 'image' } }
-        it "should have a 'image/upload' path" do
-          expect(result_tag.name).to eq('img')
-          expect(result_tag[:src]).to include("image/upload")
-        end
-        it "should generate an img tag with file extension `jpg`" do
-          expect(result_tag[:src]).to end_with("movie_id.jpg")
-        end
-      end
-      context "'raw'" do
-        let(:options) { { :resource_type => 'raw' } }
-        it "should have a 'raw/upload' path" do
-          expect(result_tag.name).to eq('img')
-          expect(result_tag[:src]).to include("raw/upload")
-        end
-        it "should generate an img tag with file extension `jpg`" do
-          expect(result_tag[:src]).to end_with("movie_id.jpg")
-        end
-      end
-    end
-  end
-end

data/spec/video_url_spec.rb

@@ -1,164 +0,0 @@
-require 'rspec'
-require 'spec_helper'
-require 'cloudinary'
-require 'action_view'
-require 'cloudinary/helper'
-require 'action_view/test_case'
-
-describe Cloudinary::Utils do
-  before(:each) do
-    Cloudinary.config do |config|
-      config.cloud_name          = "test123"
-      config.secure_distribution = nil
-      config.private_cdn         = false
-      config.secure              = false
-      config.cname               = nil
-      config.cdn_subdomain       = false
-      config.api_key             = "1234"
-      config.api_secret          = "b"
-    end
-  end
-  let(:root_path) { "http://res.cloudinary.com/test123" }
-  let(:upload_path) { "#{root_path}/video/upload" }
-
-  describe "cloudinary_url" do
-    context ":video_codec" do
-      it 'should support a string value' do
-        expect(["video_id", { :resource_type => 'video', :video_codec => 'auto' }])
-          .to produce_url("#{upload_path}/vc_auto/video_id")
-                .and empty_options
-      end
-      it 'should support a hash value' do
-        expect(["video_id", {
-          :resource_type => 'video',
-          :video_codec   => {
-            :codec   => 'h264',
-            :profile => 'basic',
-            :level   => '3.1'
-          }
-        }])
-          .to produce_url("#{upload_path}/vc_h264:basic:3.1/video_id")
-                .and empty_options
-      end
-    end
-    context ":audio_codec" do
-      it 'should support a string value' do
-        expect(["video_id", { :resource_type => 'video', :audio_codec => 'acc' }])
-          .to produce_url("#{upload_path}/ac_acc/video_id")
-                .and empty_options
-      end
-    end
-    context ":bit_rate" do
-      it 'should support an integer value' do
-        expect(["video_id", { :resource_type => 'video', :bit_rate => 2048 }])
-          .to produce_url("#{upload_path}/br_2048/video_id")
-                .and empty_options
-      end
-      it 'should support "<integer>k" ' do
-        expect(["video_id", { :resource_type => 'video', :bit_rate => '44k' }])
-          .to produce_url("#{upload_path}/br_44k/video_id")
-                .and empty_options
-      end
-      it 'should support "<integer>m"' do
-        expect(["video_id", { :resource_type => 'video', :bit_rate => '1m' }])
-          .to produce_url("#{upload_path}/br_1m/video_id")
-                .and empty_options
-      end
-    end
-    context ":audio_frequency" do
-      it 'should support an integer value' do
-        expect(["video_id", { :resource_type => 'video', :audio_frequency => 44100 }])
-          .to produce_url("#{upload_path}/af_44100/video_id")
-                .and empty_options
-      end
-    end
-    context ":video_sampling" do
-      it "should support an integer value" do
-        expect(["video_id", { :resource_type => 'video', :video_sampling => 20 }])
-          .to produce_url("#{upload_path}/vs_20/video_id")
-                .and empty_options
-      end
-      it "should support an string value in the a form of \"<float>s\"" do
-        expect(["video_id", { :resource_type => 'video', :video_sampling => "2.3s" }])
-          .to produce_url("#{upload_path}/vs_2.3s/video_id")
-                .and empty_options
-      end
-    end
-    { :so => :start_offset, :eo => :end_offset, :du => :duration }.each do |short, long|
-      context ":#{long}" do
-        it "should support decimal seconds " do
-          expect(["video_id", { :resource_type => 'video', long => 2.63 }])
-            .to produce_url("#{upload_path}/#{short}_2.63/video_id")
-                  .and empty_options
-          expect(["video_id", { :resource_type => 'video', long => '2.63' }])
-            .to produce_url("#{upload_path}/#{short}_2.63/video_id")
-                  .and empty_options
-        end
-        it 'should support percents of the video length as "<number>p"' do
-          expect(["video_id", { :resource_type => 'video', long => '35p' }])
-            .to produce_url("#{upload_path}/#{short}_35p/video_id")
-                  .and empty_options
-        end
-        it 'should support percents of the video length as "<number>%"' do
-          expect(["video_id", { :resource_type => 'video', long => '35%' }])
-            .to produce_url("#{upload_path}/#{short}_35p/video_id")
-                  .and empty_options
-        end
-      end
-    end
-
-    describe ":offset" do
-      let(:test_url) { Cloudinary::Utils.cloudinary_url("video_id", options) }
-      [
-        ['string range', 'so_2.66,eo_3.21', '2.66..3.21'],
-        ['array', 'so_2.66,eo_3.21', [2.66, 3.21]],
-        ['range of floats', 'so_2.66,eo_3.21', 2.66..3.21],
-        ['array of % strings', 'so_35p,eo_70p', %w(35% 70%)],
-        ['array of p strings', 'so_35p,eo_70p', %w(35p 70p)],
-        ['array of float percent', 'so_35.5p,eo_70.5p', %w(35.5p 70.5p)]
-      ].each do |test|
-        name, url_param, range = test
-        context "when provided with #{name} #{range}" do
-          let(:options) { { :resource_type => 'video', :offset => range } }
-          it "should produce a range transformation in the format of #{url_param}" do
-            expect { test_url }.to change { options }.to({})
-            transformation = /([^\/]*)\/video_id$/.match(test_url)[1]
-            # we can't rely on the order of the parameters so we sort them before comparing
-            expect(transformation.split(',').sort.reverse.join(',')).to eq(url_param)
-          end
-        end
-      end
-    end
-    context "when given existing relevant parameters: :quality, :background, :crop, :width, :height, :gravity, :overlay" do
-
-      { :overlay => :l, :underlay => :u }.each do |param, letter|
-        it "should support #{param}" do
-          expect(["test", { :resource_type => 'video', param => "text:hello" }])
-            .to produce_url("#{upload_path}/#{letter}_text:hello/test")
-                  .and empty_options
-        end
-
-        it "should not pass width/height to html for #{param}" do
-          expect(["test", { :resource_type => 'video', param => "text:hello", :height => 100, :width => 100 }])
-            .to produce_url("#{upload_path}/h_100,#{letter}_text:hello,w_100/test")
-                  .and empty_options
-        end
-      end
-      it "should produce the transformation string" do
-        expect(["test", { :resource_type => 'video', :background => "#112233" }])
-          .to produce_url("#{upload_path}/b_rgb:112233/test")
-                .and empty_options
-        expect(["test", {
-          :resource_type => 'video',
-          :x             => 1, :y => 2, :radius => 3,
-          :gravity       => :center,
-          :quality       => 0.4,
-          :prefix        => "a" }])
-          .to produce_url("#{upload_path}/g_center,p_a,q_0.4,r_3,x_1,y_2/test")
-                .and empty_options
-
-      end
-    end
-  end
-
-end