yt 0.32.6 → 0.33.0

data/spec/requests/as_account/account_spec.rb

@@ -1,143 +0,0 @@
-# encoding: UTF-8
-require 'spec_helper'
-require 'yt/models/account'
-
-describe Yt::Account, :device_app do
-  describe 'can create playlists', rate_limited: true 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
-  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 '.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 }
-    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 }
-
-    # It could be only me, but it returns an empty array for "items".
-    # Just in case, I currently have 2 subscribers.
-    # {
-    #  "kind": "youtube#subscriptionListResponse",
-    #  "etag": "...",
-    #  "pageInfo": {
-    #   "totalResults": 2,
-    #   "resultsPerPage": 50
-    #  },
-    #  "items": []
-    # }
-    specify 'returns the channels who are subscribed to me' do
-      expect(subscriber).to be_nil
-    end
-  end
-end

data/spec/requests/as_account/authentications_spec.rb

@@ -1,127 +0,0 @@
-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) { rand(36**20).to_s(36) }
-        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
-    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

@@ -1,246 +0,0 @@
-# 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) { 'UCBR8-60-B28hp2BmDPdntcQ' } # YouTube Spotlight
-
-    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' } # FBE
-
-        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
-      end
-    end
-
-    describe '.playlists' do
-      describe '.includes(:content_details)' do
-        let(:playlist) { channel.playlists.includes(:content_details).first }
-
-        specify 'eager-loads the content details of each playlist' do
-          expect(playlist.instance_variable_defined? :@content_detail).to be true
-        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
-
-      # NOTE: this test is commented out because today the private playlist is
-      # included on channel.related_playlists, but I couldn't find if this change
-      # has been documented.
-      # 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) { 'UCUZHFZ9jIKrLroW8LcyJEQQ' } # YouTube Creators - better make our own one
-      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' } # BBC
-      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) { 'UCBR8-60-B28hp2BmDPdntcQ' } # YouTube Spotlight
-      before { channel.throttle_subscriptions }
-
-      it { expect(channel.subscribed?).to be true }
-      # NOTE: These tests are commented out because YouTube randomly changed the
-      # behavior of the API without changing the documentation, so subscribing
-      # to a channel you are already subscribed to does not raise an error
-      # anymore.
-      # 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', rate_limited: true 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{sleep 1; 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.videos_added_to_playlists}.not_to raise_error
-      expect{channel.videos_removed_from_playlists}.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.card_impressions}.not_to raise_error
-      expect{channel.card_clicks}.not_to raise_error
-      expect{channel.card_click_rate}.not_to raise_error
-      expect{channel.card_teaser_impressions}.not_to raise_error
-      expect{channel.card_teaser_clicks}.not_to raise_error
-      expect{channel.card_teaser_click_rate}.not_to raise_error
-      expect{channel.viewer_percentage}.not_to raise_error
-      expect{channel.estimated_revenue}.to raise_error Yt::Errors::Unauthorized
-      expect{channel.ad_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
-    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