yt 0.25.13 → 0.32.2

data/lib/yt/request.rb

@@ -197,7 +197,7 @@ module Yt
     #   for a couple of seconds might solve the connection issues.
     def run_again?
       refresh_token_and_retry? ||
-      server_error? && sleep_and_retry? ||
+      server_error? && sleep_and_retry?(3) ||
       exceeded_quota? && sleep_and_retry?(3)
     end
 
@@ -209,6 +209,8 @@ module Yt
         Errno::EHOSTUNREACH,
         Errno::ENETUNREACH,
         Errno::ECONNRESET,
+        Net::OpenTimeout,
+        SocketError,
         Net::HTTPServerError
       ] + extra_server_errors
     end
@@ -232,7 +234,7 @@ module Yt
       @retries_so_far += 1
       if (@retries_so_far < max_retries)
         @response = @http_request = @uri = nil
-        sleep 3
+        sleep 3 + (10 * @retries_so_far)
       end
     end
 
@@ -267,7 +269,7 @@ module Yt
 
     # @return [Boolean] whether the request exceeds the YouTube quota
     def exceeded_quota?
-      response_error == Errors::Forbidden && response.body =~ /quotaExceeded/
+      response_error == Errors::Forbidden && response.body =~ /Exceeded/i
     end
 
     # @return [Boolean] whether the request lacks proper authorization.

data/lib/yt/version.rb

@@ -1,3 +1,3 @@
 module Yt
-  VERSION = '0.25.13'
-end
+  VERSION = '0.32.2'
+end

data/spec/collections/comment_threads_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'yt/collections/comment_threads'
+require 'yt/models/video'
+require 'yt/models/channel'
+
+describe Yt::Collections::CommentThreads do
+  subject(:collection) { Yt::Collections::CommentThreads.new parent: parent}
+
+  describe '#size', :ruby2 do
+    describe 'sends only one request and return the total results' do
+      let(:total_results) { 1234 }
+      let(:parent) { Yt::Video.new id: 'any-id' }
+
+      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'} }
+    let(:parent) { Yt::Video.new id: 'any-id' }
+    let(:page) { {items: [], token: 'any-token'} }
+
+    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/collections/playlist_items_spec.rb

@@ -6,7 +6,7 @@ require 'yt/collections/playlist_items'
 describe Yt::Collections::PlaylistItems do
   subject(:collection) { Yt::Collections::PlaylistItems.new parent: playlist }
   let(:playlist) { Yt::Playlist.new id: 'LLxO1tY8h1AhOz0T4ENwmpow' }
-  let(:attrs) { {id: 'MESycYJytkU', kind: :video} }
+  let(:attrs) { {id: '9bZkp7q19f0', kind: :video} }
   let(:msg) { {response_body: {error: {errors: [{reason: reason}]}}}.to_json }
   before { expect(collection).to behave }
 

data/spec/collections/reports_spec.rb

@@ -9,7 +9,7 @@ describe Yt::Collections::Reports do
   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 }
+    let(:result) { reports.within Range.new(5.days.ago, 4.days.ago), nil, nil, :day, nil, 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' }
@@ -27,4 +27,4 @@ describe Yt::Collections::Reports do
       end
     end
   end
-end
+end

data/spec/constants/geography_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'yt/constants/geography'
+
+describe 'Yt::COUNTRIES' do
+  it 'returns all country codes and names' do
+    expect(Yt::COUNTRIES[:US]).to eq 'United States'
+    expect(Yt::COUNTRIES['IT']).to eq 'Italy'
+  end
+end
+
+describe 'Yt::US_STATES' do
+  it 'returns all U.S. state codes and names' do
+    expect(Yt::US_STATES[:CA]).to eq 'California'
+    expect(Yt::US_STATES['CO']).to eq 'Colorado'
+  end
+end

data/spec/models/annotation_spec.rb

@@ -86,7 +86,7 @@ describe Yt::Annotation do
     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>' }
+      let(:xml) { '<TEXT>https://www.youtube.com/watch?v=9bZkp7q19f0&amp;list=LLxO1tY8h1AhOz0T4ENwmpow"</TEXT>' }
       it { expect(annotation).to have_link_to_playlist }
     end
 

data/spec/models/claim_spec.rb

@@ -20,8 +20,8 @@ describe Yt::Claim do
 
   describe '#video_id' do
     context 'given fetching a claim returns an videoId' do
-      let(:data) { {"videoId"=>"MESycYJytkU"} }
-      it { expect(claim.video_id).to eq 'MESycYJytkU' }
+      let(:data) { {"videoId"=>"9bZkp7q19f0"} }
+      it { expect(claim.video_id).to eq '9bZkp7q19f0' }
     end
   end
 
@@ -208,4 +208,16 @@ describe Yt::Claim do
       it { expect(claim.third_party?).to be false }
     end
   end
-end
+
+  describe '#source' do
+    context 'given fetching a claim returns a source' do
+      let(:data) { {"origin"=>{"source"=>"webUpload"}} }
+      it { expect(claim.source).to eq 'webUpload' }
+    end
+
+    context 'given fetching a claim does not return a source' do
+      let(:data) { {"origin"=>{}} }
+      it { expect(claim.source).to eq nil }
+    end
+  end
+end

data/spec/models/comment_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'yt/models/comment'
+
+describe Yt::Comment do
+  subject(:comment) { Yt::Comment.new attrs }
+
+  describe '#snippet' do
+    context 'given fetching a comment returns a snippet' do
+      let(:attrs) { {snippet: {"videoId" => "12345"}} }
+      it { expect(comment.snippet).to be_a Yt::Snippet }
+    end
+  end
+
+  describe 'attributes' do
+    examples = {
+      video_id: {with: 'xyz123', without: nil},
+      parent_id: {with: 'abc123', without: nil},
+      text_display: {with: 'awesome', without: nil},
+      author_display_name: {with: 'John', without: nil},
+      like_count: {with: 10, without: nil},
+      updated_at: {input: '2016-03-22T12:56:56.3Z', with: Time.parse('2016-03-22T12:56:56.3Z'), without: nil},
+    }
+
+    examples.each do |attr, cases|
+      describe "##{attr}" do
+        context "given a snippet with a #{attr}" do
+          let(:attrs) {
+            {snippet: {"#{attr.to_s.camelize(:lower)}" => cases[:input] || cases[:with]}}}
+          it { expect(comment.send(attr)).to eq cases[:with] }
+        end
+
+        context "given a snippet without a #{attr}" do
+          let(:attrs) { {snippet: {}} }
+          it { expect(comment.send(attr)).to eq cases[:without] }
+        end
+      end
+    end
+  end
+end
+

data/spec/models/comment_thread_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'yt/models/comment_thread'
+
+describe Yt::CommentThread do
+  subject(:comment_thread) { Yt::CommentThread.new attrs }
+
+  describe '#snippet' do
+    context 'given fetching a comment thread returns a snippet' do
+      let(:attrs) { {snippet: {"videoId" => "12345"}} }
+      it { expect(comment_thread.snippet).to be_a Yt::Snippet }
+    end
+  end
+
+  describe '#video_id' do
+    context 'given a snippet with a video id' do
+      let(:attrs) { {snippet: {"videoId"=>"12345"}} }
+      it { expect(comment_thread.video_id).to eq '12345' }
+    end
+
+    context 'given a snippet without a video id' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(comment_thread.video_id).to be_nil }
+    end
+  end
+
+  describe '#top_level_comment' do
+    context 'given a snippet with a top level comment' do
+      let(:attrs) { {snippet: {"topLevelComment"=> {}}} }
+      it { expect(comment_thread.top_level_comment).to be_a Yt::Comment }
+    end
+  end
+
+  describe 'attributes from #top_level_comment delegations' do
+    context 'with values' do
+      let(:attrs) { {snippet: {"topLevelComment"=> {"id" => "xyz123", "snippet" => {
+        "textDisplay" => "funny video!",
+        "authorDisplayName" => "fullscreen",
+        "likeCount" => 99,
+        "updatedAt" => "2016-03-22T12:56:56.3Z"}}}} }
+
+      it { expect(comment_thread.top_level_comment.id).to eq 'xyz123' }
+      it { expect(comment_thread.text_display).to eq 'funny video!' }
+      it { expect(comment_thread.author_display_name).to eq 'fullscreen' }
+      it { expect(comment_thread.like_count).to eq 99 }
+      it { expect(comment_thread.updated_at).to eq Time.parse('2016-03-22T12:56:56.3Z') }
+    end
+
+    context 'without values' do
+      let(:attrs) { {snippet: {"topLevelComment"=> {"snippet" => {}}}} }
+
+      it { expect(comment_thread.text_display).to be_nil }
+      it { expect(comment_thread.author_display_name).to be_nil }
+      it { expect(comment_thread.like_count).to be_nil }
+      it { expect(comment_thread.updated_at).to be_nil }
+    end
+  end
+
+  describe '#total_reply_count' do
+    context 'given a snippet with a total reply count' do
+      let(:attrs) { {snippet: {"totalReplyCount"=>1}} }
+      it { expect(comment_thread.total_reply_count).to eq 1 }
+    end
+
+    context 'given a snippet without a total reply count' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(comment_thread.total_reply_count).to be_nil }
+    end
+  end
+
+  describe '#can_reply?' do
+    context 'given a snippet with canReply set' do
+      let(:attrs) { {snippet: {"canReply"=>true}} }
+      it { expect(comment_thread.can_reply?).to be true }
+    end
+
+    context 'given a snippet without canReply set' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(comment_thread.can_reply?).to be false }
+    end
+  end
+
+  describe '#is_public?' do
+    context 'given a snippet with isPublic set' do
+      let(:attrs) { {snippet: {"isPublic"=>true}} }
+      it { expect(comment_thread).to be_public }
+    end
+
+    context 'given a snippet without isPublic set' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(comment_thread).to_not be_public }
+    end
+  end
+end

data/spec/models/content_detail_spec.rb

@@ -42,4 +42,11 @@ describe Yt::ContentDetail do
       it { expect(content_detail.duration).to eq 51 }
     end
   end
+
+  describe '#length' do
+    context 'returns the duration in HH:MM:SS' do
+      let(:data) { {"duration"=>"PT1H18M52S"} }
+      it { expect(content_detail.length).to eq '01:18:52' }
+    end
+  end
 end

data/spec/models/reference_spec.rb

@@ -156,8 +156,8 @@ describe Yt::Reference do
 
   describe '#video_id' do
     context 'given fetching a reference returns an videoId' do
-      let(:data) { {"videoId"=>"MESycYJytkU"} }
-      it { expect(reference.video_id).to eq 'MESycYJytkU' }
+      let(:data) { {"videoId"=>"9bZkp7q19f0"} }
+      it { expect(reference.video_id).to eq '9bZkp7q19f0' }
     end
   end
 

data/spec/models/request_spec.rb

@@ -178,6 +178,27 @@ describe Yt::Request do
           it { expect{request.run}.not_to fail }
         end
       end
+
+      # NOTE: This test is just a reflection of YouTube irrational behavior of
+      # being unavailable once in a while, and therefore causing Net::HTTP to
+      # fail, although retrying after some seconds works.
+      context 'a SocketError', ruby21: true do
+        let(:http_error) { SocketError.new }
+
+        context 'every time' do
+          before { expect(Net::HTTP).to receive(:start).at_least(:once).and_raise http_error }
+
+          it { expect{request.run}.to fail }
+        end
+
+        context 'but works the second time' do
+          before { expect(Net::HTTP).to receive(:start).at_least(:once).and_return retry_response }
+          before { allow(retry_response).to receive(:body) }
+          let(:retry_response) { Net::HTTPOK.new nil, nil, nil }
+
+          it { expect{request.run}.not_to fail }
+        end
+      end
     end
   end
 end

data/spec/models/resource_spec.rb

@@ -4,21 +4,6 @@ require 'yt/models/resource'
 describe Yt::Resource do
   subject(:resource) { Yt::Resource.new attrs }
 
-  context 'given a resource initialized with a URL (containing an ID)' do
-    let(:attrs) { {url: 'youtu.be/MESycYJytkU'} }
-
-    it { expect(resource.id).to eq 'MESycYJytkU' }
-    it { expect(resource.kind).to eq 'video' }
-    it { expect(resource.username).to be_nil }
-  end
-
-  context 'given a resource initialized with a URL (containing a username)' do
-    let(:attrs) { {url: 'youtube.com/fullscreen'} }
-
-    it { expect(resource.kind).to eq 'channel' }
-    it { expect(resource.username).to eq 'fullscreen' }
-  end
-
   describe '#public?' do
     context 'given fetching a status returns privacyStatus "public"' do
       let(:attrs) { {status: {"privacyStatus"=>"public"}} }

data/spec/models/video_spec.rb

@@ -649,7 +649,7 @@ describe Yt::Video do
   end
 
   describe '#update' do
-    let(:attrs) { {id: 'MESycYJytkU', snippet: {'title'=>'old'}} }
+    let(:attrs) { {id: '9bZkp7q19f0', snippet: {'title'=>'old'}} }
     before { expect(video).to receive(:do_update).and_yield 'snippet'=>{'title'=>'new'} }
 
     it { expect(video.update title: 'new').to be true }

data/spec/requests/as_account/account_spec.rb

@@ -27,10 +27,7 @@ describe Yt::Account, :device_app do
       expect(uploads).not_to be_empty
     end
 
-    specify 'includes private playlists (such as Watch Later or History)' do
-      watch_later = related_playlists.select{|p| p.title == 'Watch Later'}
-      expect(watch_later).not_to be_empty
-
+    specify 'includes private playlists (such as History)' do
       history = related_playlists.select{|p| p.title == 'History'}
       expect(history).not_to be_empty
     end
@@ -97,6 +94,21 @@ describe Yt::Account, :device_app do
     end
   end
 
+  describe '.video_groups' do
+    let(:video_group) { $account.video_groups.first }
+
+    specify 'returns the first video-group created by the account' do
+      expect(video_group).to be_a Yt::VideoGroup
+      expect(video_group.title).to be_a String
+      expect(video_group.item_count).to be_an Integer
+      expect(video_group.published_at).to be_a Time
+    end
+
+    specify 'allows to run reports against each video-group' do
+      expect(video_group.views).to be
+    end
+  end
+
   describe '.upload_video' do
     let(:video_params) { {title: 'Test Yt upload', privacy_status: 'private', category_id: 17} }
     let(:video) { $account.upload_video path_or_url, video_params }

data/spec/requests/as_account/authentications_spec.rb

@@ -41,7 +41,7 @@ describe Yt::Account, :device_app do
       end
 
       context 'that is invalid' do
-        let(:authorization_code) { '--not-a-valid-authorization-code--' }
+        let(:authorization_code) { rand(36**20).to_s(36) }
         it { expect{account.authentication}.to raise_error Yt::Errors::Unauthorized }
       end
     end
@@ -104,18 +104,6 @@ describe Yt::Account, :device_app do
 
         it { expect{account.authentication}.to raise_error Yt::Errors::MissingAuth }
       end
-
-      context 'and no device token' do
-        it { expect{account.authentication}.to raise_error Yt::Errors::MissingAuth }
-      end
-
-      # NOTE: This test is commented out because of YouTube irrational behavior
-      # of using to return "MissingAuth" when passing a wrong device code, and
-      # now randomly returning `{"error"=>"internal_failure"}` instead.
-      # context 'and an invalid device code' do
-      #   before { attrs[:device_code] = '--not-a-valid-device-code--' }
-      #   it { expect{account.authentication}.to raise_error Yt::Errors::MissingAuth }
-      # end
     end
 
     context 'given no token or code' do