yt-andrewroth 0.25.5.1

data/spec/requests/as_account/channels_spec.rb

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,56 @@
+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) { 'PLjW_GNR5Ir0GMlbJzA-aW0UV8TchJFb8p3uzrLNcZKPY' }
+
+    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' do
+    before(:all) do
+      @my_playlist = $account.create_playlist title: "Yt Test Update Playlist Item #{rand}"
+      @my_playlist.add_video 'MESycYJytkU'
+      @my_playlist_item = @my_playlist.add_video 'MESycYJytkU'
+    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

@@ -0,0 +1,244 @@
+# 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) { 'PLSWYkYzOrPMT9pJG5St5G0WDalhRzGkU4' }
+
+    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
+    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 a playlist that only includes other people’s private or deleted videos' do
+    let(:id) { 'PLsnYEvcCzABOsJdehqkIDhwz8CPGWzX59' }
+
+    describe '.playlist_items.includes(:video)' do
+      let(:items) { playlist.playlist_items.includes(:video).map{|i| i} }
+
+      specify 'returns nil (without running an infinite loop)' do
+        expect(items.size).to be 2
+      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) { 'PLSWYkYzOrPMT9pJG5St5G0WDalhRzGkU4' }
+    let(:video_id) { 'MESycYJytkU' }
+
+    it { expect{playlist.delete}.to fail.with 'forbidden' }
+    it { expect{playlist.update}.to fail.with 'forbidden' }
+    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' 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' 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) { 'MESycYJytkU' }
+
+      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 a video of a terminated account' do
+      let(:video_id) { 'kDCpdKeTe5g' }
+
+      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 'forbidden' }
+      end
+    end
+
+    context 'given one existing and one unknown video' do
+      let(:video_ids) { ['MESycYJytkU', '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
+
+      expect{playlist.views_on 3.days.ago}.not_to raise_error
+      expect{playlist.playlist_starts_on 3.days.ago}.not_to raise_error
+      expect{playlist.average_time_in_playlist_on 3.days.ago}.not_to raise_error
+      expect{playlist.views_per_playlist_start_on 3.days.ago}.not_to raise_error
+    end
+  end
+end

data/spec/requests/as_account/resource_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'yt/models/resource'
+
+describe Yt::Resource, :device_app do
+  subject(:resource) { Yt::Resource.new url: url, auth: $account }
+
+  describe '#id' do
+    context 'given a URL containing an existing username' do
+      let(:url) { 'youtube.com/fullscreen' }
+      it { expect(resource.id).to eq 'UCxO1tY8h1AhOz0T4ENwmpow' }
+    end
+
+    context 'given a URL containing an unknown username' do
+      let(:url) { 'youtube.com/--not--a--valid--username' }
+      it { expect{resource.id}.to raise_error Yt::Errors::NoItems }
+    end
+  end
+end

data/spec/requests/as_account/video_spec.rb

@@ -0,0 +1,408 @@
+# 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) { 'MESycYJytkU' }
+
+    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.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.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' ? '21' : '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} }
+
+      # @note: This test is a reflection of another irrational behavior of
+      #   YouTube API. Although 'embeddable' can be passed as an 'update'
+      #   attribute according to the documentation, it simply does not work.
+      #   The day YouTube fixes it, then this test will finally fail and will
+      #   be removed, documenting how to update 'embeddable' too.
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      # @see https://code.google.com/p/gdata-issues/issues/detail?id=4861
+      specify 'does not update the embeddable status' do
+        expect(update).to be true
+        expect(video.embeddable?).to eq old_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' 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.favorites_added}.not_to raise_error
+      expect{video.favorites_removed}.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.viewer_percentage}.not_to raise_error
+      expect{video.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{video.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
+
+      expect{video.views_on 3.days.ago}.not_to raise_error
+      expect{video.comments_on 3.days.ago}.not_to raise_error
+      expect{video.likes_on 3.days.ago}.not_to raise_error
+      expect{video.dislikes_on 3.days.ago}.not_to raise_error
+      expect{video.shares_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_lost_on 3.days.ago}.not_to raise_error
+      expect{video.favorites_added_on 3.days.ago}.not_to raise_error
+      expect{video.favorites_removed_on 3.days.ago}.not_to raise_error
+      expect{video.estimated_minutes_watched_on 3.days.ago}.not_to raise_error
+      expect{video.average_view_duration_on 3.days.ago}.not_to raise_error
+      expect{video.average_view_percentage_on 3.days.ago}.not_to raise_error
+      expect{video.earnings_on 3.days.ago}.to raise_error Yt::Errors::Unauthorized
+      expect{video.impressions_on 3.days.ago}.to raise_error Yt::Errors::Unauthorized
+    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' do
+        expect(video.update attrs).to be true
+        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
+
+    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
+        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' 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' 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 that (for some unknown reason) is marked as 'available'.
+  #   Also note that I was not able to find a single video returning fileName,
+  #   therefore video.file_name is not returned by Yt, until it can be tested.
+  # @see https://developers.google.com/youtube/v3/docs/videos#processingDetails.fileDetailsAvailability
+  context 'given one of my own *available* videos' do
+    let(:id) { 'yCmaOvUFhlI' }
+
+    it 'returns valid file details' do
+      expect(video.file_size).to be_an Integer
+      expect(video.file_type).to be_a String
+      expect(video.container).to be_a String
+    end
+  end
+end