yt 0.32.6 → 0.33.0

data/spec/requests/as_account/channels_spec.rb

@@ -1,18 +0,0 @@
-# encoding: UTF-8
-require 'spec_helper'
-require 'yt/collections/channels'
-
-describe Yt::Collections::Channels, :device_app do
-  subject(:channels) { Yt::Collections::Channels.new auth: $account }
-
-  context 'with a list of parts' do
-    let(:part) { 'statistics' }
-    let(:channel) { channels.where(part: part, id: 'UCxO1tY8h1AhOz0T4ENwmpow').first }
-
-    specify 'load ONLY the specified parts of the channels' do
-      expect(channel.instance_variable_defined? :@snippet).to be false
-      expect(channel.instance_variable_defined? :@status).to be false
-      expect(channel.instance_variable_defined? :@statistics_set).to be true
-    end
-  end
-end

data/spec/requests/as_account/playlist_item_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-require 'yt/models/playlist_item'
-
-describe Yt::PlaylistItem, :device_app do
-  subject(:item) { Yt::PlaylistItem.new id: id, auth: $account }
-
-  context 'given an existing playlist item' do
-    let(:id) { 'UExiai1JRGU2Zzh2c0FQT0RFci1xRUZjRERvWHhqRzhEVC41MjE1MkI0OTQ2QzJGNzNG' }
-
-    it 'returns valid metadata' do
-      expect(item.title).to be_a String
-      expect(item.description).to be_a String
-      expect(item.thumbnail_url).to be_a String
-      expect(item.published_at).to be_a Time
-      expect(item.channel_id).to be_a String
-      expect(item.channel_title).to be_a String
-      expect(item.playlist_id).to be_a String
-      expect(item.position).to be_an Integer
-      expect(item.video_id).to be_a String
-      expect(item.video).to be_a Yt::Video
-      expect(item.privacy_status).to be_a String
-    end
-  end
-
-  context 'given an unknown playlist item' do
-    let(:id) { 'not-a-playlist-item-id' }
-
-    it { expect{item.snippet}.to raise_error Yt::Errors::RequestError }
-  end
-
-  context 'given one of my own playlist items that I want to update', rate_limited: true do
-    before(:all) do
-      @my_playlist = $account.create_playlist title: "Yt Test Update Playlist Item #{rand}"
-      @my_playlist.add_video '9bZkp7q19f0'
-      @my_playlist_item = @my_playlist.add_video '9bZkp7q19f0'
-    end
-    after(:all) { @my_playlist.delete }
-
-    let(:id) { @my_playlist_item.id }
-    let!(:old_title) { @my_playlist_item.title }
-    let!(:old_privacy_status) { @my_playlist_item.privacy_status }
-    let(:update) { @my_playlist_item.update attrs }
-
-    context 'given I update the position' do
-      let(:attrs) { {position: 0} }
-
-      specify 'only updates the position' do
-        expect(update).to be true
-        expect(@my_playlist_item.position).to be 0
-        expect(@my_playlist_item.title).to eq old_title
-        expect(@my_playlist_item.privacy_status).to eq old_privacy_status
-      end
-    end
-  end
-end

data/spec/requests/as_account/playlist_spec.rb

@@ -1,218 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'yt/models/playlist'
-
-describe Yt::Playlist, :device_app do
-  subject(:playlist) { Yt::Playlist.new id: id, auth: $account }
-
-  context 'given an existing playlist' do
-    let(:id) { 'PLpjK416fmKwQlQ0KvTWFmXZZa3d4IO2ro' } # from YouTube Creators
-
-    it 'returns valid metadata' do
-      expect(playlist.title).to be_a String
-      expect(playlist.description).to be_a String
-      expect(playlist.thumbnail_url).to be_a String
-      expect(playlist.published_at).to be_a Time
-      expect(playlist.tags).to be_an Array
-      expect(playlist.channel_id).to be_a String
-      expect(playlist.channel_title).to be_a String
-      expect(playlist.privacy_status).to be_a String
-      expect(playlist.item_count).to be_an Integer
-    end
-
-    describe '.playlist_items' do
-      let(:item) { playlist.playlist_items.first }
-
-      specify 'returns the playlist item with the complete snippet' do
-        expect(item).to be_a Yt::PlaylistItem
-        expect(item.snippet).to be_complete
-        expect(item.position).not_to be_nil
-      end
-
-      specify 'does not eager-load the attributes of the item’s video' do
-        expect(item.video.instance_variable_defined? :@snippet).to be false
-        expect(item.video.instance_variable_defined? :@status).to be false
-        expect(item.video.instance_variable_defined? :@statistics_set).to be false
-      end
-    end
-
-    describe '.playlist_items.includes(:video)' do
-      let(:item) { playlist.playlist_items.includes(:video).first }
-
-      specify 'eager-loads the snippet, status and statistics of each video' do
-        expect(item.video.instance_variable_defined? :@snippet).to be true
-        expect(item.video.instance_variable_defined? :@status).to be true
-        expect(item.video.instance_variable_defined? :@statistics_set).to be true
-      end
-    end
-  end
-
-  context 'given an unknown playlist' do
-    let(:id) { 'not-a-playlist-id' }
-
-    it { expect{playlist.snippet}.to raise_error Yt::Errors::NoItems }
-    it { expect{playlist.status}.to raise_error Yt::Errors::NoItems }
-  end
-
-  context 'given someone else’s playlist' do
-    let(:id) { 'PLpjK416fmKwQlQ0KvTWFmXZZa3d4IO2ro' } # from YouTube Creators
-    let(:video_id) { '9bZkp7q19f0' }
-
-    it { expect{playlist.delete}.to fail.with 'playlistForbidden' }
-    it { expect{playlist.update}.to fail.with 'playlistForbidden' }
-    it { expect{playlist.add_video! video_id}.to raise_error Yt::Errors::RequestError }
-    it { expect{playlist.delete_playlist_items}.to raise_error Yt::Errors::RequestError }
-  end
-
-  context 'given one of my own playlists that I want to delete', rate_limited: true do
-    before(:all) { @my_playlist = $account.create_playlist title: "Yt Test Delete Playlist #{rand}" }
-    let(:id) { @my_playlist.id }
-
-    it { expect(playlist.delete).to be true }
-  end
-
-  context 'given one of my own playlists that I want to update', rate_limited: true do
-    before(:all) { @my_playlist = $account.create_playlist title: "Yt Test Update Playlist #{rand}" }
-    after(:all) { @my_playlist.delete }
-    let(:id) { @my_playlist.id }
-    let!(:old_title) { @my_playlist.title }
-    let!(:old_privacy_status) { @my_playlist.privacy_status }
-    let(:update) { @my_playlist.update attrs }
-
-    context 'given I update the title' do
-      # NOTE: The use of UTF-8 characters is to test that we can pass up to
-      # 50 characters, independently of their representation
-      let(:attrs) { {title: "Yt Example Update Playlist #{rand} - ®•♡❥❦❧☙"} }
-
-      specify 'only updates the title' do
-        expect(update).to be true
-        expect(@my_playlist.title).not_to eq old_title
-        expect(@my_playlist.privacy_status).to eq old_privacy_status
-      end
-    end
-
-    context 'given I update the description' do
-      let!(:old_description) { @my_playlist.description }
-      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
-
-      specify 'only updates the description' do
-        expect(update).to be true
-        expect(@my_playlist.description).not_to eq old_description
-        expect(@my_playlist.title).to eq old_title
-        expect(@my_playlist.privacy_status).to eq old_privacy_status
-      end
-    end
-
-    context 'given I update the tags' do
-      let!(:old_tags) { @my_playlist.tags }
-      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
-
-      specify 'only updates the tag' do
-        expect(update).to be true
-        expect(@my_playlist.tags).not_to eq old_tags
-        expect(@my_playlist.title).to eq old_title
-        expect(@my_playlist.privacy_status).to eq old_privacy_status
-      end
-    end
-
-    context 'given I update title, description and/or tags using angle brackets' do
-      let(:attrs) { {title: "Yt Test < >", description: '< >', tags: ['<tag>']} }
-
-      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
-        expect(update).to be true
-        expect(playlist.title).to eq 'Yt Test ‹ ›'
-        expect(playlist.description).to eq '‹ ›'
-        expect(playlist.tags).to eq ['‹tag›']
-      end
-    end
-
-    context 'given I update the privacy status' do
-      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
-
-      context 'passing the parameter in underscore syntax' do
-        let(:attrs) { {privacy_status: new_privacy_status} }
-
-        specify 'only updates the privacy status' do
-          expect(update).to be true
-          expect(@my_playlist.privacy_status).not_to eq old_privacy_status
-          expect(@my_playlist.title).to eq old_title
-        end
-      end
-
-      context 'passing the parameter in camel-case syntax' do
-        let(:attrs) { {privacyStatus: new_privacy_status} }
-
-        specify 'only updates the privacy status' do
-          expect(update).to be true
-          expect(@my_playlist.privacy_status).not_to eq old_privacy_status
-          expect(@my_playlist.title).to eq old_title
-        end
-      end
-    end
-
-    context 'given an existing video' do
-      let(:video_id) { '9bZkp7q19f0' } # Gangnam Style
-
-      describe 'can be added' do
-        it { expect(playlist.add_video video_id).to be_a Yt::PlaylistItem }
-        it { expect{playlist.add_video video_id}.to change{playlist.playlist_items.count}.by(1) }
-        it { expect(playlist.add_video! video_id).to be_a Yt::PlaylistItem }
-        it { expect{playlist.add_video! video_id}.to change{playlist.playlist_items.count}.by(1) }
-        it { expect(playlist.add_video(video_id, position: 0).position).to be 0 }
-      end
-
-      # NOTE: This test sounds redundant, but it’s actually a reflection of
-      # another irrational behavior of YouTube API. In short, if you add a new
-      # video to a playlist, the returned item does not have the "position"
-      # information. You need an extra call to get it. When YouTube fixes this
-      # behavior, this test (and related code) will go away.
-      describe 'adding the video' do
-        let(:item) { playlist.add_video video_id }
-
-        specify 'returns an item without its position' do
-          expect(item.snippet).not_to be_complete
-          expect(item.position).not_to be_nil # after reloading
-        end
-      end
-
-      describe 'can be removed' do
-        before { playlist.add_video video_id }
-
-        it { expect(playlist.delete_playlist_items.uniq).to eq [true] }
-        it { expect{playlist.delete_playlist_items}.to change{playlist.playlist_items.count} }
-      end
-    end
-
-    context 'given an unknown video' do
-      let(:video_id) { 'not-a-video' }
-
-      describe 'cannot be added' do
-        it { expect(playlist.add_video video_id).to be_nil }
-        it { expect{playlist.add_video video_id}.not_to change{playlist.playlist_items.count} }
-        it { expect{playlist.add_video! video_id}.to fail.with 'videoNotFound' }
-      end
-    end
-
-    context 'given one existing and one unknown video' do
-      let(:video_ids) { ['9bZkp7q19f0', 'not-a-video'] }
-
-      describe 'only one can be added' do
-        it { expect(playlist.add_videos(video_ids).length).to eq 2 }
-        it { expect{playlist.add_videos video_ids}.to change{playlist.playlist_items.count}.by(1) }
-        it { expect{playlist.add_videos! video_ids}.to fail.with 'videoNotFound' }
-      end
-    end
-  end
-
-  context 'given one of my own playlists that I want to get reports for' do
-    let(:id) { $account.channel.playlists.first.id }
-
-    it 'returns valid reports for playlist-related metrics' do
-      expect{playlist.views}.not_to raise_error
-      expect{playlist.playlist_starts}.not_to raise_error
-      expect{playlist.average_time_in_playlist}.not_to raise_error
-      expect{playlist.views_per_playlist_start}.not_to raise_error
-    end
-  end
-end

data/spec/requests/as_account/video_spec.rb

@@ -1,408 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'yt/models/video'
-
-describe Yt::Video, :device_app do
-  subject(:video) { Yt::Video.new id: id, auth: $account }
-
-  context 'given someone else’s video' do
-    let(:id) { '9bZkp7q19f0' }
-
-    it { expect(video.content_detail).to be_a Yt::ContentDetail }
-
-    it 'returns valid metadata' do
-      expect(video.title).to be_a String
-      expect(video.description).to be_a String
-      expect(video.thumbnail_url).to be_a String
-      expect(video.published_at).to be_a Time
-      expect(video.privacy_status).to be_a String
-      expect(video.tags).to be_an Array
-      expect(video.channel_id).to be_a String
-      expect(video.channel_title).to be_a String
-      expect(video.channel_url).to be_a String
-      expect(video.category_id).to be_a String
-      expect(video.live_broadcast_content).to be_a String
-      expect(video.view_count).to be_an Integer
-      expect(video.like_count).to be_an Integer
-      expect(video.dislike_count).to be_an Integer
-      expect(video.favorite_count).to be_an Integer
-      expect(video.comment_count).to be_an Integer
-      expect(video.duration).to be_an Integer
-      expect(video.length).to be_a String
-      expect(video.hd?).to be_in [true, false]
-      expect(video.stereoscopic?).to be_in [true, false]
-      expect(video.captioned?).to be_in [true, false]
-      expect(video.licensed?).to be_in [true, false]
-      expect(video.deleted?).to be_in [true, false]
-      expect(video.failed?).to be_in [true, false]
-      expect(video.processed?).to be_in [true, false]
-      expect(video.rejected?).to be_in [true, false]
-      expect(video.uploading?).to be_in [true, false]
-      expect(video.uses_unsupported_codec?).to be_in [true, false]
-      expect(video.has_failed_conversion?).to be_in [true, false]
-      expect(video.empty?).to be_in [true, false]
-      expect(video.invalid?).to be_in [true, false]
-      expect(video.too_small?).to be_in [true, false]
-      expect(video.aborted?).to be_in [true, false]
-      expect(video.claimed?).to be_in [true, false]
-      expect(video.infringes_copyright?).to be_in [true, false]
-      expect(video.duplicate?).to be_in [true, false]
-      expect(video.scheduled_at.class).to be_in [NilClass, Time]
-      expect(video.scheduled?).to be_in [true, false]
-      expect(video.too_long?).to be_in [true, false]
-      expect(video.violates_terms_of_use?).to be_in [true, false]
-      expect(video.inappropriate?).to be_in [true, false]
-      expect(video.infringes_trademark?).to be_in [true, false]
-      expect(video.belongs_to_closed_account?).to be_in [true, false]
-      expect(video.belongs_to_suspended_account?).to be_in [true, false]
-      expect(video.licensed_as_creative_commons?).to be_in [true, false]
-      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
-      expect(video.has_public_stats_viewable?).to be_in [true, false]
-      expect(video.embeddable?).to be_in [true, false]
-      expect(video.actual_start_time).to be_nil
-      expect(video.actual_end_time).to be_nil
-      expect(video.scheduled_start_time).to be_nil
-      expect(video.scheduled_end_time).to be_nil
-      expect(video.concurrent_viewers).to be_nil
-      expect(video.embed_html).to be_a String
-      expect(video.category_title).to be_a String
-    end
-
-    it { expect{video.update}.to fail }
-    it { expect{video.delete}.to fail.with 'forbidden' }
-
-    context 'that I like' do
-      before { video.like }
-      it { expect(video).to be_liked }
-      it { expect(video.dislike).to be true }
-    end
-
-    context 'that I dislike' do
-      before { video.dislike }
-      it { expect(video).not_to be_liked }
-      it { expect(video.like).to be true }
-    end
-
-    context 'that I am indifferent to' do
-      before { video.unlike }
-      it { expect(video).not_to be_liked }
-      it { expect(video.like).to be true }
-    end
-  end
-
-  context 'given someone else’s live video broadcast scheduled in the future' do
-    let(:id) { 'PqzGI8gO_gk' }
-
-    it 'returns valid live streaming details' do
-      expect(video.actual_start_time).to be_nil
-      expect(video.actual_end_time).to be_nil
-      expect(video.scheduled_start_time).to be_a Time
-      expect(video.scheduled_end_time).to be_nil
-    end
-  end
-
-  context 'given someone else’s past live video broadcast' do
-    let(:id) { 'COOM8_tOy6U' }
-
-    it 'returns valid live streaming details' do
-      expect(video.actual_start_time).to be_a Time
-      expect(video.actual_end_time).to be_a Time
-      expect(video.scheduled_start_time).to be_a Time
-      expect(video.scheduled_end_time).to be_a Time
-      expect(video.concurrent_viewers).to be_nil
-    end
-  end
-
-  context 'given an unknown video' do
-    let(:id) { 'not-a-video-id' }
-
-    it { expect{video.content_detail}.to raise_error Yt::Errors::NoItems }
-    it { expect{video.snippet}.to raise_error Yt::Errors::NoItems }
-    it { expect{video.rating}.to raise_error Yt::Errors::NoItems }
-    it { expect{video.status}.to raise_error Yt::Errors::NoItems }
-    it { expect{video.statistics_set}.to raise_error Yt::Errors::NoItems }
-    it { expect{video.file_detail}.to raise_error Yt::Errors::NoItems }
-  end
-
-  context 'given one of my own videos that I want to delete' do
-    before(:all) { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: "Yt Test Delete Video #{rand}" }
-    let(:id) { @tmp_video.id }
-
-    it { expect(video.delete).to be true }
-  end
-
-  context 'given one of my own videos that I want to update' do
-    let(:id) { $account.videos.where(order: 'viewCount').first.id }
-    let!(:old_title) { video.title }
-    let!(:old_privacy_status) { video.privacy_status }
-    let(:update) { video.update attrs }
-
-    context 'given I update the title' do
-      # NOTE: The use of UTF-8 characters is to test that we can pass up to
-      # 50 characters, independently of their representation
-      let(:attrs) { {title: "Yt Example Update Video #{rand} - ®•♡❥❦❧☙"} }
-
-      specify 'only updates the title' do
-        expect(update).to be true
-        expect(video.title).not_to eq old_title
-        expect(video.privacy_status).to eq old_privacy_status
-      end
-    end
-
-    context 'given I update the description' do
-      let!(:old_description) { video.description }
-      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
-
-      specify 'only updates the description' do
-        expect(update).to be true
-        expect(video.description).not_to eq old_description
-        expect(video.title).to eq old_title
-        expect(video.privacy_status).to eq old_privacy_status
-      end
-    end
-
-    context 'given I update the tags' do
-      let!(:old_tags) { video.tags }
-      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
-
-      specify 'only updates the tag' do
-        expect(update).to be true
-        expect(video.tags).not_to eq old_tags
-        expect(video.title).to eq old_title
-        expect(video.privacy_status).to eq old_privacy_status
-      end
-    end
-
-    context 'given I update the category ID' do
-      let!(:old_category_id) { video.category_id }
-      let!(:new_category_id) { old_category_id == '22' ? '23' : '22' }
-
-      context 'passing the parameter in underscore syntax' do
-        let(:attrs) { {category_id: new_category_id} }
-
-        specify 'only updates the category ID' do
-          expect(update).to be true
-          expect(video.category_id).not_to eq old_category_id
-          expect(video.title).to eq old_title
-          expect(video.privacy_status).to eq old_privacy_status
-        end
-      end
-
-      context 'passing the parameter in camel-case syntax' do
-        let(:attrs) { {categoryId: new_category_id} }
-
-        specify 'only updates the category ID' do
-          expect(update).to be true
-          expect(video.category_id).not_to eq old_category_id
-        end
-      end
-    end
-
-    context 'given I update title, description and/or tags using angle brackets' do
-      let(:attrs) { {title: "Example Yt Test < >", description: '< >', tags: ['<tag>']} }
-
-      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
-        expect(update).to be true
-        expect(video.title).to eq 'Example Yt Test ‹ ›'
-        expect(video.description).to eq '‹ ›'
-        expect(video.tags).to eq ['‹tag›']
-      end
-    end
-
-    # note: 'scheduled' videos cannot be set to 'unlisted'
-    context 'given I update the privacy status' do
-      before { video.update publish_at: nil if video.scheduled? }
-      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
-
-      context 'passing the parameter in underscore syntax' do
-        let(:attrs) { {privacy_status: new_privacy_status} }
-
-        specify 'only updates the privacy status' do
-          expect(update).to be true
-          expect(video.privacy_status).not_to eq old_privacy_status
-          expect(video.title).to eq old_title
-        end
-      end
-
-      context 'passing the parameter in camel-case syntax' do
-        let(:attrs) { {privacyStatus: new_privacy_status} }
-
-        specify 'only updates the privacy status' do
-          expect(update).to be true
-          expect(video.privacy_status).not_to eq old_privacy_status
-          expect(video.title).to eq old_title
-        end
-      end
-    end
-
-    context 'given I update the embeddable status' do
-      let!(:old_embeddable) { video.embeddable? }
-      let!(:new_embeddable) { !old_embeddable }
-
-      let(:attrs) { {embeddable: new_embeddable} }
-
-      # @see https://developers.google.com/youtube/v3/docs/videos/update
-      specify 'does update the embeddable status' do
-        expect(update).to be true
-        expect(video.embeddable?).to eq new_embeddable
-      end
-    end
-
-    context 'given I update the public stats viewable setting' do
-      let!(:old_public_stats_viewable) { video.has_public_stats_viewable? }
-      let!(:new_public_stats_viewable) { !old_public_stats_viewable }
-
-      context 'passing the parameter in underscore syntax' do
-        let(:attrs) { {public_stats_viewable: new_public_stats_viewable} }
-
-        specify 'only updates the public stats viewable setting' do
-          expect(update).to be true
-          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
-          expect(video.privacy_status).to eq old_privacy_status
-          expect(video.title).to eq old_title
-        end
-      end
-
-      context 'passing the parameter in camel-case syntax' do
-        let(:attrs) { {publicStatsViewable: new_public_stats_viewable} }
-
-        specify 'only updates the public stats viewable setting' do
-          expect(update).to be true
-          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
-          expect(video.privacy_status).to eq old_privacy_status
-          expect(video.title).to eq old_title
-        end
-      end
-    end
-
-    it 'returns valid reports for video-related metrics', extended_permissions: true do
-      # Some reports are only available to Content Owners.
-      # See content owner test for more details about what the methods return.
-      expect{video.views}.not_to raise_error
-      expect{video.comments}.not_to raise_error
-      expect{video.likes}.not_to raise_error
-      expect{video.dislikes}.not_to raise_error
-      expect{video.shares}.not_to raise_error
-      expect{video.subscribers_gained}.not_to raise_error
-      expect{video.subscribers_lost}.not_to raise_error
-      expect{video.videos_added_to_playlists}.not_to raise_error
-      expect{video.videos_removed_from_playlists}.not_to raise_error
-      expect{video.estimated_minutes_watched}.not_to raise_error
-      expect{video.average_view_duration}.not_to raise_error
-      expect{video.average_view_percentage}.not_to raise_error
-      expect{video.annotation_clicks}.not_to raise_error
-      expect{video.annotation_click_through_rate}.not_to raise_error
-      expect{video.annotation_close_rate}.not_to raise_error
-      expect{video.card_impressions}.not_to raise_error
-      expect{video.card_clicks}.not_to raise_error
-      expect{video.card_click_rate}.not_to raise_error
-      expect{video.card_teaser_impressions}.not_to raise_error
-      expect{video.card_teaser_clicks}.not_to raise_error
-      expect{video.card_teaser_click_rate}.not_to raise_error
-      expect{video.viewer_percentage}.not_to raise_error
-      expect{video.estimated_revenue}.to raise_error Yt::Errors::Unauthorized
-      expect{video.ad_impressions}.to raise_error Yt::Errors::Unauthorized
-      expect{video.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
-      expect{video.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
-      expect{video.advertising_options_set}.to raise_error Yt::Errors::Forbidden
-    end
-  end
-
-  # @note: This test is separated from the block above because, for some
-  #   undocumented reasons, if an existing video was private, then set to
-  #   unlisted, then set to private again, YouTube _sometimes_ raises a
-  #   400 Error when trying to set the publishAt timestamp.
-  #   Therefore, just to test the updating of publishAt, we use a brand new
-  #   video (set to private), rather than reusing an existing one as above.
-  context 'given one of my own *private* videos that I want to update' do
-    before { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: old_title, privacy_status: old_privacy_status }
-    let(:id) { @tmp_video.id }
-    let!(:old_title) { "Yt Test Update publishAt Video #{rand}" }
-    let!(:old_privacy_status) { 'private' }
-    after  { video.delete }
-
-    let!(:new_scheduled_at) { Yt::Timestamp.parse("#{rand(30) + 1} Jan 2020", Time.now) }
-
-    context 'passing the parameter in underscore syntax' do
-      let(:attrs) { {publish_at: new_scheduled_at} }
-
-      specify 'only updates the timestamp to publish the video', flaky: true do
-        expect(video.update attrs).to be true
-        expect(video.privacy_status).to eq old_privacy_status
-        expect(video.title).to eq old_title
-        # NOTE: This is another irrational behavior of YouTube API. In short,
-        # the response of Video#update *does not* include the publishAt value
-        # even if it exists. You need to call Video#list again to get it.
-        video = Yt::Video.new id: id, auth: $account
-        expect(video.scheduled_at).to eq new_scheduled_at
-        # Setting a private (scheduled) video to private has no effect:
-        expect(video.update privacy_status: 'private').to be true
-        video = Yt::Video.new id: id, auth: $account
-        expect(video.scheduled_at).to eq new_scheduled_at
-        # Setting a private (scheduled) video to unlisted/public removes publishAt:
-        expect(video.update privacy_status: 'unlisted').to be true
-        video = Yt::Video.new id: id, auth: $account
-        expect(video.scheduled_at).to be_nil
-      end
-    end
-
-    context 'passing the parameter in camel-case syntax' do
-      let(:attrs) { {publishAt: new_scheduled_at} }
-
-      specify 'only updates the timestamp to publish the video' do
-        expect(video.update attrs).to be true
-        video = Yt::Video.new id: id, auth: $account
-        expect(video.scheduled_at).to eq new_scheduled_at
-        expect(video.privacy_status).to eq old_privacy_status
-        expect(video.title).to eq old_title
-      end
-    end
-  end
-
-  # @note: This should somehow test that the thumbnail *changes*. However,
-  #   YouTube does not change the URL of the thumbnail even though the content
-  #   changes. A full test would have to *download* the thumbnails before and
-  #   after, and compare the files. For now, not raising error is enough.
-  #   Eventually, change to `expect{update}.to change{video.thumbnail_url}`
-  context 'given one of my own videos for which I want to upload a thumbnail' do
-    let(:id) { $account.videos.where(order: 'viewCount').first.id }
-    let(:update) { video.upload_thumbnail path_or_url }
-
-    context 'given the path to a local JPG image file', extended_permissions: true do
-      let(:path_or_url) { File.expand_path '../thumbnail.jpg', __FILE__ }
-
-      it { expect{update}.not_to raise_error }
-    end
-
-    context 'given the path to a remote PNG image file', extended_permissions: true do
-      let(:path_or_url) { 'https://bit.ly/yt_thumbnail' }
-
-      it { expect{update}.not_to raise_error }
-    end
-
-    context 'given an invalid URL' do
-      let(:path_or_url) { 'this-is-not-a-url' }
-
-      it { expect{update}.to raise_error Yt::Errors::RequestError }
-    end
-  end
-
-  # @note: This test is separated from the block above because YouTube only
-  #   returns file details for *some videos*: "The fileDetails object will
-  #   only be returned if the processingDetails.fileAvailability property
-  #   has a value of 'available'." Therefore, just to test fileDetails, we use a
-  #   different video (I couldn't find any video marked as 'available').
-  # @see https://developers.google.com/youtube/v3/docs/videos#fileDetails
-  # @see https://developers.google.com/youtube/v3/docs/videos#processingDetails.fileDetailsAvailability
-  context 'given one of my own videos' do
-    let(:id) { $account.videos.first.id }
-
-    it 'returns valid file details' do
-      expect(video.file_name).to be_a String
-      expect(video.file_size).to be_nil
-      expect(video.file_type).to be_nil
-      expect(video.container).to be_nil
-    end
-  end
-end