yt 0.25.13 → 0.32.2

data/spec/requests/as_account/channel_spec.rb

@@ -80,22 +80,6 @@ describe Yt::Channel, :device_app do
           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
 
@@ -164,8 +148,12 @@ describe Yt::Channel, :device_app do
       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 }
+      # 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 }
@@ -195,7 +183,7 @@ describe Yt::Channel, :device_app do
 
       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) }
+      it { expect{channel.delete_playlists params}.to change{sleep 1; channel.playlists.count}.by(-1) }
     end
 
     # Can't subscribe to your own channel.
@@ -212,8 +200,6 @@ describe Yt::Channel, :device_app do
       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.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
@@ -222,33 +208,17 @@ describe Yt::Channel, :device_app do
       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.earnings}.to raise_error Yt::Errors::Unauthorized
-      expect{channel.impressions}.to raise_error Yt::Errors::Unauthorized
+      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
-
-      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.videos_added_to_playlists_on 3.days.ago}.not_to raise_error
-      expect{channel.videos_removed_from_playlists_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
 

data/spec/requests/as_account/playlist_item_spec.rb

@@ -5,7 +5,7 @@ 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' }
+    let(:id) { 'UExTV1lrWXpPclBNVDlwSkc1U3Q1RzBXRGFsaFJ6R2tVNC4yQUE2Q0JEMTk4NTM3RTZC' }
 
     it 'returns valid metadata' do
       expect(item.title).to be_a String
@@ -32,8 +32,8 @@ describe Yt::PlaylistItem, :device_app do
   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'
+      @my_playlist.add_video '9bZkp7q19f0'
+      @my_playlist_item = @my_playlist.add_video '9bZkp7q19f0'
     end
     after(:all) { @my_playlist.delete }
 

data/spec/requests/as_account/playlist_spec.rb

@@ -48,18 +48,6 @@ describe Yt::Playlist, :device_app do
     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' }
 
@@ -69,10 +57,10 @@ describe Yt::Playlist, :device_app do
 
   context 'given someone else’s playlist' do
     let(:id) { 'PLSWYkYzOrPMT9pJG5St5G0WDalhRzGkU4' }
-    let(:video_id) { 'MESycYJytkU' }
+    let(:video_id) { '9bZkp7q19f0' }
 
-    it { expect{playlist.delete}.to fail.with 'forbidden' }
-    it { expect{playlist.update}.to fail.with 'forbidden' }
+    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
@@ -164,7 +152,7 @@ describe Yt::Playlist, :device_app do
     end
 
     context 'given an existing video' do
-      let(:video_id) { 'MESycYJytkU' }
+      let(:video_id) { '9bZkp7q19f0' }
 
       describe 'can be added' do
         it { expect(playlist.add_video video_id).to be_a Yt::PlaylistItem }
@@ -206,18 +194,8 @@ describe Yt::Playlist, :device_app do
       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'] }
+      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 }
@@ -235,11 +213,6 @@ describe Yt::Playlist, :device_app do
       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/video_spec.rb

@@ -7,7 +7,7 @@ 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' }
+    let(:id) { '9bZkp7q19f0' }
 
     it { expect(video.content_detail).to be_a Yt::ContentDetail }
 
@@ -20,6 +20,7 @@ describe Yt::Video, :device_app do
       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
@@ -28,6 +29,7 @@ describe Yt::Video, :device_app do
       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]
@@ -290,8 +292,6 @@ describe Yt::Video, :device_app do
       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.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
@@ -300,29 +300,2030 @@ describe Yt::Video, :device_app do
       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.earnings}.to raise_error Yt::Errors::Unauthorized
-      expect{video.impressions}.to raise_error Yt::Errors::Unauthorized
+      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' 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
+        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
+# 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.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.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.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' 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
+        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
+# 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.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 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.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.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' 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
+        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
+# 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.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.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.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' 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
+        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
+# 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.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.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.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' 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
+        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
+# 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.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 }
 
-      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.videos_added_to_playlists_on 3.days.ago}.not_to raise_error
-      expect{video.videos_removed_from_playlists_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
+      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.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.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