yt-andrewroth 0.25.5.1

data/spec/models/resource_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'yt/models/resource'
+
+describe Yt::Resource do
+  subject(:resource) { Yt::Resource.new attrs }
+
+  context 'given a resource initialized with a URL (containing an ID)' do
+    let(:attrs) { {url: 'youtu.be/MESycYJytkU'} }
+
+    it { expect(resource.id).to eq 'MESycYJytkU' }
+    it { expect(resource.kind).to eq 'video' }
+    it { expect(resource.username).to be_nil }
+  end
+
+  context 'given a resource initialized with a URL (containing a username)' do
+    let(:attrs) { {url: 'youtube.com/fullscreen'} }
+
+    it { expect(resource.kind).to eq 'channel' }
+    it { expect(resource.username).to eq 'fullscreen' }
+  end
+
+  describe '#public?' do
+    context 'given fetching a status returns privacyStatus "public"' do
+      let(:attrs) { {status: {"privacyStatus"=>"public"}} }
+      it { expect(resource).to be_public }
+    end
+
+    context 'given fetching a status does not return privacyStatus "public"' do
+      let(:attrs) { {status: {}} }
+      it { expect(resource).not_to be_public }
+    end
+  end
+
+  describe '#private?' do
+    context 'given fetching a status returns privacyStatus "private"' do
+      let(:attrs) { {status: {"privacyStatus"=>"private"}} }
+      it { expect(resource).to be_private }
+    end
+
+    context 'given fetching a status does not return privacyStatus "private"' do
+      let(:attrs) { {status: {}} }
+      it { expect(resource).not_to be_private }
+    end
+  end
+
+  describe '#unlisted?' do
+    context 'given fetching a status returns privacyStatus "unlisted"' do
+      let(:attrs) { {status: {"privacyStatus"=>"unlisted"}} }
+      it { expect(resource).to be_unlisted }
+    end
+
+    context 'given fetching a status does not return privacyStatus "unlisted"' do
+      let(:attrs) { {status: {}} }
+      it { expect(resource).not_to be_unlisted }
+    end
+  end
+end

data/spec/models/right_owner_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'yt/models/right_owner'
+
+describe Yt::RightOwner do
+  subject(:right_owner) { Yt::RightOwner.new data: data }
+  let(:data) { {} }
+
+  describe '#ratio' do
+    context 'given fetching an owner returns a ratio' do
+      let(:data) { {"ratio"=>"20.0"} }
+      it { expect(right_owner.ratio).to eq 20 }
+    end
+  end
+
+  describe '#owner' do
+    context 'given fetching an owner returns an owner name' do
+      let(:data) { {"owner"=>"FullScreen"} }
+      it { expect(right_owner.owner).to eq 'FullScreen' }
+    end
+  end
+
+  describe '#owner' do
+    context 'given fetching an owner returns a publisher name' do
+      let(:data) { {"publisher"=>"Third Party"} }
+      it { expect(right_owner.publisher).to eq 'Third Party' }
+    end
+
+    context 'given fetching an owner does not return a publisher name' do
+      it { expect(right_owner.publisher).to be_nil }
+    end
+  end
+
+  describe '#included_territories' do
+    context 'given fetching an owner returns included territories' do
+      let(:data) { {"type"=>"include", "territories"=>["US", "CA"]} }
+      it { expect(right_owner.included_territories).to eq %w(US CA) }
+    end
+
+    context 'given fetching an owner does not return included territories' do
+      it { expect(right_owner.included_territories).to be_nil }
+    end
+  end
+
+  describe '#excluded_territories' do
+    context 'given fetching an owner returns excluded territories' do
+      let(:data) { {"type"=>"exclude", "territories"=>["US", "CA"]} }
+      it { expect(right_owner.excluded_territories).to eq %w(US CA) }
+    end
+
+    context 'given fetching an owner does not return excluded territories' do
+      it { expect(right_owner.excluded_territories).to be_nil }
+    end
+  end
+
+  describe '#everywhere?' do
+    context 'given fetching an owner returns zero excluded territories' do
+      let(:data) { {"type"=>"exclude", "territories"=>[]} }
+      it { expect(right_owner).to be_everywhere }
+    end
+
+    context 'given fetching an owner returns no excluded territories' do
+      let(:data) { {"type"=>"exclude"} }
+      it { expect(right_owner).to be_everywhere }
+    end
+
+    context 'given fetching an owner returns included territories' do
+      let(:data) { {"type"=>"include", "territories"=>[]} }
+      it { expect(right_owner).not_to be_everywhere }
+    end
+  end
+end

data/spec/models/snippet_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'yt/models/snippet'
+
+describe Yt::Snippet do
+  subject(:snippet) { Yt::Snippet.new data: data }
+
+  describe '#data' do
+    let(:data) { {"key"=>"value"} }
+    specify 'returns the data the snippet was initialized with' do
+      expect(snippet.data).to eq data
+    end
+  end
+end

data/spec/models/statistics_set_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'yt/models/statistics_set'
+
+describe Yt::StatisticsSet do
+  subject(:statistics_set) { Yt::StatisticsSet.new data: data }
+
+  describe '#data' do
+    let(:data) { {"key"=>"value"} }
+    specify 'returns the data the statistics set was initialized with' do
+      expect(statistics_set.data).to eq data
+    end
+  end
+end

data/spec/models/status_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'yt/models/status'
+
+describe Yt::Status do
+  subject(:status) { Yt::Status.new data: data }
+
+  describe '#data' do
+    let(:data) { {"key"=>"value"} }
+    specify 'returns the data the status was initialized with' do
+      expect(status.data).to eq data
+    end
+  end
+end

data/spec/models/subscription_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'yt/models/subscription'
+
+describe Yt::Subscription do
+  subject(:subscription) { Yt::Subscription.new id: id }
+
+  describe '#exists?' do
+    context 'given a subscription with an id' do
+      let(:id) { 'CBl6OoF0BpiV' }
+      it { expect(subscription).to exist }
+    end
+
+    context 'given a subscription without an id' do
+      let(:id) { nil }
+      it { expect(subscription).not_to exist }
+    end
+  end
+
+  describe '#delete' do
+    let(:id) { 'CBl6OoF0BpiV' }
+    before { expect(subscription).to behave }
+
+    context 'given an existing subscription' do
+      let(:behave) { receive(:do_delete).and_yield }
+
+      it { expect(subscription.delete).to be true }
+      it { expect{subscription.delete}.to change{subscription.exists?} }
+    end
+  end
+end

data/spec/models/url_spec.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'yt/models/url'
+
+describe Yt::URL do
+  subject(:url) { Yt::URL.new text }
+
+  context 'given a long video URL' do
+    let(:text) { 'youtube.com/watch?v=MESycYJytkU' }
+    it {expect(url.kind).to eq :video }
+    it {expect(url.id).to eq 'MESycYJytkU' }
+    it {expect(url.username).to be_nil }
+  end
+
+  context 'given a short video URL' do
+    let(:text) { 'https://youtu.be/MESycYJytkU' }
+    it {expect(url.kind).to eq :video }
+    it {expect(url.id).to eq 'MESycYJytkU' }
+  end
+
+  context 'given an embed video URL' do
+    let(:text) { 'https://www.youtube.com/embed/MESycYJytkU' }
+    it {expect(url.kind).to eq :video }
+    it {expect(url.id).to eq 'MESycYJytkU' }
+  end
+
+  context 'given a playlist-embedded video URL' do
+    let(:text) { 'youtube.com/watch?v=MESycYJytkU&list=LLxO1tY8h1AhOz0T4ENwmpow' }
+    it {expect(url.kind).to eq :video }
+    it {expect(url.id).to eq 'MESycYJytkU' }
+  end
+
+  context 'given a long channel URL' do
+    let(:text) { 'http://youtube.com/channel/UCxO1tY8h1AhOz0T4ENwmpow' }
+    it {expect(url.kind).to eq :channel }
+    it {expect(url.id).to eq 'UCxO1tY8h1AhOz0T4ENwmpow' }
+  end
+
+  context 'given a short channel URL' do
+    let(:text) { 'https://www.youtube.com/Fullscreen' }
+    it {expect(url.kind).to eq :channel }
+    it {expect(url.username).to eq 'Fullscreen' }
+    it {expect(url.id).to be_nil }
+  end
+
+  context 'given a user’s channel URL' do
+    let(:text) { 'https://www.youtube.com/user/Fullscreen' }
+    it {expect(url.kind).to eq :channel }
+    it {expect(url.username).to eq 'Fullscreen' }
+  end
+
+  context 'given a subscription center URL' do
+    let(:text) { 'youtube.com/subscription_center?add_user=Fullscreen' }
+    it {expect(url.kind).to eq :subscription }
+  end
+
+  context 'given a subscription widget URL' do
+    let(:text) { 'youtube.com/subscribe_widget?p=Fullscreen' }
+    it {expect(url.kind).to eq :subscription }
+  end
+
+  context 'given a subscription confirmation URL' do
+    let(:text) { 'youtube.com/channel/UCxO1tY8h1AhOz0T4ENwmpow?sub_confirmation=1' }
+    it {expect(url.kind).to eq :subscription }
+  end
+
+  context 'given a long playlist URL' do
+    let(:text) { 'youtube.com/playlist?list=LLxO1tY8h1AhOz0T4ENwmpow' }
+    it {expect(url.kind).to eq :playlist }
+    it {expect(url.id).to eq 'LLxO1tY8h1AhOz0T4ENwmpow' }
+  end
+
+  context 'given a valid URL with a trailing slash' do
+    let(:text) { 'https://www.youtube.com/user/Fullscreen/' }
+    it {expect(url.kind).to eq :channel }
+  end
+end

data/spec/models/video_category_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'yt/models/video_category'
+
+describe Yt::VideoCategory do
+  subject(:video_category) { Yt::VideoCategory.new attrs }
+
+  describe '#id' do
+    context 'given fetching a video category returns an id' do
+      let(:attrs) { {id: "22"} }
+      it { expect(video_category.id).to eq '22' }
+    end
+  end
+
+  describe '#snippet' do
+    context 'given fetching a video category returns a snippet' do
+      let(:attrs) { {snippet: {"title": "People & Blogs", "assignable": true}} }
+
+      it { expect(video_category.snippet).to be_a Yt::Snippet }
+    end
+  end
+end

data/spec/models/video_spec.rb

@@ -0,0 +1,669 @@
+require 'spec_helper'
+require 'yt/models/video'
+
+describe Yt::Video do
+  subject(:video) { Yt::Video.new attrs }
+
+  describe '#snippet' do
+    context 'given fetching a video returns a snippet' do
+      let(:attrs) { {snippet: {"title"=>"Fullscreen Creator Platform"}} }
+      it { expect(video.snippet).to be_a Yt::Snippet }
+    end
+  end
+
+
+  describe '#title' do
+    context 'given a snippet with a title' do
+      let(:attrs) { {snippet: {"title"=>"Fullscreen Creator Platform"}} }
+      it { expect(video.title).to eq 'Fullscreen Creator Platform' }
+    end
+
+    context 'given a snippet without a title' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.title).to eq '' }
+    end
+  end
+
+  describe '#description' do
+    context 'given a snippet with a description' do
+      let(:attrs) { {snippet: {"description"=>"A cool video."}} }
+      it { expect(video.description).to eq 'A cool video.' }
+    end
+
+    context 'given a snippet without a description' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.description).to eq '' }
+    end
+  end
+
+  describe '#thumbnail_url' do
+    context 'given a snippet with thumbnails' do
+      let(:attrs) { {snippet: {"thumbnails"=>{
+        "default"=>{"url"=> "http://example.com/120x90.jpg"},
+        "medium"=>{"url"=> "http://example.com/320x180.jpg"},
+      }}} }
+      it { expect(video.thumbnail_url).to eq 'http://example.com/120x90.jpg' }
+      it { expect(video.thumbnail_url 'default').to eq 'http://example.com/120x90.jpg' }
+      it { expect(video.thumbnail_url :default).to eq 'http://example.com/120x90.jpg' }
+      it { expect(video.thumbnail_url :medium).to eq 'http://example.com/320x180.jpg' }
+      it { expect(video.thumbnail_url :high).to be_nil }
+    end
+
+    context 'given a snippet without thumbnails' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.thumbnail_url).to be_nil }
+    end
+  end
+
+  describe '#published_at' do
+    context 'given a snippet with a timestamp' do
+      let(:attrs) { {snippet: {"publishedAt"=>"2014-04-22T19:14:49.000Z"}} }
+      it { expect(video.published_at.year).to be 2014 }
+    end
+  end
+
+  describe '#channel_id' do
+    context 'given a snippet with a channel ID' do
+      let(:attrs) { {snippet: {"channelId"=>"UCxO1tY8h1AhOz0T4ENwmpow"}} }
+      it { expect(video.channel_id).to eq 'UCxO1tY8h1AhOz0T4ENwmpow' }
+    end
+
+    context 'given a snippet without a channel ID' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.channel_id).to be_nil }
+    end
+  end
+
+  describe '#channel_title' do
+    context 'given a snippet with a channel title' do
+      let(:attrs) { {snippet: {"channelTitle"=>"Fullscreen"}} }
+      it { expect(video.channel_title).to eq 'Fullscreen' }
+    end
+
+    context 'given a snippet without a channel title' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.channel_title).to be_nil }
+    end
+  end
+
+  describe '#live_broadcast_content' do
+    context 'given a snippet with live broadcast content' do
+      let(:attrs) { {snippet: {"liveBroadcastContent"=>"live"}} }
+      it { expect(video.live_broadcast_content).to eq 'live' }
+    end
+
+    context 'given a snippet without live broadcast content' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.live_broadcast_content).to be_nil }
+    end
+  end
+
+  describe '#tags' do
+    context 'given a snippet with tags' do
+      let(:attrs) { {snippet: {"tags"=>["promotion", "new media"]}} }
+      it { expect(video.tags).to eq ["promotion", "new media"] }
+    end
+
+    context 'given a snippet without tags' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.tags).to eq [] }
+    end
+  end
+
+  describe '#category_id' do
+    context 'given a snippet with a category ID' do
+      let(:attrs) { {snippet: {"categoryId"=>"22"}} }
+      it { expect(video.category_id).to eq '22' }
+    end
+
+    context 'given a snippet without a category ID' do
+      let(:attrs) { {snippet: {}} }
+      it { expect(video.category_id).to be_nil }
+    end
+  end
+
+
+  describe '#deleted?' do
+    context 'given fetching a status returns uploadStatus "deleted"' do
+      let(:attrs) { {status: {"uploadStatus"=>"deleted"}} }
+      it { expect(video).to be_deleted }
+    end
+
+    context 'given fetching a status does not return uploadStatus "deleted"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).not_to be_deleted }
+    end
+  end
+
+  describe '#failed?' do
+    context 'given fetching a status returns uploadStatus "failed"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).to be_failed }
+    end
+
+    context 'given fetching a status does not return uploadStatus "failed"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).not_to be_failed }
+    end
+  end
+
+  describe '#processed?' do
+    context 'given fetching a status returns uploadStatus "processed"' do
+      let(:attrs) { {status: {"uploadStatus"=>"processed"}} }
+      it { expect(video).to be_processed }
+    end
+
+    context 'given fetching a status does not return uploadStatus "processed"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).not_to be_processed }
+    end
+  end
+
+  describe '#rejected?' do
+    context 'given fetching a status returns uploadStatus "rejected"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video).to be_rejected }
+    end
+
+    context 'given fetching a status does not return uploadStatus "rejected"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).not_to be_rejected }
+    end
+  end
+
+  describe '#uploading?' do
+    context 'given fetching a status returns uploadStatus "uploaded"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).to be_uploading }
+    end
+
+    context 'given fetching a status does not return uploadStatus "uploaded"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).not_to be_uploading }
+    end
+  end
+
+  describe '#uses_unsupported_codec?' do
+    context 'given fetching a status returns failureReason "codec"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed", "failureReason"=>"codec"}} }
+      it { expect(video.uses_unsupported_codec?).to be true }
+    end
+
+    context 'given fetching a status does not return failureReason "codec"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video.uses_unsupported_codec?).to be false }
+    end
+  end
+
+  describe '#conversion_failed?' do
+    context 'given fetching a status returns failureReason "conversion"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed", "failureReason"=>"conversion"}} }
+      it { expect(video).to have_failed_conversion }
+    end
+
+    context 'given fetching a status does not return failureReason "conversion"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).not_to have_failed_conversion }
+    end
+  end
+
+  describe '#empty_file?' do
+    context 'given fetching a status returns failureReason "emptyFile"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed", "failureReason"=>"emptyFile"}} }
+      it { expect(video).to be_empty }
+    end
+
+    context 'given fetching a status does not return failureReason "emptyFile"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).not_to be_empty }
+    end
+  end
+
+  describe '#invalid_file?' do
+    context 'given fetching a status returns failureReason "invalidFile"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed", "failureReason"=>"invalidFile"}} }
+      it { expect(video).to be_invalid }
+    end
+
+    context 'given fetching a status does not return failureReason "invalidFile"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).not_to be_invalid }
+    end
+  end
+
+  describe '#too_small?' do
+    context 'given fetching a status returns failureReason "tooSmall"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed", "failureReason"=>"tooSmall"}} }
+      it { expect(video).to be_too_small }
+    end
+
+    context 'given fetching a status does not return failureReason "tooSmall"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).not_to be_too_small }
+    end
+  end
+
+  describe '#upload_aborted?' do
+    context 'given fetching a status returns failureReason "uploadAborted"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed", "failureReason"=>"uploadAborted"}} }
+      it { expect(video).to be_aborted }
+    end
+
+    context 'given fetching a status does not return failureReason "uploadAborted"' do
+      let(:attrs) { {status: {"uploadStatus"=>"failed"}} }
+      it { expect(video).not_to be_aborted }
+    end
+  end
+
+  describe '#claimed?' do
+    context 'given fetching a status returns rejectionReason "claim"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"claim"}} }
+      it { expect(video).to be_claimed }
+    end
+
+    context 'given fetching a status does not return rejectionReason "claim"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video).not_to be_claimed }
+    end
+  end
+
+  describe '#infringes_copyright?' do
+    context 'given fetching a status returns rejectionReason "copyright"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"copyright"}} }
+      it { expect(video.infringes_copyright?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "copyright"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video.infringes_copyright?).to be false }
+    end
+  end
+
+  describe '#duplicate?' do
+    context 'given fetching a status returns rejectionReason "duplicate"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"duplicate"}} }
+      it { expect(video).to be_duplicate }
+    end
+
+    context 'given fetching a status does not return rejectionReason "duplicate"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video).not_to be_duplicate }
+    end
+  end
+
+  describe '#inappropriate?' do
+    context 'given fetching a status returns rejectionReason "inappropriate"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"inappropriate"}} }
+      it { expect(video).to be_inappropriate }
+    end
+
+    context 'given fetching a status does not return rejectionReason "inappropriate"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video).not_to be_inappropriate }
+    end
+  end
+
+  describe '#too_long?' do
+    context 'given fetching a status returns rejectionReason "length"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"length"}} }
+      it { expect(video).to be_too_long }
+    end
+
+    context 'given fetching a status does not return rejectionReason "length"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video).not_to be_too_long }
+    end
+  end
+
+  describe '#violates_terms_of_use?' do
+    context 'given fetching a status returns rejectionReason "termsOfUse"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"termsOfUse"}} }
+      it { expect(video.violates_terms_of_use?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "termsOfUse"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video.violates_terms_of_use?).to be false }
+    end
+  end
+
+  describe '#infringes_trademark?' do
+    context 'given fetching a status returns rejectionReason "trademark"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"trademark"}} }
+      it { expect(video.infringes_trademark?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "trademark"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video.infringes_trademark?).to be false }
+    end
+  end
+
+  describe '#belongs_to_closed_account?' do
+    context 'given fetching a status returns rejectionReason "uploaderAccountClosed"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"uploaderAccountClosed"}} }
+      it { expect(video.belongs_to_closed_account?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "uploaderAccountClosed"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video.belongs_to_closed_account?).to be false }
+    end
+  end
+
+  describe '#belongs_to_suspended_account?' do
+    context 'given fetching a status returns rejectionReason "uploaderAccountSuspended"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected", "rejectionReason"=>"uploaderAccountSuspended"}} }
+      it { expect(video.belongs_to_suspended_account?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "uploaderAccountSuspended"' do
+      let(:attrs) { {status: {"uploadStatus"=>"rejected"}} }
+      it { expect(video.belongs_to_suspended_account?).to be false }
+    end
+  end
+
+  describe '#scheduled_at and #scheduled' do
+    context 'given fetching a status returns "publishAt"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded", "privacyStatus"=>"private", "publishAt"=>"2014-04-22T19:14:49.000Z"}} }
+      it { expect(video).to be_scheduled }
+      it { expect(video.scheduled_at.year).to be 2014 }
+    end
+
+    context 'given fetching a status does not returns "publishAt"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded", "privacyStatus"=>"private"}} }
+      it { expect(video).not_to be_scheduled }
+      it { expect(video.scheduled_at).not_to be }
+    end
+  end
+
+  describe '#licensed_as_creative_commons?' do
+    context 'given fetching a status returns license "creativeCommon"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded", "license"=>"creativeCommon"}} }
+      it { expect(video).to be_licensed_as_creative_commons }
+    end
+
+    context 'given fetching a status does not return license "creativeCommon"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).not_to be_licensed_as_creative_commons }
+    end
+  end
+
+  describe '#licensed_as_standard_youtube?' do
+    context 'given fetching a status returns license "youtube"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded", "license"=>"youtube"}} }
+      it { expect(video).to be_licensed_as_standard_youtube }
+    end
+
+    context 'given fetching a status does not return license "youtube"' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded"}} }
+      it { expect(video).not_to be_licensed_as_standard_youtube }
+    end
+  end
+
+  describe '#embeddable?' do
+    context 'given fetching a status returns "embeddable" true' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded", "embeddable"=>true}} }
+      it { expect(video).to be_embeddable }
+    end
+
+    context 'given fetching a status returns "embeddable" false' do
+      let(:attrs) { {status: {"uploadStatus"=>"uploaded", "embeddable"=>false}} }
+      it { expect(video).not_to be_embeddable }
+    end
+  end
+
+  describe '#has_public_stats_viewable?' do
+    context 'given fetching a status returns "publicStatsViewable" true' do
+      let(:attrs) { {status: {"publicStatsViewable"=>true}} }
+      it { expect(video).to have_public_stats_viewable }
+    end
+
+    context 'given fetching a status returns "publicStatsViewable" false' do
+      let(:attrs) { {status: {"publicStatsViewable"=>false}} }
+      it { expect(video).not_to have_public_stats_viewable }
+    end
+  end
+
+  describe '#stereoscopic?' do
+    context 'given a 3D video' do
+      let(:attrs) { {content_details: {"dimension"=>"3d"}} }
+      it { expect(video).to be_stereoscopic }
+    end
+
+    context 'given a 2D video' do
+      let(:attrs) { {content_details: {"dimension"=>"2d"}} }
+      it { expect(video).not_to be_stereoscopic }
+    end
+  end
+
+  describe '#hd?' do
+    context 'given a high-definition video' do
+      let(:attrs) { {content_details: {"definition"=>"hd"}} }
+      it { expect(video).to be_hd }
+    end
+
+    context 'given a standard-definition video' do
+      let(:attrs) { {content_details: {"definition"=>"sd"}} }
+      it { expect(video).not_to be_hd }
+    end
+  end
+
+  describe '#captioned?' do
+    context 'given a video with captions' do
+      let(:attrs) { {content_details: {"caption"=>"true"}} }
+      it { expect(video).to be_captioned }
+    end
+
+    context 'given a video without captions' do
+      let(:attrs) { {content_details: {"caption"=>"false"}} }
+      it { expect(video).not_to be_captioned }
+    end
+  end
+
+  describe '#licensed?' do
+    context 'given a video with licensed content' do
+      let(:attrs) { {content_details: {"licensedContent"=>true}} }
+      it { expect(video).to be_licensed }
+    end
+
+    context 'given a video without licensed content' do
+      let(:attrs) { {content_details: {"licensedContent"=>false}} }
+      it { expect(video).not_to be_licensed }
+    end
+  end
+
+  describe '#age_restricted?' do
+    context 'given a video with age restricted content' do
+      let(:attrs) { {content_details: {"contentRating"=>{"ytRating"=>"ytAgeRestricted"}}} }
+      it { expect(video).to be_age_restricted }
+    end
+
+    context 'given a video without age restricted content' do
+      let(:attrs) { {content_details: {}} }
+      it { expect(video).not_to be_age_restricted }
+    end
+
+    context 'given a video with a content rating but not ytRating' do
+      let(:attrs) { {content_details: {"contentRating"=>{"acbRating": "PG"}}} }
+      it { expect(video).not_to be_age_restricted }
+    end
+  end
+
+  describe '#file_size' do
+    context 'given a video with fileSize' do
+      let(:attrs) { {file_details: {"fileSize"=>"8000000"}} }
+      it { expect(video.file_size).to be 8_000_000 }
+    end
+  end
+
+  describe '#file_type' do
+    context 'given a video with fileType' do
+      let(:attrs) { {file_details: {"fileType"=>"video"}} }
+      it { expect(video.file_type).to eq 'video' }
+    end
+  end
+
+  describe '#container' do
+    context 'given a video with container' do
+      let(:attrs) { {file_details: {"container"=>"mov"}} }
+      it { expect(video.container).to eq 'mov' }
+    end
+  end
+
+  describe '#actual_start_time' do
+    context 'given a non-live streaming video' do
+      let(:attrs) { {live_streaming_details: {}} }
+      it { expect(video.actual_start_time).to be_nil }
+    end
+
+    context 'given a live streaming video that has not started yet' do
+      let(:attrs) { {live_streaming_details: {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"}} }
+      it { expect(video.actual_start_time).to be_nil }
+    end
+
+    context 'given a live streaming video that has started' do
+      let(:attrs) { {live_streaming_details: {"actualStartTime"=>"2014-08-01T17:48:40.678Z"}} }
+      it { expect(video.actual_start_time.year).to be 2014 }
+    end
+  end
+
+  describe '#actual_end_time' do
+    context 'given a non-live streaming video' do
+      let(:attrs) { {live_streaming_details: {}} }
+      it { expect(video.actual_end_time).to be_nil }
+    end
+
+    context 'given a live streaming video that has not ended yet' do
+      let(:attrs) { {live_streaming_details: {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"}} }
+      it { expect(video.actual_end_time).to be_nil }
+    end
+
+    context 'given a live streaming video that has ended' do
+      let(:attrs) { {live_streaming_details: {"actualEndTime"=>"2014-08-01T17:48:40.678Z"}} }
+      it { expect(video.actual_end_time.year).to be 2014 }
+    end
+  end
+
+  describe '#scheduled_start_time' do
+    context 'given a non-live streaming video' do
+      let(:attrs) { {live_streaming_details: {}} }
+      it { expect(video.scheduled_start_time).to be_nil }
+    end
+
+    context 'given a live streaming video' do
+      let(:attrs) { {live_streaming_details: {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"}} }
+      it { expect(video.scheduled_start_time.year).to be 2017 }
+    end
+  end
+
+  describe '#scheduled_end_time' do
+    context 'given a non-live streaming video' do
+      let(:attrs) { {live_streaming_details: {}} }
+      it { expect(video.scheduled_end_time).to be_nil }
+    end
+
+    context 'given a live streaming video that broadcasts indefinitely' do
+      let(:attrs) { {live_streaming_details: {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"}} }
+      it { expect(video.scheduled_end_time).to be_nil }
+    end
+
+    context 'given a live streaming video with a scheduled ednd' do
+      let(:attrs) { {live_streaming_details: {"scheduledEndTime"=>"2014-08-01T17:48:40.678Z"}} }
+      it { expect(video.scheduled_end_time.year).to be 2014 }
+    end
+  end
+
+  describe '#concurrent_viewers' do
+    context 'given a non-live streaming video' do
+      let(:attrs) { {live_streaming_details: {}} }
+      it { expect(video.concurrent_viewers).to be_nil }
+    end
+
+    context 'given a current live streaming video with viewers' do
+      let(:attrs) { {live_streaming_details: {"concurrentViewers"=>"1"}} }
+      it { expect(video.concurrent_viewers).to be 1 }
+    end
+
+    context 'given a past live streaming video' do
+      let(:attrs) { {live_streaming_details: {"actualEndTime"=>"2013-08-01T17:48:40.678Z"}} }
+      it { expect(video.concurrent_viewers).to be_nil }
+    end
+  end
+
+  describe '#view_count' do
+    context 'given a video with views' do
+      let(:attrs) { {statistics: { "viewCount"=>"123"}} }
+      it { expect(video.view_count).to be 123 }
+    end
+  end
+
+  describe '#comment_count' do
+    context 'given a video with comments' do
+      let(:attrs) { {statistics: { "commentCount"=>"45"}} }
+      it { expect(video.comment_count).to be 45 }
+    end
+  end
+
+  describe '#like_count' do
+    context 'given a video with likes' do
+      let(:attrs) { {statistics: { "likeCount"=>"6"}} }
+      it { expect(video.like_count).to be 6 }
+    end
+  end
+
+  describe '#dislike_count' do
+    context 'given a video with dislikes' do
+      let(:attrs) { {statistics: { "dislikeCount"=>"9"}} }
+      it { expect(video.dislike_count).to be 9 }
+    end
+  end
+
+  describe '#favorite_count' do
+    context 'given a video with favorites' do
+      let(:attrs) { {statistics: { "favoriteCount"=>"44"}} }
+      it { expect(video.favorite_count).to be 44 }
+    end
+  end
+
+  describe '#embed_html' do
+    context 'given a video with embedHtml' do
+      let(:html) { "<iframe type='text/html' src='http://www.youtube.com/embed/BPNYv0vd78A' width='640' height='360' frameborder='0' allowfullscreen='true'/>" }
+      let(:attrs) { {player: {"embedHtml"=>html}} }
+      it { expect(video.embed_html).to be html }
+    end
+  end
+
+  describe '#statistics_set' do
+    context 'given fetching a video returns statistics' do
+      let(:attrs) { {statistics: {"viewCount"=>"202"}} }
+      it { expect(video.statistics_set).to be_a Yt::StatisticsSet }
+    end
+  end
+
+  describe '#content_details' do
+    context 'given fetching a video returns content details' do
+      let(:attrs) { {content_details: {"definition"=>"hd"}} }
+      it { expect(video.content_detail).to be_a Yt::ContentDetail }
+    end
+  end
+
+  describe '#update' do
+    let(:attrs) { {id: 'MESycYJytkU', snippet: {'title'=>'old'}} }
+    before { expect(video).to receive(:do_update).and_yield 'snippet'=>{'title'=>'new'} }
+
+    it { expect(video.update title: 'new').to be true }
+    it { expect{video.update title: 'new'}.to change{video.title} }
+  end
+
+  describe '#delete' do
+    let(:attrs) { {id: 'video-id'} }
+
+    context 'given an existing video' do
+      before { expect(video).to receive(:do_delete).and_yield }
+
+      it { expect(video.delete).to be true }
+      it { expect{video.delete}.to change{video.exists?} }
+    end
+  end
+end