yt 0.25.40 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b0ee675025a4e3373b1281cfa5097498aec15ab
-  data.tar.gz: ea6970b4d354cebcc440ad32e0d7855ec437b936
+  metadata.gz: 84c5ba72d6991b9fb6c57f489bd30a5647bf4930
+  data.tar.gz: 28c51f4ae24aaa298b08983762cc85ea687057af
 SHA512:
-  metadata.gz: 2c3a000be6dc7c31d03964b9dc5f27442079e177fd4f867bc0a663833c709653d30c7c6dde977e4df8d6b675c45cb8fa63c8331537b1e0215a36bf19bb392221
-  data.tar.gz: 9203eb0e4dc5e84926e49b6c14830507753d7e52656c48da58816fb6637e14d3d332be9041f1acdd76d41ccace0f0aa8bf5e8e722ba3a00d110924d0df15a6ab
+  metadata.gz: c13c6f260519e3c69e524e560b1d0d0e476e38d89cc60d2d58856702581720849ddb28a38cc5f543095fff37a3eb688dc13b4c9eba1d1915b5ac4933b8fa84ec
+  data.tar.gz: 45542ab85dbe203f7675e10e40ce4221a94b1e3fb11136ed4c59bb667786c2a792b22b918c9ffeb126cab5969b9b88e347102bcc9ce390855b43764f906930b7

data/CHANGELOG.md

@@ -6,6 +6,17 @@ For more information about changelogs, check
 [Keep a Changelog](http://keepachangelog.com) and
 [Vandamme](http://tech-angels.github.io/vandamme).
 
+## 0.26.0 - 2016-10-05
+
+**How to upgrade**
+
+If your code calls `.favorites_added` and `.favorites_removed` on channels and
+videos then you must remove that code since those metrics are not anymore
+supported by YouTube API.
+
+* [REMOVAL] Remove deprecated `favorites_added` metric for channels, videos, and video groups.
+* [REMOVAL] Remove deprecated `favorites_removed` metric for channels, videos, and video groups
+
 ## 0.25.40 - 2016-09-19
 
 * [IMPROVEMENT] Add `Yt::Claim#data` to access the policy of a claim

data/lib/yt/models/channel.rb

@@ -141,12 +141,6 @@ module Yt
       # @macro report_by_day_and_country
       has_report :subscribers_lost, Integer
 
-      # @macro report_by_day_and_country
-      has_report :favorites_added, Integer
-
-      # @macro report_by_day_and_country
-      has_report :favorites_removed, Integer
-
       # @macro report_by_day_and_country
       has_report :videos_added_to_playlists, Integer
 

data/lib/yt/models/video.rb

@@ -424,12 +424,6 @@ module Yt
       # @macro report_by_day_and_country
       has_report :subscribers_lost, Integer
 
-      # @macro report_by_day_and_country
-      has_report :favorites_added, Integer
-
-      # @macro report_by_day_and_country
-      has_report :favorites_removed, Integer
-
       # @macro report_by_day_and_country
       has_report :videos_added_to_playlists, Integer
 

data/lib/yt/models/video_group.rb

@@ -68,12 +68,6 @@ module Yt
       # @macro report_by_day_and_country
       has_report :subscribers_lost, Integer
 
-      # @macro report_by_day_and_country
-      has_report :favorites_added, Integer
-
-      # @macro report_by_day_and_country
-      has_report :favorites_removed, Integer
-
       # @macro report_by_day_and_country
       has_report :videos_added_to_playlists, Integer
 

data/lib/yt/version.rb

@@ -1,3 +1,3 @@
 module Yt
-  VERSION = '0.25.40'
+  VERSION = '0.26.0'
 end

data/spec/requests/as_account/channel_spec.rb

@@ -213,8 +213,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
@@ -236,8 +234,6 @@ describe Yt::Channel, :device_app do
       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

data/spec/requests/as_account/video_spec.rb

@@ -290,8 +290,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
@@ -314,8 +312,2106 @@ describe Yt::Video, :device_app do
       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
+    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) { 'MESycYJytkU' }
+
+    it { expect(video.content_detail).to be_a Yt::ContentDetail }
+
+    it 'returns valid metadata' do
+      expect(video.title).to be_a String
+      expect(video.description).to be_a String
+      expect(video.thumbnail_url).to be_a String
+      expect(video.published_at).to be_a Time
+      expect(video.privacy_status).to be_a String
+      expect(video.tags).to be_an Array
+      expect(video.channel_id).to be_a String
+      expect(video.channel_title).to be_a String
+      expect(video.category_id).to be_a String
+      expect(video.live_broadcast_content).to be_a String
+      expect(video.view_count).to be_an Integer
+      expect(video.like_count).to be_an Integer
+      expect(video.dislike_count).to be_an Integer
+      expect(video.favorite_count).to be_an Integer
+      expect(video.comment_count).to be_an Integer
+      expect(video.duration).to be_an Integer
+      expect(video.hd?).to be_in [true, false]
+      expect(video.stereoscopic?).to be_in [true, false]
+      expect(video.captioned?).to be_in [true, false]
+      expect(video.licensed?).to be_in [true, false]
+      expect(video.deleted?).to be_in [true, false]
+      expect(video.failed?).to be_in [true, false]
+      expect(video.processed?).to be_in [true, false]
+      expect(video.rejected?).to be_in [true, false]
+      expect(video.uploading?).to be_in [true, false]
+      expect(video.uses_unsupported_codec?).to be_in [true, false]
+      expect(video.has_failed_conversion?).to be_in [true, false]
+      expect(video.empty?).to be_in [true, false]
+      expect(video.invalid?).to be_in [true, false]
+      expect(video.too_small?).to be_in [true, false]
+      expect(video.aborted?).to be_in [true, false]
+      expect(video.claimed?).to be_in [true, false]
+      expect(video.infringes_copyright?).to be_in [true, false]
+      expect(video.duplicate?).to be_in [true, false]
+      expect(video.scheduled_at.class).to be_in [NilClass, Time]
+      expect(video.scheduled?).to be_in [true, false]
+      expect(video.too_long?).to be_in [true, false]
+      expect(video.violates_terms_of_use?).to be_in [true, false]
+      expect(video.inappropriate?).to be_in [true, false]
+      expect(video.infringes_trademark?).to be_in [true, false]
+      expect(video.belongs_to_closed_account?).to be_in [true, false]
+      expect(video.belongs_to_suspended_account?).to be_in [true, false]
+      expect(video.licensed_as_creative_commons?).to be_in [true, false]
+      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
+      expect(video.has_public_stats_viewable?).to be_in [true, false]
+      expect(video.embeddable?).to be_in [true, false]
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_nil
+      expect(video.scheduled_end_time).to be_nil
+      expect(video.concurrent_viewers).to be_nil
+      expect(video.embed_html).to be_a String
+      expect(video.category_title).to be_a String
+    end
+
+    it { expect{video.update}.to fail }
+    it { expect{video.delete}.to fail.with 'forbidden' }
+
+    context 'that I like' do
+      before { video.like }
+      it { expect(video).to be_liked }
+      it { expect(video.dislike).to be true }
+    end
+
+    context 'that I dislike' do
+      before { video.dislike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+
+    context 'that I am indifferent to' do
+      before { video.unlike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+  end
+
+  context 'given someone else’s live video broadcast scheduled in the future' do
+    let(:id) { 'PqzGI8gO_gk' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_nil
+    end
+  end
+
+  context 'given someone else’s past live video broadcast' do
+    let(:id) { 'COOM8_tOy6U' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_a Time
+      expect(video.actual_end_time).to be_a Time
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_a Time
+      expect(video.concurrent_viewers).to be_nil
+    end
+  end
+
+  context 'given an unknown video' do
+    let(:id) { 'not-a-video-id' }
+
+    it { expect{video.content_detail}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.snippet}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.rating}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.status}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.statistics_set}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.file_detail}.to raise_error Yt::Errors::NoItems }
+  end
+
+  context 'given one of my own videos that I want to delete' do
+    before(:all) { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: "Yt Test Delete Video #{rand}" }
+    let(:id) { @tmp_video.id }
+
+    it { expect(video.delete).to be true }
+  end
+
+  context 'given one of my own videos that I want to update' do
+    let(:id) { $account.videos.where(order: 'viewCount').first.id }
+    let!(:old_title) { video.title }
+    let!(:old_privacy_status) { video.privacy_status }
+    let(:update) { video.update attrs }
+
+    context 'given I update the title' do
+      # NOTE: The use of UTF-8 characters is to test that we can pass up to
+      # 50 characters, independently of their representation
+      let(:attrs) { {title: "Yt Example Update Video #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the title' do
+        expect(update).to be true
+        expect(video.title).not_to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the description' do
+      let!(:old_description) { video.description }
+      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the description' do
+        expect(update).to be true
+        expect(video.description).not_to eq old_description
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the tags' do
+      let!(:old_tags) { video.tags }
+      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
+
+      specify 'only updates the tag' do
+        expect(update).to be true
+        expect(video.tags).not_to eq old_tags
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the category ID' do
+      let!(:old_category_id) { video.category_id }
+      let!(:new_category_id) { old_category_id == '22' ? '21' : '22' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {category_id: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+          expect(video.title).to eq old_title
+          expect(video.privacy_status).to eq old_privacy_status
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {categoryId: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+        end
+      end
+    end
+
+    context 'given I update title, description and/or tags using angle brackets' do
+      let(:attrs) { {title: "Example Yt Test < >", description: '< >', tags: ['<tag>']} }
+
+      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
+        expect(update).to be true
+        expect(video.title).to eq 'Example Yt Test ‹ ›'
+        expect(video.description).to eq '‹ ›'
+        expect(video.tags).to eq ['‹tag›']
+      end
+    end
+
+    # note: 'scheduled' videos cannot be set to 'unlisted'
+    context 'given I update the privacy status' do
+      before { video.update publish_at: nil if video.scheduled? }
+      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {privacy_status: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {privacyStatus: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    context 'given I update the embeddable status' do
+      let!(:old_embeddable) { video.embeddable? }
+      let!(:new_embeddable) { !old_embeddable }
+
+      let(:attrs) { {embeddable: new_embeddable} }
+
+      # @note: This test is a reflection of another irrational behavior of
+      #   YouTube API. Although 'embeddable' can be passed as an 'update'
+      #   attribute according to the documentation, it simply does not work.
+      #   The day YouTube fixes it, then this test will finally fail and will
+      #   be removed, documenting how to update 'embeddable' too.
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      # @see https://code.google.com/p/gdata-issues/issues/detail?id=4861
+      specify 'does not update the embeddable status' do
+        expect(update).to be true
+        expect(video.embeddable?).to eq old_embeddable
+      end
+    end
+
+    context 'given I update the public stats viewable setting' do
+      let!(:old_public_stats_viewable) { video.has_public_stats_viewable? }
+      let!(:new_public_stats_viewable) { !old_public_stats_viewable }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {public_stats_viewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {publicStatsViewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    it 'returns valid reports for video-related metrics' do
+      # Some reports are only available to Content Owners.
+      # See content owner test for more details about what the methods return.
+      expect{video.views}.not_to raise_error
+      expect{video.comments}.not_to raise_error
+      expect{video.likes}.not_to raise_error
+      expect{video.dislikes}.not_to raise_error
+      expect{video.shares}.not_to raise_error
+      expect{video.subscribers_gained}.not_to raise_error
+      expect{video.subscribers_lost}.not_to raise_error
+      expect{video.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.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{video.impressions}.to raise_error Yt::Errors::Unauthorized
+      expect{video.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
+      expect{video.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
+      expect{video.advertising_options_set}.to raise_error Yt::Errors::Forbidden
+
+      expect{video.views_on 3.days.ago}.not_to raise_error
+      expect{video.comments_on 3.days.ago}.not_to raise_error
+      expect{video.likes_on 3.days.ago}.not_to raise_error
+      expect{video.dislikes_on 3.days.ago}.not_to raise_error
+      expect{video.shares_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_lost_on 3.days.ago}.not_to raise_error
+      expect{video.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
+    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) { 'MESycYJytkU' }
+
+    it { expect(video.content_detail).to be_a Yt::ContentDetail }
+
+    it 'returns valid metadata' do
+      expect(video.title).to be_a String
+      expect(video.description).to be_a String
+      expect(video.thumbnail_url).to be_a String
+      expect(video.published_at).to be_a Time
+      expect(video.privacy_status).to be_a String
+      expect(video.tags).to be_an Array
+      expect(video.channel_id).to be_a String
+      expect(video.channel_title).to be_a String
+      expect(video.category_id).to be_a String
+      expect(video.live_broadcast_content).to be_a String
+      expect(video.view_count).to be_an Integer
+      expect(video.like_count).to be_an Integer
+      expect(video.dislike_count).to be_an Integer
+      expect(video.favorite_count).to be_an Integer
+      expect(video.comment_count).to be_an Integer
+      expect(video.duration).to be_an Integer
+      expect(video.hd?).to be_in [true, false]
+      expect(video.stereoscopic?).to be_in [true, false]
+      expect(video.captioned?).to be_in [true, false]
+      expect(video.licensed?).to be_in [true, false]
+      expect(video.deleted?).to be_in [true, false]
+      expect(video.failed?).to be_in [true, false]
+      expect(video.processed?).to be_in [true, false]
+      expect(video.rejected?).to be_in [true, false]
+      expect(video.uploading?).to be_in [true, false]
+      expect(video.uses_unsupported_codec?).to be_in [true, false]
+      expect(video.has_failed_conversion?).to be_in [true, false]
+      expect(video.empty?).to be_in [true, false]
+      expect(video.invalid?).to be_in [true, false]
+      expect(video.too_small?).to be_in [true, false]
+      expect(video.aborted?).to be_in [true, false]
+      expect(video.claimed?).to be_in [true, false]
+      expect(video.infringes_copyright?).to be_in [true, false]
+      expect(video.duplicate?).to be_in [true, false]
+      expect(video.scheduled_at.class).to be_in [NilClass, Time]
+      expect(video.scheduled?).to be_in [true, false]
+      expect(video.too_long?).to be_in [true, false]
+      expect(video.violates_terms_of_use?).to be_in [true, false]
+      expect(video.inappropriate?).to be_in [true, false]
+      expect(video.infringes_trademark?).to be_in [true, false]
+      expect(video.belongs_to_closed_account?).to be_in [true, false]
+      expect(video.belongs_to_suspended_account?).to be_in [true, false]
+      expect(video.licensed_as_creative_commons?).to be_in [true, false]
+      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
+      expect(video.has_public_stats_viewable?).to be_in [true, false]
+      expect(video.embeddable?).to be_in [true, false]
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_nil
+      expect(video.scheduled_end_time).to be_nil
+      expect(video.concurrent_viewers).to be_nil
+      expect(video.embed_html).to be_a String
+      expect(video.category_title).to be_a String
+    end
+
+    it { expect{video.update}.to fail }
+    it { expect{video.delete}.to fail.with 'forbidden' }
+
+    context 'that I like' do
+      before { video.like }
+      it { expect(video).to be_liked }
+      it { expect(video.dislike).to be true }
+    end
+
+    context 'that I dislike' do
+      before { video.dislike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+
+    context 'that I am indifferent to' do
+      before { video.unlike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+  end
+
+  context 'given someone else’s live video broadcast scheduled in the future' do
+    let(:id) { 'PqzGI8gO_gk' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_nil
+    end
+  end
+
+  context 'given someone else’s past live video broadcast' do
+    let(:id) { 'COOM8_tOy6U' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_a Time
+      expect(video.actual_end_time).to be_a Time
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_a Time
+      expect(video.concurrent_viewers).to be_nil
+    end
+  end
+
+  context 'given an unknown video' do
+    let(:id) { 'not-a-video-id' }
+
+    it { expect{video.content_detail}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.snippet}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.rating}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.status}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.statistics_set}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.file_detail}.to raise_error Yt::Errors::NoItems }
+  end
+
+  context 'given one of my own videos that I want to delete' do
+    before(:all) { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: "Yt Test Delete Video #{rand}" }
+    let(:id) { @tmp_video.id }
+
+    it { expect(video.delete).to be true }
+  end
+
+  context 'given one of my own videos that I want to update' do
+    let(:id) { $account.videos.where(order: 'viewCount').first.id }
+    let!(:old_title) { video.title }
+    let!(:old_privacy_status) { video.privacy_status }
+    let(:update) { video.update attrs }
+
+    context 'given I update the title' do
+      # NOTE: The use of UTF-8 characters is to test that we can pass up to
+      # 50 characters, independently of their representation
+      let(:attrs) { {title: "Yt Example Update Video #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the title' do
+        expect(update).to be true
+        expect(video.title).not_to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the description' do
+      let!(:old_description) { video.description }
+      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the description' do
+        expect(update).to be true
+        expect(video.description).not_to eq old_description
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the tags' do
+      let!(:old_tags) { video.tags }
+      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
+
+      specify 'only updates the tag' do
+        expect(update).to be true
+        expect(video.tags).not_to eq old_tags
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the category ID' do
+      let!(:old_category_id) { video.category_id }
+      let!(:new_category_id) { old_category_id == '22' ? '21' : '22' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {category_id: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+          expect(video.title).to eq old_title
+          expect(video.privacy_status).to eq old_privacy_status
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {categoryId: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+        end
+      end
+    end
+
+    context 'given I update title, description and/or tags using angle brackets' do
+      let(:attrs) { {title: "Example Yt Test < >", description: '< >', tags: ['<tag>']} }
+
+      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
+        expect(update).to be true
+        expect(video.title).to eq 'Example Yt Test ‹ ›'
+        expect(video.description).to eq '‹ ›'
+        expect(video.tags).to eq ['‹tag›']
+      end
+    end
+
+    # note: 'scheduled' videos cannot be set to 'unlisted'
+    context 'given I update the privacy status' do
+      before { video.update publish_at: nil if video.scheduled? }
+      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {privacy_status: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {privacyStatus: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    context 'given I update the embeddable status' do
+      let!(:old_embeddable) { video.embeddable? }
+      let!(:new_embeddable) { !old_embeddable }
+
+      let(:attrs) { {embeddable: new_embeddable} }
+
+      # @note: This test is a reflection of another irrational behavior of
+      #   YouTube API. Although 'embeddable' can be passed as an 'update'
+      #   attribute according to the documentation, it simply does not work.
+      #   The day YouTube fixes it, then this test will finally fail and will
+      #   be removed, documenting how to update 'embeddable' too.
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      # @see https://code.google.com/p/gdata-issues/issues/detail?id=4861
+      specify 'does not update the embeddable status' do
+        expect(update).to be true
+        expect(video.embeddable?).to eq old_embeddable
+      end
+    end
+
+    context 'given I update the public stats viewable setting' do
+      let!(:old_public_stats_viewable) { video.has_public_stats_viewable? }
+      let!(:new_public_stats_viewable) { !old_public_stats_viewable }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {public_stats_viewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {publicStatsViewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    it 'returns valid reports for video-related metrics' do
+      # Some reports are only available to Content Owners.
+      # See content owner test for more details about what the methods return.
+      expect{video.views}.not_to raise_error
+      expect{video.comments}.not_to raise_error
+      expect{video.likes}.not_to raise_error
+      expect{video.dislikes}.not_to raise_error
+      expect{video.shares}.not_to raise_error
+      expect{video.subscribers_gained}.not_to raise_error
+      expect{video.subscribers_lost}.not_to raise_error
+      expect{video.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.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{video.impressions}.to raise_error Yt::Errors::Unauthorized
+      expect{video.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
+      expect{video.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
+      expect{video.advertising_options_set}.to raise_error Yt::Errors::Forbidden
+
+      expect{video.views_on 3.days.ago}.not_to raise_error
+      expect{video.comments_on 3.days.ago}.not_to raise_error
+      expect{video.likes_on 3.days.ago}.not_to raise_error
+      expect{video.dislikes_on 3.days.ago}.not_to raise_error
+      expect{video.shares_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_lost_on 3.days.ago}.not_to raise_error
+      expect{video.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
+    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) { 'MESycYJytkU' }
+
+    it { expect(video.content_detail).to be_a Yt::ContentDetail }
+
+    it 'returns valid metadata' do
+      expect(video.title).to be_a String
+      expect(video.description).to be_a String
+      expect(video.thumbnail_url).to be_a String
+      expect(video.published_at).to be_a Time
+      expect(video.privacy_status).to be_a String
+      expect(video.tags).to be_an Array
+      expect(video.channel_id).to be_a String
+      expect(video.channel_title).to be_a String
+      expect(video.category_id).to be_a String
+      expect(video.live_broadcast_content).to be_a String
+      expect(video.view_count).to be_an Integer
+      expect(video.like_count).to be_an Integer
+      expect(video.dislike_count).to be_an Integer
+      expect(video.favorite_count).to be_an Integer
+      expect(video.comment_count).to be_an Integer
+      expect(video.duration).to be_an Integer
+      expect(video.hd?).to be_in [true, false]
+      expect(video.stereoscopic?).to be_in [true, false]
+      expect(video.captioned?).to be_in [true, false]
+      expect(video.licensed?).to be_in [true, false]
+      expect(video.deleted?).to be_in [true, false]
+      expect(video.failed?).to be_in [true, false]
+      expect(video.processed?).to be_in [true, false]
+      expect(video.rejected?).to be_in [true, false]
+      expect(video.uploading?).to be_in [true, false]
+      expect(video.uses_unsupported_codec?).to be_in [true, false]
+      expect(video.has_failed_conversion?).to be_in [true, false]
+      expect(video.empty?).to be_in [true, false]
+      expect(video.invalid?).to be_in [true, false]
+      expect(video.too_small?).to be_in [true, false]
+      expect(video.aborted?).to be_in [true, false]
+      expect(video.claimed?).to be_in [true, false]
+      expect(video.infringes_copyright?).to be_in [true, false]
+      expect(video.duplicate?).to be_in [true, false]
+      expect(video.scheduled_at.class).to be_in [NilClass, Time]
+      expect(video.scheduled?).to be_in [true, false]
+      expect(video.too_long?).to be_in [true, false]
+      expect(video.violates_terms_of_use?).to be_in [true, false]
+      expect(video.inappropriate?).to be_in [true, false]
+      expect(video.infringes_trademark?).to be_in [true, false]
+      expect(video.belongs_to_closed_account?).to be_in [true, false]
+      expect(video.belongs_to_suspended_account?).to be_in [true, false]
+      expect(video.licensed_as_creative_commons?).to be_in [true, false]
+      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
+      expect(video.has_public_stats_viewable?).to be_in [true, false]
+      expect(video.embeddable?).to be_in [true, false]
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_nil
+      expect(video.scheduled_end_time).to be_nil
+      expect(video.concurrent_viewers).to be_nil
+      expect(video.embed_html).to be_a String
+      expect(video.category_title).to be_a String
+    end
+
+    it { expect{video.update}.to fail }
+    it { expect{video.delete}.to fail.with 'forbidden' }
+
+    context 'that I like' do
+      before { video.like }
+      it { expect(video).to be_liked }
+      it { expect(video.dislike).to be true }
+    end
+
+    context 'that I dislike' do
+      before { video.dislike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+
+    context 'that I am indifferent to' do
+      before { video.unlike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+  end
+
+  context 'given someone else’s live video broadcast scheduled in the future' do
+    let(:id) { 'PqzGI8gO_gk' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_nil
+    end
+  end
+
+  context 'given someone else’s past live video broadcast' do
+    let(:id) { 'COOM8_tOy6U' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_a Time
+      expect(video.actual_end_time).to be_a Time
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_a Time
+      expect(video.concurrent_viewers).to be_nil
+    end
+  end
+
+  context 'given an unknown video' do
+    let(:id) { 'not-a-video-id' }
+
+    it { expect{video.content_detail}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.snippet}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.rating}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.status}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.statistics_set}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.file_detail}.to raise_error Yt::Errors::NoItems }
+  end
+
+  context 'given one of my own videos that I want to delete' do
+    before(:all) { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: "Yt Test Delete Video #{rand}" }
+    let(:id) { @tmp_video.id }
+
+    it { expect(video.delete).to be true }
+  end
+
+  context 'given one of my own videos that I want to update' do
+    let(:id) { $account.videos.where(order: 'viewCount').first.id }
+    let!(:old_title) { video.title }
+    let!(:old_privacy_status) { video.privacy_status }
+    let(:update) { video.update attrs }
+
+    context 'given I update the title' do
+      # NOTE: The use of UTF-8 characters is to test that we can pass up to
+      # 50 characters, independently of their representation
+      let(:attrs) { {title: "Yt Example Update Video #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the title' do
+        expect(update).to be true
+        expect(video.title).not_to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the description' do
+      let!(:old_description) { video.description }
+      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the description' do
+        expect(update).to be true
+        expect(video.description).not_to eq old_description
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the tags' do
+      let!(:old_tags) { video.tags }
+      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
+
+      specify 'only updates the tag' do
+        expect(update).to be true
+        expect(video.tags).not_to eq old_tags
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the category ID' do
+      let!(:old_category_id) { video.category_id }
+      let!(:new_category_id) { old_category_id == '22' ? '21' : '22' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {category_id: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+          expect(video.title).to eq old_title
+          expect(video.privacy_status).to eq old_privacy_status
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {categoryId: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+        end
+      end
+    end
+
+    context 'given I update title, description and/or tags using angle brackets' do
+      let(:attrs) { {title: "Example Yt Test < >", description: '< >', tags: ['<tag>']} }
+
+      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
+        expect(update).to be true
+        expect(video.title).to eq 'Example Yt Test ‹ ›'
+        expect(video.description).to eq '‹ ›'
+        expect(video.tags).to eq ['‹tag›']
+      end
+    end
+
+    # note: 'scheduled' videos cannot be set to 'unlisted'
+    context 'given I update the privacy status' do
+      before { video.update publish_at: nil if video.scheduled? }
+      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {privacy_status: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {privacyStatus: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    context 'given I update the embeddable status' do
+      let!(:old_embeddable) { video.embeddable? }
+      let!(:new_embeddable) { !old_embeddable }
+
+      let(:attrs) { {embeddable: new_embeddable} }
+
+      # @note: This test is a reflection of another irrational behavior of
+      #   YouTube API. Although 'embeddable' can be passed as an 'update'
+      #   attribute according to the documentation, it simply does not work.
+      #   The day YouTube fixes it, then this test will finally fail and will
+      #   be removed, documenting how to update 'embeddable' too.
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      # @see https://code.google.com/p/gdata-issues/issues/detail?id=4861
+      specify 'does not update the embeddable status' do
+        expect(update).to be true
+        expect(video.embeddable?).to eq old_embeddable
+      end
+    end
+
+    context 'given I update the public stats viewable setting' do
+      let!(:old_public_stats_viewable) { video.has_public_stats_viewable? }
+      let!(:new_public_stats_viewable) { !old_public_stats_viewable }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {public_stats_viewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {publicStatsViewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    it 'returns valid reports for video-related metrics' do
+      # Some reports are only available to Content Owners.
+      # See content owner test for more details about what the methods return.
+      expect{video.views}.not_to raise_error
+      expect{video.comments}.not_to raise_error
+      expect{video.likes}.not_to raise_error
+      expect{video.dislikes}.not_to raise_error
+      expect{video.shares}.not_to raise_error
+      expect{video.subscribers_gained}.not_to raise_error
+      expect{video.subscribers_lost}.not_to raise_error
+      expect{video.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.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{video.impressions}.to raise_error Yt::Errors::Unauthorized
+      expect{video.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
+      expect{video.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
+      expect{video.advertising_options_set}.to raise_error Yt::Errors::Forbidden
+
+      expect{video.views_on 3.days.ago}.not_to raise_error
+      expect{video.comments_on 3.days.ago}.not_to raise_error
+      expect{video.likes_on 3.days.ago}.not_to raise_error
+      expect{video.dislikes_on 3.days.ago}.not_to raise_error
+      expect{video.shares_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_lost_on 3.days.ago}.not_to raise_error
+      expect{video.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
+    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) { 'MESycYJytkU' }
+
+    it { expect(video.content_detail).to be_a Yt::ContentDetail }
+
+    it 'returns valid metadata' do
+      expect(video.title).to be_a String
+      expect(video.description).to be_a String
+      expect(video.thumbnail_url).to be_a String
+      expect(video.published_at).to be_a Time
+      expect(video.privacy_status).to be_a String
+      expect(video.tags).to be_an Array
+      expect(video.channel_id).to be_a String
+      expect(video.channel_title).to be_a String
+      expect(video.category_id).to be_a String
+      expect(video.live_broadcast_content).to be_a String
+      expect(video.view_count).to be_an Integer
+      expect(video.like_count).to be_an Integer
+      expect(video.dislike_count).to be_an Integer
+      expect(video.favorite_count).to be_an Integer
+      expect(video.comment_count).to be_an Integer
+      expect(video.duration).to be_an Integer
+      expect(video.hd?).to be_in [true, false]
+      expect(video.stereoscopic?).to be_in [true, false]
+      expect(video.captioned?).to be_in [true, false]
+      expect(video.licensed?).to be_in [true, false]
+      expect(video.deleted?).to be_in [true, false]
+      expect(video.failed?).to be_in [true, false]
+      expect(video.processed?).to be_in [true, false]
+      expect(video.rejected?).to be_in [true, false]
+      expect(video.uploading?).to be_in [true, false]
+      expect(video.uses_unsupported_codec?).to be_in [true, false]
+      expect(video.has_failed_conversion?).to be_in [true, false]
+      expect(video.empty?).to be_in [true, false]
+      expect(video.invalid?).to be_in [true, false]
+      expect(video.too_small?).to be_in [true, false]
+      expect(video.aborted?).to be_in [true, false]
+      expect(video.claimed?).to be_in [true, false]
+      expect(video.infringes_copyright?).to be_in [true, false]
+      expect(video.duplicate?).to be_in [true, false]
+      expect(video.scheduled_at.class).to be_in [NilClass, Time]
+      expect(video.scheduled?).to be_in [true, false]
+      expect(video.too_long?).to be_in [true, false]
+      expect(video.violates_terms_of_use?).to be_in [true, false]
+      expect(video.inappropriate?).to be_in [true, false]
+      expect(video.infringes_trademark?).to be_in [true, false]
+      expect(video.belongs_to_closed_account?).to be_in [true, false]
+      expect(video.belongs_to_suspended_account?).to be_in [true, false]
+      expect(video.licensed_as_creative_commons?).to be_in [true, false]
+      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
+      expect(video.has_public_stats_viewable?).to be_in [true, false]
+      expect(video.embeddable?).to be_in [true, false]
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_nil
+      expect(video.scheduled_end_time).to be_nil
+      expect(video.concurrent_viewers).to be_nil
+      expect(video.embed_html).to be_a String
+      expect(video.category_title).to be_a String
+    end
+
+    it { expect{video.update}.to fail }
+    it { expect{video.delete}.to fail.with 'forbidden' }
+
+    context 'that I like' do
+      before { video.like }
+      it { expect(video).to be_liked }
+      it { expect(video.dislike).to be true }
+    end
+
+    context 'that I dislike' do
+      before { video.dislike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+
+    context 'that I am indifferent to' do
+      before { video.unlike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+  end
+
+  context 'given someone else’s live video broadcast scheduled in the future' do
+    let(:id) { 'PqzGI8gO_gk' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_nil
+    end
+  end
+
+  context 'given someone else’s past live video broadcast' do
+    let(:id) { 'COOM8_tOy6U' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_a Time
+      expect(video.actual_end_time).to be_a Time
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_a Time
+      expect(video.concurrent_viewers).to be_nil
+    end
+  end
+
+  context 'given an unknown video' do
+    let(:id) { 'not-a-video-id' }
+
+    it { expect{video.content_detail}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.snippet}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.rating}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.status}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.statistics_set}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.file_detail}.to raise_error Yt::Errors::NoItems }
+  end
+
+  context 'given one of my own videos that I want to delete' do
+    before(:all) { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: "Yt Test Delete Video #{rand}" }
+    let(:id) { @tmp_video.id }
+
+    it { expect(video.delete).to be true }
+  end
+
+  context 'given one of my own videos that I want to update' do
+    let(:id) { $account.videos.where(order: 'viewCount').first.id }
+    let!(:old_title) { video.title }
+    let!(:old_privacy_status) { video.privacy_status }
+    let(:update) { video.update attrs }
+
+    context 'given I update the title' do
+      # NOTE: The use of UTF-8 characters is to test that we can pass up to
+      # 50 characters, independently of their representation
+      let(:attrs) { {title: "Yt Example Update Video #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the title' do
+        expect(update).to be true
+        expect(video.title).not_to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the description' do
+      let!(:old_description) { video.description }
+      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the description' do
+        expect(update).to be true
+        expect(video.description).not_to eq old_description
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the tags' do
+      let!(:old_tags) { video.tags }
+      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
+
+      specify 'only updates the tag' do
+        expect(update).to be true
+        expect(video.tags).not_to eq old_tags
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the category ID' do
+      let!(:old_category_id) { video.category_id }
+      let!(:new_category_id) { old_category_id == '22' ? '21' : '22' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {category_id: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+          expect(video.title).to eq old_title
+          expect(video.privacy_status).to eq old_privacy_status
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {categoryId: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+        end
+      end
+    end
+
+    context 'given I update title, description and/or tags using angle brackets' do
+      let(:attrs) { {title: "Example Yt Test < >", description: '< >', tags: ['<tag>']} }
+
+      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
+        expect(update).to be true
+        expect(video.title).to eq 'Example Yt Test ‹ ›'
+        expect(video.description).to eq '‹ ›'
+        expect(video.tags).to eq ['‹tag›']
+      end
+    end
+
+    # note: 'scheduled' videos cannot be set to 'unlisted'
+    context 'given I update the privacy status' do
+      before { video.update publish_at: nil if video.scheduled? }
+      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {privacy_status: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {privacyStatus: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    context 'given I update the embeddable status' do
+      let!(:old_embeddable) { video.embeddable? }
+      let!(:new_embeddable) { !old_embeddable }
+
+      let(:attrs) { {embeddable: new_embeddable} }
+
+      # @note: This test is a reflection of another irrational behavior of
+      #   YouTube API. Although 'embeddable' can be passed as an 'update'
+      #   attribute according to the documentation, it simply does not work.
+      #   The day YouTube fixes it, then this test will finally fail and will
+      #   be removed, documenting how to update 'embeddable' too.
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      # @see https://code.google.com/p/gdata-issues/issues/detail?id=4861
+      specify 'does not update the embeddable status' do
+        expect(update).to be true
+        expect(video.embeddable?).to eq old_embeddable
+      end
+    end
+
+    context 'given I update the public stats viewable setting' do
+      let!(:old_public_stats_viewable) { video.has_public_stats_viewable? }
+      let!(:new_public_stats_viewable) { !old_public_stats_viewable }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {public_stats_viewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {publicStatsViewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    it 'returns valid reports for video-related metrics' do
+      # Some reports are only available to Content Owners.
+      # See content owner test for more details about what the methods return.
+      expect{video.views}.not_to raise_error
+      expect{video.comments}.not_to raise_error
+      expect{video.likes}.not_to raise_error
+      expect{video.dislikes}.not_to raise_error
+      expect{video.shares}.not_to raise_error
+      expect{video.subscribers_gained}.not_to raise_error
+      expect{video.subscribers_lost}.not_to raise_error
+      expect{video.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.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{video.impressions}.to raise_error Yt::Errors::Unauthorized
+      expect{video.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
+      expect{video.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
+      expect{video.advertising_options_set}.to raise_error Yt::Errors::Forbidden
+
+      expect{video.views_on 3.days.ago}.not_to raise_error
+      expect{video.comments_on 3.days.ago}.not_to raise_error
+      expect{video.likes_on 3.days.ago}.not_to raise_error
+      expect{video.dislikes_on 3.days.ago}.not_to raise_error
+      expect{video.shares_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_lost_on 3.days.ago}.not_to raise_error
+      expect{video.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
+    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) { 'MESycYJytkU' }
+
+    it { expect(video.content_detail).to be_a Yt::ContentDetail }
+
+    it 'returns valid metadata' do
+      expect(video.title).to be_a String
+      expect(video.description).to be_a String
+      expect(video.thumbnail_url).to be_a String
+      expect(video.published_at).to be_a Time
+      expect(video.privacy_status).to be_a String
+      expect(video.tags).to be_an Array
+      expect(video.channel_id).to be_a String
+      expect(video.channel_title).to be_a String
+      expect(video.category_id).to be_a String
+      expect(video.live_broadcast_content).to be_a String
+      expect(video.view_count).to be_an Integer
+      expect(video.like_count).to be_an Integer
+      expect(video.dislike_count).to be_an Integer
+      expect(video.favorite_count).to be_an Integer
+      expect(video.comment_count).to be_an Integer
+      expect(video.duration).to be_an Integer
+      expect(video.hd?).to be_in [true, false]
+      expect(video.stereoscopic?).to be_in [true, false]
+      expect(video.captioned?).to be_in [true, false]
+      expect(video.licensed?).to be_in [true, false]
+      expect(video.deleted?).to be_in [true, false]
+      expect(video.failed?).to be_in [true, false]
+      expect(video.processed?).to be_in [true, false]
+      expect(video.rejected?).to be_in [true, false]
+      expect(video.uploading?).to be_in [true, false]
+      expect(video.uses_unsupported_codec?).to be_in [true, false]
+      expect(video.has_failed_conversion?).to be_in [true, false]
+      expect(video.empty?).to be_in [true, false]
+      expect(video.invalid?).to be_in [true, false]
+      expect(video.too_small?).to be_in [true, false]
+      expect(video.aborted?).to be_in [true, false]
+      expect(video.claimed?).to be_in [true, false]
+      expect(video.infringes_copyright?).to be_in [true, false]
+      expect(video.duplicate?).to be_in [true, false]
+      expect(video.scheduled_at.class).to be_in [NilClass, Time]
+      expect(video.scheduled?).to be_in [true, false]
+      expect(video.too_long?).to be_in [true, false]
+      expect(video.violates_terms_of_use?).to be_in [true, false]
+      expect(video.inappropriate?).to be_in [true, false]
+      expect(video.infringes_trademark?).to be_in [true, false]
+      expect(video.belongs_to_closed_account?).to be_in [true, false]
+      expect(video.belongs_to_suspended_account?).to be_in [true, false]
+      expect(video.licensed_as_creative_commons?).to be_in [true, false]
+      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
+      expect(video.has_public_stats_viewable?).to be_in [true, false]
+      expect(video.embeddable?).to be_in [true, false]
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_nil
+      expect(video.scheduled_end_time).to be_nil
+      expect(video.concurrent_viewers).to be_nil
+      expect(video.embed_html).to be_a String
+      expect(video.category_title).to be_a String
+    end
+
+    it { expect{video.update}.to fail }
+    it { expect{video.delete}.to fail.with 'forbidden' }
+
+    context 'that I like' do
+      before { video.like }
+      it { expect(video).to be_liked }
+      it { expect(video.dislike).to be true }
+    end
+
+    context 'that I dislike' do
+      before { video.dislike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+
+    context 'that I am indifferent to' do
+      before { video.unlike }
+      it { expect(video).not_to be_liked }
+      it { expect(video.like).to be true }
+    end
+  end
+
+  context 'given someone else’s live video broadcast scheduled in the future' do
+    let(:id) { 'PqzGI8gO_gk' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_nil
+      expect(video.actual_end_time).to be_nil
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_nil
+    end
+  end
+
+  context 'given someone else’s past live video broadcast' do
+    let(:id) { 'COOM8_tOy6U' }
+
+    it 'returns valid live streaming details' do
+      expect(video.actual_start_time).to be_a Time
+      expect(video.actual_end_time).to be_a Time
+      expect(video.scheduled_start_time).to be_a Time
+      expect(video.scheduled_end_time).to be_a Time
+      expect(video.concurrent_viewers).to be_nil
+    end
+  end
+
+  context 'given an unknown video' do
+    let(:id) { 'not-a-video-id' }
+
+    it { expect{video.content_detail}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.snippet}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.rating}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.status}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.statistics_set}.to raise_error Yt::Errors::NoItems }
+    it { expect{video.file_detail}.to raise_error Yt::Errors::NoItems }
+  end
+
+  context 'given one of my own videos that I want to delete' do
+    before(:all) { @tmp_video = $account.upload_video 'https://bit.ly/yt_test', title: "Yt Test Delete Video #{rand}" }
+    let(:id) { @tmp_video.id }
+
+    it { expect(video.delete).to be true }
+  end
+
+  context 'given one of my own videos that I want to update' do
+    let(:id) { $account.videos.where(order: 'viewCount').first.id }
+    let!(:old_title) { video.title }
+    let!(:old_privacy_status) { video.privacy_status }
+    let(:update) { video.update attrs }
+
+    context 'given I update the title' do
+      # NOTE: The use of UTF-8 characters is to test that we can pass up to
+      # 50 characters, independently of their representation
+      let(:attrs) { {title: "Yt Example Update Video #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the title' do
+        expect(update).to be true
+        expect(video.title).not_to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the description' do
+      let!(:old_description) { video.description }
+      let(:attrs) { {description: "Yt Example Description  #{rand} - ®•♡❥❦❧☙"} }
+
+      specify 'only updates the description' do
+        expect(update).to be true
+        expect(video.description).not_to eq old_description
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the tags' do
+      let!(:old_tags) { video.tags }
+      let(:attrs) { {tags: ["Yt Test Tag #{rand}"]} }
+
+      specify 'only updates the tag' do
+        expect(update).to be true
+        expect(video.tags).not_to eq old_tags
+        expect(video.title).to eq old_title
+        expect(video.privacy_status).to eq old_privacy_status
+      end
+    end
+
+    context 'given I update the category ID' do
+      let!(:old_category_id) { video.category_id }
+      let!(:new_category_id) { old_category_id == '22' ? '21' : '22' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {category_id: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+          expect(video.title).to eq old_title
+          expect(video.privacy_status).to eq old_privacy_status
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {categoryId: new_category_id} }
+
+        specify 'only updates the category ID' do
+          expect(update).to be true
+          expect(video.category_id).not_to eq old_category_id
+        end
+      end
+    end
+
+    context 'given I update title, description and/or tags using angle brackets' do
+      let(:attrs) { {title: "Example Yt Test < >", description: '< >', tags: ['<tag>']} }
+
+      specify 'updates them replacing angle brackets with similar unicode characters accepted by YouTube' do
+        expect(update).to be true
+        expect(video.title).to eq 'Example Yt Test ‹ ›'
+        expect(video.description).to eq '‹ ›'
+        expect(video.tags).to eq ['‹tag›']
+      end
+    end
+
+    # note: 'scheduled' videos cannot be set to 'unlisted'
+    context 'given I update the privacy status' do
+      before { video.update publish_at: nil if video.scheduled? }
+      let!(:new_privacy_status) { old_privacy_status == 'private' ? 'unlisted' : 'private' }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {privacy_status: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {privacyStatus: new_privacy_status} }
+
+        specify 'only updates the privacy status' do
+          expect(update).to be true
+          expect(video.privacy_status).not_to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    context 'given I update the embeddable status' do
+      let!(:old_embeddable) { video.embeddable? }
+      let!(:new_embeddable) { !old_embeddable }
+
+      let(:attrs) { {embeddable: new_embeddable} }
+
+      # @note: This test is a reflection of another irrational behavior of
+      #   YouTube API. Although 'embeddable' can be passed as an 'update'
+      #   attribute according to the documentation, it simply does not work.
+      #   The day YouTube fixes it, then this test will finally fail and will
+      #   be removed, documenting how to update 'embeddable' too.
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      # @see https://code.google.com/p/gdata-issues/issues/detail?id=4861
+      specify 'does not update the embeddable status' do
+        expect(update).to be true
+        expect(video.embeddable?).to eq old_embeddable
+      end
+    end
+
+    context 'given I update the public stats viewable setting' do
+      let!(:old_public_stats_viewable) { video.has_public_stats_viewable? }
+      let!(:new_public_stats_viewable) { !old_public_stats_viewable }
+
+      context 'passing the parameter in underscore syntax' do
+        let(:attrs) { {public_stats_viewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+
+      context 'passing the parameter in camel-case syntax' do
+        let(:attrs) { {publicStatsViewable: new_public_stats_viewable} }
+
+        specify 'only updates the public stats viewable setting' do
+          expect(update).to be true
+          expect(video.has_public_stats_viewable?).to eq new_public_stats_viewable
+          expect(video.privacy_status).to eq old_privacy_status
+          expect(video.title).to eq old_title
+        end
+      end
+    end
+
+    it 'returns valid reports for video-related metrics' do
+      # Some reports are only available to Content Owners.
+      # See content owner test for more details about what the methods return.
+      expect{video.views}.not_to raise_error
+      expect{video.comments}.not_to raise_error
+      expect{video.likes}.not_to raise_error
+      expect{video.dislikes}.not_to raise_error
+      expect{video.shares}.not_to raise_error
+      expect{video.subscribers_gained}.not_to raise_error
+      expect{video.subscribers_lost}.not_to raise_error
+      expect{video.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.earnings}.to raise_error Yt::Errors::Unauthorized
+      expect{video.impressions}.to raise_error Yt::Errors::Unauthorized
+      expect{video.monetized_playbacks}.to raise_error Yt::Errors::Unauthorized
+      expect{video.playback_based_cpm}.to raise_error Yt::Errors::Unauthorized
+      expect{video.advertising_options_set}.to raise_error Yt::Errors::Forbidden
+
+      expect{video.views_on 3.days.ago}.not_to raise_error
+      expect{video.comments_on 3.days.ago}.not_to raise_error
+      expect{video.likes_on 3.days.ago}.not_to raise_error
+      expect{video.dislikes_on 3.days.ago}.not_to raise_error
+      expect{video.shares_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_gained_on 3.days.ago}.not_to raise_error
+      expect{video.subscribers_lost_on 3.days.ago}.not_to raise_error
       expect{video.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