yt-andrewroth 0.25.5.1

data/spec/requests/as_account/account_spec.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+require 'spec_helper'
+require 'yt/models/account'
+
+describe Yt::Account, :device_app do
+  describe 'can create playlists' do
+    let(:params) { {title: 'Test Yt playlist', privacy_status: 'unlisted'} }
+    before { @playlist = $account.create_playlist params }
+    it { expect(@playlist).to be_a Yt::Playlist }
+    after { @playlist.delete }
+  end
+
+  it { expect($account.channel).to be_a Yt::Channel }
+  it { expect($account.playlists.first).to be_a Yt::Playlist }
+  it { expect($account.subscribed_channels.first).to be_a Yt::Channel }
+  it { expect($account.user_info).to be_a Yt::UserInfo }
+
+  describe '.related_playlists' do
+    let(:related_playlists) { $account.related_playlists }
+
+    specify 'returns the list of associated playlist (Liked Videos, Uploads, ...)' do
+      expect(related_playlists.first).to be_a Yt::Playlist
+    end
+
+    specify 'includes public related playlists (such as Liked Videos)' do
+      uploads = related_playlists.select{|p| p.title.starts_with? 'Uploads'}
+      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
+
+      history = related_playlists.select{|p| p.title == 'History'}
+      expect(history).not_to be_empty
+    end
+  end
+
+  describe '.videos' do
+    let(:video) { $account.videos.where(order: 'viewCount').first }
+
+    specify 'returns the videos uploaded by the account with their tags and category ID' do
+      expect(video).to be_a Yt::Video
+      expect(video.tags).not_to be_empty
+      expect(video.category_id).not_to be_nil
+    end
+
+    describe '.where(q: query_string)' do
+      let(:count) { $account.videos.where(q: query).count }
+
+      context 'given a query string that matches any video owned by the account' do
+        let(:query) { ENV['YT_TEST_MATCHING_QUERY_STRING'] }
+        it { expect(count).to be > 0 }
+      end
+
+      context 'given a query string that does not match any video owned by the account' do
+        let(:query) { '--not-a-matching-query-string--' }
+        it { expect(count).to be_zero }
+      end
+    end
+
+    describe 'ignores filters by ID (all the videos uploaded by the account are returned)' do
+      let(:other_video) { $account.videos.where(order: 'viewCount', id: 'invalid').first }
+      it { expect(other_video.id).to eq video.id }
+    end
+
+    describe 'ignores filters by chart (all the videos uploaded by the account are returned)' do
+      let(:other_video) { $account.videos.where(order: 'viewCount', chart: 'invalid').first }
+      it { expect(other_video.id).to eq video.id }
+    end
+
+    describe '.includes(:snippet)' do
+      let(:video) { $account.videos.includes(:snippet).first }
+
+      specify 'eager-loads the *full* snippet of each video' do
+        expect(video.instance_variable_defined? :@snippet).to be true
+        expect(video.channel_title).to be
+        expect(video.snippet).to be_complete
+      end
+    end
+
+    describe '.includes(:statistics, :status)' do
+      let(:video) { $account.videos.includes(:statistics, :status).first }
+
+      specify 'eager-loads the statistics and status of each video' do
+        expect(video.instance_variable_defined? :@statistics_set).to be true
+        expect(video.instance_variable_defined? :@status).to be true
+      end
+    end
+
+    describe '.includes(:content_details)' do
+      let(:video) { $account.videos.includes(:content_details).first }
+
+      specify 'eager-loads the statistics of each video' do
+        expect(video.instance_variable_defined? :@content_detail).to be true
+      end
+    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 }
+    after { video.delete }
+
+    context 'given the path to a local video file' do
+      let(:path_or_url) { File.expand_path '../video.mp4', __FILE__ }
+
+      it { expect(video).to be_a Yt::Video }
+    end
+
+    context 'given the URL of a remote video file' do
+      let(:path_or_url) { 'https://bit.ly/yt_test' }
+
+      it { expect(video).to be_a Yt::Video }
+    end
+  end
+
+  describe '.subscribers' do
+    let(:subscriber) { $account.subscribers.first }
+
+    specify 'returns the channels who are subscribed to me' do
+      expect(subscriber).to be_a Yt::Channel
+    end
+  end
+end

data/spec/requests/as_account/authentications_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'yt/models/account'
+
+describe Yt::Account, :device_app do
+  subject(:account) { Yt::Account.new attrs }
+
+  describe '#refresh' do
+    context 'given a valid refresh token' do
+      let(:attrs) { {refresh_token: ENV['YT_TEST_DEVICE_REFRESH_TOKEN']} }
+
+      # NOTE: When the token is refreshed, YouTube *might* actually return
+      # the *same* access token if it is still valid. Typically, within the
+      # same second, refreshing the token returns the same token. Still,
+      # testing that *expires_at* changes is a guarantee that we attempted
+      # to get a new token, which is what refresh is meant to do.
+      it { expect{account.refreshed_access_token?}.to change{account.expires_at} }
+    end
+  end
+
+  describe '#authentication' do
+    context 'given a refresh token' do
+      let(:attrs) { {refresh_token: refresh_token} }
+
+      context 'that is valid' do
+        let(:refresh_token) { ENV['YT_TEST_DEVICE_REFRESH_TOKEN'] }
+        it { expect(account.authentication).to be_a Yt::Authentication }
+        it { expect(account.refresh_token).to eq refresh_token }
+      end
+
+      context 'that is invalid' do
+        let(:refresh_token) { '--not-a-valid-refresh-token--' }
+        it { expect{account.authentication}.to raise_error Yt::Errors::Unauthorized }
+      end
+    end
+
+    context 'given a redirect URI and an authorization code' do
+      let(:attrs) { {authorization_code: authorization_code, redirect_uri: 'http://localhost/'} }
+
+      context 'that is valid' do
+        # cannot be tested "live"
+      end
+
+      context 'that is invalid' do
+        let(:authorization_code) { '--not-a-valid-authorization-code--' }
+        it { expect{account.authentication}.to raise_error Yt::Errors::Unauthorized }
+      end
+    end
+
+    context 'given an access token' do
+      let(:attrs) { {access_token: access_token, expires_at: expires_at} }
+
+      context 'that is valid' do
+        let(:access_token) { $account.access_token }
+
+        context 'that does not have an expiration date' do
+          let(:expires_at) { nil }
+          it { expect(account.authentication).to be_a Yt::Authentication }
+        end
+
+        context 'that has not expired' do
+          let(:expires_at) { 1.day.from_now.to_s }
+          it { expect(account.authentication).to be_a Yt::Authentication }
+        end
+
+        context 'that has expired' do
+          let(:expires_at) { 1.day.ago.to_s }
+
+          context 'and no refresh token' do
+            it { expect{account.authentication}.to raise_error Yt::Errors::MissingAuth }
+          end
+
+          context 'and an invalid refresh token' do
+            before { attrs[:refresh_token] = '--not-a-valid-refresh-token--' }
+            it { expect{account.authentication}.to raise_error Yt::Errors::Unauthorized }
+          end
+
+          context 'and a valid refresh token' do
+            before { attrs[:refresh_token] = ENV['YT_TEST_DEVICE_REFRESH_TOKEN'] }
+            it { expect(account.authentication).to be_a Yt::Authentication }
+          end
+        end
+      end
+
+      context 'that is invalid' do
+        let(:access_token) { '--not-a-valid-access-token--' }
+        let(:expires_at) { 1.day.from_now }
+
+        context 'and no refresh token' do
+          it { expect{account.channel}.to raise_error Yt::Errors::Unauthorized }
+        end
+
+        context 'and a valid refresh token' do
+          before { attrs[:refresh_token] = ENV['YT_TEST_DEVICE_REFRESH_TOKEN'] }
+          it { expect{account.channel}.not_to raise_error }
+        end
+      end
+    end
+
+    context 'given scopes' do
+      let(:attrs) { {scopes: ['userinfo.email', 'youtube']} }
+
+      context 'and a redirect_uri' do
+        before { attrs[:redirect_uri] = 'http://localhost/' }
+
+        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
+      let(:attrs) { {} }
+      it { expect{account.authentication}.to raise_error Yt::Errors::MissingAuth }
+    end
+  end
+
+  describe '#authentication_url' do
+    let(:auth_attrs) { {redirect_uri: 'http://localhost/', scopes: ['userinfo.email', 'userinfo.profile']} }
+    context 'given a redirect URI and scopes' do
+      let(:attrs) { auth_attrs }
+      it { expect(account.authentication_url).to match 'access_type=offline' }
+
+      context 'given a forced approval prompt' do
+        let(:attrs) { auth_attrs.merge force: true }
+        it { expect(account.authentication_url).to match 'approval_prompt=force' }
+      end
+    end
+  end
+end

data/spec/requests/as_account/channel_spec.rb

@@ -0,0 +1,259 @@
+# encoding: UTF-8
+require 'spec_helper'
+require 'yt/models/channel'
+
+describe Yt::Channel, :device_app do
+  subject(:channel) { Yt::Channel.new id: id, auth: $account }
+
+  context 'given someone else’s channel' do
+    let(:id) { 'UCxO1tY8h1AhOz0T4ENwmpow' }
+
+    it 'returns valid metadata' do
+      expect(channel.title).to be_a String
+      expect(channel.description).to be_a String
+      expect(channel.thumbnail_url).to be_a String
+      expect(channel.published_at).to be_a Time
+      expect(channel.privacy_status).to be_a String
+      expect(channel.view_count).to be_an Integer
+      expect(channel.comment_count).to be_an Integer
+      expect(channel.video_count).to be_an Integer
+      expect(channel.subscriber_count).to be_an Integer
+      expect(channel.subscriber_count_visible?).to be_in [true, false]
+    end
+
+    describe '.videos' do
+      let(:video) { channel.videos.first }
+
+      specify 'returns the videos in the channel without tags or category ID' do
+        expect(video).to be_a Yt::Video
+        expect(video.snippet).not_to be_complete
+      end
+
+      describe '.where(id: *anything*)' do
+        let(:video) { channel.videos.where(id: 'invalid').first }
+
+        specify 'is ignored (all the channel’s videos are returned)' do
+          expect(video).to be_a Yt::Video
+        end
+      end
+
+      describe '.where(chart: *anything*)' do
+        let(:video) { channel.videos.where(chart: 'invalid').first }
+
+        specify 'is ignored (all the channel’s videos are returned)' do
+          expect(video).to be_a Yt::Video
+        end
+      end
+
+      describe '.includes(:statistics, :status)' do
+        let(:video) { channel.videos.includes(:statistics, :status).first }
+
+        specify 'eager-loads the statistics and status of each video' do
+          expect(video.instance_variable_defined? :@statistics_set).to be true
+          expect(video.instance_variable_defined? :@status).to be true
+        end
+      end
+
+      describe '.includes(:content_details)' do
+        let(:video) { channel.videos.includes(:content_details).first }
+
+        specify 'eager-loads the statistics of each video' do
+          expect(video.instance_variable_defined? :@content_detail).to be true
+        end
+      end
+
+      describe '.includes(:category)' do
+        let(:video) { channel.videos.includes(:category, :status).first }
+
+        specify 'eager-loads the category (id and title) of each video' do
+          expect(video.instance_variable_defined? :@snippet).to be true
+          expect(video.instance_variable_defined? :@video_category).to be true
+        end
+      end
+
+      describe 'when the channel has more than 500 videos' do
+        let(:id) { 'UC0v-tlzsn0QZwJnkiaUSJVQ' }
+
+        specify 'the estimated and actual number of videos can be retrieved' do
+          # @note: in principle, the following three counters should match, but
+          #   in reality +video_count+ and +size+ are only approximations.
+          expect(channel.video_count).to be > 500
+          expect(channel.videos.size).to be > 500
+        end
+
+        specify 'over 500 videos can only be retrieved when sorting by date' do
+          # @note: these tests are slow because they go through multiple pages
+          # of results to test that we can overcome YouTube’s limitation of only
+          # returning the first 500 results when ordered by date.
+          expect(channel.videos.count).to be > 500
+          expect(channel.videos.where(order: 'viewCount').count).to be 500
+        end
+
+        specify 'over 500 videos can be retrieved even with a publishedBefore condition' do
+          # @note: these tests are slow because they go through multiple pages
+          # of results to test that we can overcome YouTube’s limitation of only
+          # returning the first 500 results when ordered by date.
+          today = Date.today.beginning_of_day.iso8601(0)
+          expect(channel.videos.where(published_before: today).count).to be > 500
+        end
+      end
+    end
+
+    it { expect(channel.playlists.first).to be_a Yt::Playlist }
+    it { expect{channel.delete_playlists}.to raise_error Yt::Errors::RequestError }
+
+    describe '.related_playlists' do
+      let(:related_playlists) { channel.related_playlists }
+
+      specify 'returns the list of associated playlist (Liked Videos, Uploads, ...)' do
+        expect(related_playlists.first).to be_a Yt::Playlist
+      end
+
+      specify 'includes public related playlists (such as Liked Videos)' do
+        uploads = related_playlists.select{|p| p.title.starts_with? 'Uploads'}
+        expect(uploads).not_to be_empty
+      end
+
+      specify 'does not includes private playlists (such as Watch Later)' do
+        watch_later = related_playlists.select{|p| p.title.starts_with? 'Watch'}
+        expect(watch_later).to be_empty
+      end
+    end
+
+    specify 'with a public list of subscriptions' do
+      expect(channel.subscribed_channels.first).to be_a Yt::Channel
+    end
+
+    context 'with a hidden list of subscriptions' do
+      let(:id) { 'UCG0hw7n_v0sr8MXgb6oel6w' }
+      it { expect{channel.subscribed_channels.size}.to raise_error Yt::Errors::Forbidden }
+    end
+
+    # NOTE: These tests are slow because we *must* wait some seconds between
+    # subscribing and unsubscribing to a channel, otherwise YouTube will show
+    # wrong (cached) data, such as a user is subscribed when he is not.
+    context 'that I am not subscribed to', :slow do
+      let(:id) { 'UCCj956IF62FbT7Gouszaj9w' }
+      before { channel.throttle_subscriptions }
+
+      it { expect(channel.subscribed?).to be false }
+      it { expect(channel.unsubscribe).to be_falsey }
+      it { expect{channel.unsubscribe!}.to raise_error Yt::Errors::RequestError }
+
+      context 'when I subscribe' do
+        before { channel.subscribe }
+        after { channel.unsubscribe }
+
+        it { expect(channel.subscribed?).to be true }
+        it { expect(channel.unsubscribe!).to be_truthy }
+      end
+    end
+
+    context 'that I am subscribed to', :slow do
+      let(:id) { 'UCxO1tY8h1AhOz0T4ENwmpow' }
+      before { channel.throttle_subscriptions }
+
+      it { expect(channel.subscribed?).to be true }
+      it { expect(channel.subscribe).to be_falsey }
+      it { expect{channel.subscribe!}.to raise_error Yt::Errors::RequestError }
+
+      context 'when I unsubscribe' do
+        before { channel.unsubscribe }
+        after { channel.subscribe }
+
+        it { expect(channel.subscribed?).to be false }
+        it { expect(channel.subscribe!).to be_truthy }
+      end
+    end
+  end
+
+  context 'given my own channel' do
+    let(:id) { $account.channel.id }
+    let(:title) { 'Yt Test <title>' }
+    let(:description) { 'Yt Test <description>' }
+    let(:tags) { ['Yt Test Tag 1', 'Yt Test <Tag> 2'] }
+    let(:privacy_status) { 'unlisted' }
+    let(:params) { {title: title, description: description, tags: tags, privacy_status: privacy_status} }
+
+    specify 'subscriptions can be listed (hidden or public)' do
+      expect(channel.subscriptions.size).to be
+    end
+
+    describe 'playlists can be deleted' do
+      let(:title) { "Yt Test Delete All Playlists #{rand}" }
+      before { $account.create_playlist params }
+
+      it { expect(channel.delete_playlists title: %r{#{params[:title]}}).to eq [true] }
+      it { expect(channel.delete_playlists params).to eq [true] }
+      it { expect{channel.delete_playlists params}.to change{channel.playlists.count}.by(-1) }
+    end
+
+    # Can't subscribe to your own channel.
+    it { expect{channel.subscribe!}.to raise_error Yt::Errors::RequestError }
+    it { expect(channel.subscribe).to be_falsey }
+
+    it 'returns valid reports for channel-related metrics' do
+      # Some reports are only available to Content Owners.
+      # See content owner test for more details about what the methods return.
+      expect{channel.views}.not_to raise_error
+      expect{channel.comments}.not_to raise_error
+      expect{channel.likes}.not_to raise_error
+      expect{channel.dislikes}.not_to raise_error
+      expect{channel.shares}.not_to raise_error
+      expect{channel.subscribers_gained}.not_to raise_error
+      expect{channel.subscribers_lost}.not_to raise_error
+      expect{channel.favorites_added}.not_to raise_error
+      expect{channel.favorites_removed}.not_to raise_error
+      expect{channel.estimated_minutes_watched}.not_to raise_error
+      expect{channel.average_view_duration}.not_to raise_error
+      expect{channel.average_view_percentage}.not_to raise_error
+      expect{channel.annotation_clicks}.not_to raise_error
+      expect{channel.annotation_click_through_rate}.not_to raise_error
+      expect{channel.annotation_close_rate}.not_to raise_error
+      expect{channel.viewer_percentage}.not_to raise_error
+      expect{channel.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{channel.impressions}.to raise_error Yt::Errors::Unauthorized
+      expect{channel.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
+      expect{channel.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
+
+      expect{channel.views_on 3.days.ago}.not_to raise_error
+      expect{channel.comments_on 3.days.ago}.not_to raise_error
+      expect{channel.likes_on 3.days.ago}.not_to raise_error
+      expect{channel.dislikes_on 3.days.ago}.not_to raise_error
+      expect{channel.shares_on 3.days.ago}.not_to raise_error
+      expect{channel.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{channel.subscribers_lost_on 3.days.ago}.not_to raise_error
+      expect{channel.favorites_added_on 3.days.ago}.not_to raise_error
+      expect{channel.favorites_removed_on 3.days.ago}.not_to raise_error
+      expect{channel.estimated_minutes_watched_on 3.days.ago}.not_to raise_error
+      expect{channel.average_view_duration_on 3.days.ago}.not_to raise_error
+      expect{channel.average_view_percentage_on 3.days.ago}.not_to raise_error
+      expect{channel.earnings_on 3.days.ago}.to raise_error Yt::Errors::Unauthorized
+      expect{channel.impressions_on 3.days.ago}.to raise_error Yt::Errors::Unauthorized
+    end
+
+    it 'cannot give information about its content owner' do
+      expect{channel.content_owner}.to raise_error Yt::Errors::Forbidden
+      expect{channel.linked_at}.to raise_error Yt::Errors::Forbidden
+    end
+  end
+
+  context 'given an unknown channel' do
+    let(:id) { 'not-a-channel-id' }
+
+    it { expect{channel.snippet}.to raise_error Yt::Errors::NoItems }
+    it { expect{channel.status}.to raise_error Yt::Errors::NoItems }
+    it { expect{channel.statistics_set}.to raise_error Yt::Errors::NoItems }
+    it { expect{channel.subscribe}.to raise_error Yt::Errors::RequestError }
+
+    describe 'starting with UC' do
+      let(:id) { 'UC-not-a-channel-id' }
+
+      # NOTE: This test is just a reflection of YouTube irrational behavior of
+      # returns 0 results if the name of an unknown channel starts with UC, but
+      # returning 100,000 results otherwise (ignoring the channel filter).
+      it { expect(channel.videos.count).to be_zero }
+      it { expect(channel.videos.size).to be_zero }
+    end
+  end
+end