yt-andrewroth 0.25.5.1

data/spec/collections/reports_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'yt/collections/reports'
+require 'yt/models/content_owner'
+
+describe Yt::Collections::Reports do
+  subject(:reports) { Yt::Collections::Reports.new(parent: content_owner).tap{|reports| reports.metrics = {views: Integer}} }
+  let(:content_owner) { Yt::ContentOwner.new owner_name: 'any-name' }
+  let(:error){ {reason: reason, message: message} }
+  let(:msg) { {response_body: {error: {errors: [error]}}}.to_json }
+
+  describe '#within' do
+    let(:result) { reports.within Range.new(5.days.ago, 4.days.ago), nil, nil, :day, nil }
+    context 'given the request raises error 400 with "Invalid Query" message' do
+      let(:reason) { 'badRequest' }
+      let(:message) { 'Invalid query. Query did not conform to the expectations' }
+      before { expect(reports).to receive(:list).once.and_raise Yt::Error, msg }
+      let(:try_again) { expect(reports).to receive(:list).at_least(:once) }
+
+      context 'every time' do
+        before { try_again.and_raise Yt::Error, msg }
+        it { expect{result}.to fail }
+      end
+
+      context 'but returns a success code 2XX the second time' do
+        before { try_again.and_return [views: {total: 20}] }
+        it { expect{result}.not_to fail }
+      end
+    end
+  end
+end

data/spec/collections/subscriptions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'yt/collections/subscriptions'
+
+describe Yt::Collections::Subscriptions do
+  subject(:collection) { Yt::Collections::Subscriptions.new }
+  let(:msg) { {response_body: {error: {errors: [{reason: reason}]}}}.to_json }
+  before { expect(collection).to behave }
+
+  describe '#insert' do
+    context 'given a new subscription' do
+      let(:subscription) { Yt::Subscription.new }
+      let(:behave) { receive(:do_insert).and_return subscription }
+
+      it { expect(collection.insert).to eq subscription }
+    end
+
+    context 'given a duplicate subscription' do
+      let(:reason) { 'subscriptionDuplicate' }
+      let(:behave) { receive(:do_insert).and_raise Yt::Error, msg }
+
+      it { expect{collection.insert}.to fail.with 'subscriptionDuplicate' }
+      it { expect{collection.insert ignore_errors: true}.not_to fail }
+    end
+  end
+end

data/spec/collections/videos_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'yt/collections/videos'
+require 'yt/models/channel'
+
+describe Yt::Collections::Videos do
+  subject(:collection) { Yt::Collections::Videos.new parent: channel }
+  let(:channel) { Yt::Channel.new id: 'any-id' }
+  let(:page) { {items: [], token: 'any-token'} }
+
+  describe '#size', :ruby2 do
+    describe 'sends only one request and return the total results' do
+      let(:total_results) { 123456 }
+      before do
+        expect_any_instance_of(Yt::Request).to receive(:run).once do
+          double(body: {'pageInfo'=>{'totalResults'=>total_results}})
+        end
+      end
+      it { expect(collection.size).to be total_results }
+    end
+  end
+
+  describe '#count' do
+    let(:query) { {q: 'search string'} }
+
+    context 'called once with .where(query) and once without' do
+      after do
+        collection.where(query).count
+        collection.count
+      end
+
+      it 'only applies the query on the first call' do
+        expect(collection).to receive(:fetch_page) do |options|
+          expect(options[:params]).to include query
+          page
+        end
+        expect(collection).to receive(:fetch_page) do |options|
+          expect(options[:params]).not_to include query
+          page
+        end
+      end
+    end
+  end
+end

data/spec/errors/forbidden_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'yt/errors/forbidden'
+
+describe Yt::Errors::Forbidden do
+  let(:msg) { %r{^A request to YouTube API was considered forbidden by the server} }
+
+  describe '#exception' do
+    it { expect{raise Yt::Errors::Forbidden}.to raise_error msg }
+  end
+end

data/spec/errors/missing_auth_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'yt/errors/missing_auth'
+
+describe Yt::Errors::MissingAuth do
+  subject(:error) { raise Yt::Errors::MissingAuth, params }
+  let(:params) { {} }
+  let(:msg) { %r{^A request to YouTube API was sent without a valid authentication} }
+
+  describe '#exception' do
+    it { expect{error}.to raise_error msg }
+
+    context 'given the user can authenticate via web' do
+      let(:params) { {scopes: 'youtube', authentication_url: 'http://google.example.com/auth', redirect_uri: 'http://localhost/'} }
+      let(:msg) { %r{^You can ask YouTube accounts to authenticate your app} }
+      it { expect{error}.to raise_error msg }
+    end
+
+    context 'given the user can authenticate via device code' do
+      let(:params) { {scopes: 'youtube', user_code: 'abcdefgh', verification_url: 'http://google.com/device'} }
+      let(:msg) { %r{^Please authenticate your app by visiting the page} }
+      it { expect{error}.to raise_error msg }
+    end
+  end
+end

data/spec/errors/no_items_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'yt/errors/no_items'
+
+describe Yt::Errors::NoItems do
+  let(:msg) { %r{^A request to YouTube API returned no items} }
+
+  describe '#exception' do
+    it { expect{raise Yt::Errors::NoItems}.to raise_error msg }
+  end
+end

data/spec/errors/request_error_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'yt/errors/request_error'
+
+describe Yt::Errors::RequestError do
+  subject(:error) { raise Yt::Errors::RequestError, params }
+  let(:params) { {} }
+  let(:msg) { %r{^A request to YouTube API failed} }
+
+  describe '#exception' do
+    it { expect{error}.to raise_error msg }
+
+    context 'given the exception includes sensitive data' do
+      let(:body) { 'some secret token' }
+      let(:curl) { 'curl -H "Authorization: secret-token"' }
+      let(:params) { {response_body: body, request_curl: curl}.to_json }
+
+      describe 'given a log level of :debug or :devel' do
+        before(:all) { Yt.configuration.log_level = :debug }
+        specify 'exposes sensitive data' do
+          expect{error}.to raise_error do |error|
+            expect(error.message).to include 'secret'
+          end
+        end
+      end
+
+      describe 'given a different log level' do
+        before(:all) { Yt.configuration.log_level = :info }
+        specify 'hides sensitive data' do
+          expect{error}.to raise_error do |error|
+            expect(error.message).not_to include 'secret'
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Yt::Error do
+  let(:msg) { %r{^A request to YouTube API failed} }
+
+  describe '#exception' do
+    it { expect{raise Yt::Error}.to raise_error msg }
+  end
+end

data/spec/errors/server_error_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'yt/errors/server_error'
+
+describe Yt::Errors::ServerError do
+  let(:msg) { %r{^A request to YouTube API caused an unexpected server error} }
+
+  describe '#exception' do
+    it { expect{raise Yt::Errors::ServerError}.to raise_error msg }
+  end
+end

data/spec/errors/unauthorized_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'yt/errors/unauthorized'
+
+describe Yt::Errors::Unauthorized do
+  let(:msg) { %r{^A request to YouTube API was sent without a valid authentication} }
+
+  describe '#exception' do
+    it { expect{raise Yt::Errors::Unauthorized}.to raise_error msg }
+  end
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'yt/models/account'
+
+describe Yt::Video do
+  subject(:account) { Yt::Account.new attrs }
+
+  describe '#id' do
+    context 'given a user info with an ID' do
+      let(:attrs) { {user_info: {"id"=>"103024385"}} }
+      it { expect(account.id).to eq '103024385' }
+    end
+
+    context 'given a user info without an ID' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.id).to eq '' }
+    end
+  end
+
+  describe '#email' do
+    context 'given a user info with an email' do
+      let(:attrs) { {user_info: {"email"=>"user@example.com"}} }
+      it { expect(account.email).to eq 'user@example.com' }
+    end
+
+    context 'given a user info without an email' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.email).to eq '' }
+    end
+  end
+
+  describe '#has_verified_email?' do
+    context 'given a user info with a verified email' do
+      let(:attrs) { {user_info: {"verified_email"=>true}} }
+      it { expect(account).to have_verified_email }
+    end
+
+    context 'given a user info without a verified email' do
+      let(:attrs) { {user_info: {"verified_email"=>false}} }
+      it { expect(account).not_to have_verified_email }
+    end
+  end
+
+  describe '#name' do
+    context 'given a user info with a name' do
+      let(:attrs) { {user_info: {"name"=>"User Example"}} }
+      it { expect(account.name).to eq 'User Example' }
+    end
+
+    context 'given a user info without a name' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.name).to eq '' }
+    end
+  end
+
+  describe '#given_name' do
+    context 'given a user info with a given name' do
+      let(:attrs) { {user_info: {"given_name"=>"User"}} }
+      it { expect(account.given_name).to eq 'User' }
+    end
+
+    context 'given a user info without a given name' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.given_name).to eq '' }
+    end
+  end
+
+  describe '#family_name' do
+    context 'given a user info with a family name' do
+      let(:attrs) { {user_info: {"family_name"=>"Example"}} }
+      it { expect(account.family_name).to eq 'Example' }
+    end
+
+    context 'given a user info without a family name' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.family_name).to eq '' }
+    end
+  end
+
+  describe '#profile_url' do
+    context 'given a user info with a link' do
+      let(:attrs) { {user_info: {"link"=>"https://plus.google.com/1234"}} }
+      it { expect(account.profile_url).to eq 'https://plus.google.com/1234' }
+    end
+
+    context 'given a user info without a link' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.profile_url).to eq '' }
+    end
+  end
+
+  describe '#avatar_url' do
+    context 'given a user info with a picture' do
+      let(:attrs) { {user_info: {"picture"=>"https://lh3.googleusercontent.com/photo.jpg"}} }
+      it { expect(account.avatar_url).to eq 'https://lh3.googleusercontent.com/photo.jpg' }
+    end
+
+    context 'given a user info without a picture' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.avatar_url).to eq '' }
+    end
+  end
+
+  describe '#gender' do
+    context 'given a user info with a gender' do
+      let(:attrs) { {user_info: {"gender"=>"male"}} }
+      it { expect(account.gender).to eq 'male' }
+    end
+
+    context 'given a user info without a gender' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.gender).to eq '' }
+    end
+  end
+
+  describe '#locale' do
+    context 'given a user info with a locale' do
+      let(:attrs) { {user_info: {"locale"=>"en"}} }
+      it { expect(account.locale).to eq 'en' }
+    end
+
+    context 'given a user info without a locale' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.locale).to eq '' }
+    end
+  end
+
+  describe '#hd' do
+    context 'given a user info with a Google App domain' do
+      let(:attrs) { {user_info: {"hd"=>"example.com"}} }
+      it { expect(account.hd).to eq 'example.com' }
+    end
+
+    context 'given a user info without a Google App domain' do
+      let(:attrs) { {user_info: {}} }
+      it { expect(account.hd).to eq '' }
+    end
+  end
+end

data/spec/models/annotation_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'yt/models/annotation'
+
+describe Yt::Annotation do
+  subject(:annotation) { Yt::Annotation.new data: Hash.from_xml(xml) }
+
+  describe '#above? and #below?' do
+    let(:xml) { %Q{
+      <segment>
+      <movingRegion type="rect">
+      <rectRegion d="0" h="17.7779998779" t="0:04.000" w="25.0" x="7.117000103" y="5.07000017166"/>
+      <rectRegion d="0" h="17.7779998779" t="0:05.000" w="25.0" x="7.117000103" y="5.07000017166"/>
+      </movingRegion>
+      </segment>
+    } }
+
+    context 'given an annotation located above N% of the video height' do
+      it { expect(annotation.above? 50).to be true }
+      it { expect(annotation.below? 50).to be_falsey }
+    end
+
+    context 'given an annotation located below N% of the video height' do
+      it { expect(annotation.above? 5).to be_falsey }
+      it { expect(annotation.below? 5).to be true }
+    end
+
+    context 'given an annotation without a single position' do
+      let(:xml) { %Q{
+        <segment>
+        <movingRegion type="rect">
+        <rectRegion d="0" h="17.7779998779" t="0:05.000" w="25.0" x="7.117000103" y="5.07000017166"/>
+        </movingRegion>
+        </segment>
+      } }
+      it { expect(annotation.above? 50).to be true }
+      it { expect(annotation.below? 50).to be_falsey }
+    end
+
+    context 'given an annotation without explicit location' do
+      let(:xml) { '<segment></segment>' }
+      it { expect(annotation.above? 50).to be_falsey }
+      it { expect(annotation.below? 50).to be_falsey }
+    end
+  end
+
+  describe '#text' do
+    context 'given an annotation with text' do
+      let(:xml) { '<TEXT>Hello, world!</TEXT>' }
+      it { expect(annotation.text).to eq 'Hello, world!' }
+    end
+  end
+
+  describe '#has_link_to_subscribe?' do
+    context 'given an annotation with a link of class 5' do
+      let(:xml) { '<action type="openUrl"><url link_class="5"/></action>' }
+      it { expect(annotation).to have_link_to_subscribe }
+    end
+
+    context 'given an annotation without a link of class 5' do
+      let(:xml) { '<action type="openUrl"><url link_class="3"/></action>' }
+      it { expect(annotation).not_to have_link_to_subscribe }
+    end
+  end
+
+  describe '#has_link_to_video?' do
+    context 'given an annotation with a link of class 1' do
+      let(:xml) { '<action type="openUrl"><url link_class="1"/></action>' }
+      it { expect(annotation).to have_link_to_video }
+    end
+
+    context 'given an annotation with a "featured video" invideo programming' do
+      let(:xml) { '<type>promotion</type>' }
+      it { expect(annotation).to have_link_to_video }
+    end
+
+    context 'given an annotation without a link of class 1' do
+      let(:xml) { '<action type="openUrl"><url link_class="3"/></action>' }
+      it { expect(annotation).not_to have_link_to_video }
+    end
+  end
+
+  describe '#has_link_to_playlist?' do
+    context 'given an annotation with a link of class 2' do
+      let(:xml) { '<action type="openUrl"><url link_class="2"/></action>' }
+      it { expect(annotation).to have_link_to_playlist }
+    end
+
+    context 'given an annotation with an embedded playlist link' do
+      let(:xml) { '<TEXT>https://www.youtube.com/watch?v=MESycYJytkU&amp;list=LLxO1tY8h1AhOz0T4ENwmpow"</TEXT>' }
+      it { expect(annotation).to have_link_to_playlist }
+    end
+
+    context 'given an annotation without a link of class 2' do
+      let(:xml) { '<action type="openUrl"><url link_class="3"/></action>' }
+      it { expect(annotation).not_to have_link_to_playlist }
+    end
+
+    context 'given an annotation without text' do
+      let(:xml) { '<TEXT />' }
+      it { expect(annotation).not_to have_link_to_playlist }
+    end
+  end
+
+  describe '#has_link_to_same_window?' do
+    context 'given an annotation with a "current" target' do
+      let(:xml) { '<action type="openUrl"><url target="current"/></action>' }
+      it { expect(annotation).to have_link_to_same_window }
+    end
+
+    context 'given an annotation without a "current" target' do
+      let(:xml) { '<action type="openUrl"><url target="new"/></action>' }
+      it { expect(annotation).not_to have_link_to_same_window }
+    end
+  end
+
+  describe '#has_invideo_programming?' do
+    context 'given an annotation with a "featured video" invideo programming' do
+      let(:xml) { '<type>promotion</type>' }
+      it { expect(annotation).to have_invideo_programming }
+    end
+
+    context 'given an annotation with a "branding intro" invideo programming' do
+      let(:xml) { '<type>branding</type>' }
+      it { expect(annotation).to have_invideo_programming }
+    end
+
+    context 'given an annotation without an invideo programming' do
+      let(:xml) { '<segment></segment>' }
+      it { expect(annotation).not_to have_invideo_programming }
+    end
+  end
+
+  describe '#starts_after and #starts_before' do
+    context 'given an annotation with the first timestamp equal to 1 hour' do
+      let(:xml) { %Q{
+        <segment>
+        <movingRegion type="rect">
+        <rectRegion d="0" h="17.7779998779" t="01:00:01.000" w="25.0" x="7.117000103" y="5.07000017166"/>
+        <rectRegion d="0" h="17.7779998779" t="01:05:56.066" w="25.0" x="7.117000103" y="5.07000017166"/>
+        </movingRegion>
+        </segment>
+      } }
+      it { expect(annotation.starts_after? 3600).to be true }
+      it { expect(annotation.starts_after? 3610).to be_falsey }
+      it { expect(annotation.starts_before? 3600).to be_falsey }
+      it { expect(annotation.starts_before? 3610).to be true }
+    end
+
+    context 'given an annotation without timestamps' do
+      let(:xml) { '<segment></segment>' }
+      it { expect(annotation.starts_after? 0).to be_nil }
+      it { expect(annotation.starts_before? 0).to be_nil }
+    end
+
+    context 'given an annotation with "never" as the timestamp' do
+      let(:xml) { %Q{
+        <segment>
+        <movingRegion type="rect">
+        <rectRegion h="6.0" t="never" w="25.0" x="7.0" y="5.0"/>
+        <rectRegion h="6.0" t="never" w="25.0" x="7.0" y="5.0"/>
+        </movingRegion>
+        </segment>
+      } }
+      it { expect(annotation.starts_after? 0).to be_nil }
+      it { expect(annotation.starts_before? 0).to be_nil }
+    end
+
+    context 'given an annotation with "0" as the timestamp' do
+      let(:xml) { %Q{
+        <segment>
+        <movingRegion type="rect">
+        <rectRegion h="6.0" t="0" w="25.0" x="7.0" y="5.0"/>
+        </movingRegion>
+        </segment>
+      } }
+      it { expect(annotation.starts_after? 10).to be_falsey }
+      it { expect(annotation.starts_before? 10).to be true }
+    end
+  end
+end