yt 0.32.6 → 0.33.4

data/spec/models/annotation_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'yt/models/annotation'
-
-describe Yt::Annotation do
-  subject(:annotation) { Yt::Annotation.new data: Hash.from_xml(xml) }
-
-  describe '#above? and #below?' do
-    let(:xml) { %Q{
-      <segment>
-      <movingRegion type="rect">
-      <rectRegion d="0" h="17.7779998779" t="0:04.000" w="25.0" x="7.117000103" y="5.07000017166"/>
-      <rectRegion d="0" h="17.7779998779" t="0:05.000" w="25.0" x="7.117000103" y="5.07000017166"/>
-      </movingRegion>
-      </segment>
-    } }
-
-    context 'given an annotation located above N% of the video height' do
-      it { expect(annotation.above? 50).to be true }
-      it { expect(annotation.below? 50).to be_falsey }
-    end
-
-    context 'given an annotation located below N% of the video height' do
-      it { expect(annotation.above? 5).to be_falsey }
-      it { expect(annotation.below? 5).to be true }
-    end
-
-    context 'given an annotation without a single position' do
-      let(:xml) { %Q{
-        <segment>
-        <movingRegion type="rect">
-        <rectRegion d="0" h="17.7779998779" t="0:05.000" w="25.0" x="7.117000103" y="5.07000017166"/>
-        </movingRegion>
-        </segment>
-      } }
-      it { expect(annotation.above? 50).to be true }
-      it { expect(annotation.below? 50).to be_falsey }
-    end
-
-    context 'given an annotation without explicit location' do
-      let(:xml) { '<segment></segment>' }
-      it { expect(annotation.above? 50).to be_falsey }
-      it { expect(annotation.below? 50).to be_falsey }
-    end
-  end
-
-  describe '#text' do
-    context 'given an annotation with text' do
-      let(:xml) { '<TEXT>Hello, world!</TEXT>' }
-      it { expect(annotation.text).to eq 'Hello, world!' }
-    end
-  end
-
-  describe '#has_link_to_subscribe?' do
-    context 'given an annotation with a link of class 5' do
-      let(:xml) { '<action type="openUrl"><url link_class="5"/></action>' }
-      it { expect(annotation).to have_link_to_subscribe }
-    end
-
-    context 'given an annotation without a link of class 5' do
-      let(:xml) { '<action type="openUrl"><url link_class="3"/></action>' }
-      it { expect(annotation).not_to have_link_to_subscribe }
-    end
-  end
-
-  describe '#has_link_to_video?' do
-    context 'given an annotation with a link of class 1' do
-      let(:xml) { '<action type="openUrl"><url link_class="1"/></action>' }
-      it { expect(annotation).to have_link_to_video }
-    end
-
-    context 'given an annotation with a "featured video" invideo programming' do
-      let(:xml) { '<type>promotion</type>' }
-      it { expect(annotation).to have_link_to_video }
-    end
-
-    context 'given an annotation without a link of class 1' do
-      let(:xml) { '<action type="openUrl"><url link_class="3"/></action>' }
-      it { expect(annotation).not_to have_link_to_video }
-    end
-  end
-
-  describe '#has_link_to_playlist?' do
-    context 'given an annotation with a link of class 2' do
-      let(:xml) { '<action type="openUrl"><url link_class="2"/></action>' }
-      it { expect(annotation).to have_link_to_playlist }
-    end
-
-    context 'given an annotation with an embedded playlist link' do
-      let(:xml) { '<TEXT>https://www.youtube.com/watch?v=9bZkp7q19f0&amp;list=LLxO1tY8h1AhOz0T4ENwmpow"</TEXT>' }
-      it { expect(annotation).to have_link_to_playlist }
-    end
-
-    context 'given an annotation without a link of class 2' do
-      let(:xml) { '<action type="openUrl"><url link_class="3"/></action>' }
-      it { expect(annotation).not_to have_link_to_playlist }
-    end
-
-    context 'given an annotation without text' do
-      let(:xml) { '<TEXT />' }
-      it { expect(annotation).not_to have_link_to_playlist }
-    end
-  end
-
-  describe '#has_link_to_same_window?' do
-    context 'given an annotation with a "current" target' do
-      let(:xml) { '<action type="openUrl"><url target="current"/></action>' }
-      it { expect(annotation).to have_link_to_same_window }
-    end
-
-    context 'given an annotation without a "current" target' do
-      let(:xml) { '<action type="openUrl"><url target="new"/></action>' }
-      it { expect(annotation).not_to have_link_to_same_window }
-    end
-  end
-
-  describe '#has_invideo_programming?' do
-    context 'given an annotation with a "featured video" invideo programming' do
-      let(:xml) { '<type>promotion</type>' }
-      it { expect(annotation).to have_invideo_programming }
-    end
-
-    context 'given an annotation with a "branding intro" invideo programming' do
-      let(:xml) { '<type>branding</type>' }
-      it { expect(annotation).to have_invideo_programming }
-    end
-
-    context 'given an annotation without an invideo programming' do
-      let(:xml) { '<segment></segment>' }
-      it { expect(annotation).not_to have_invideo_programming }
-    end
-  end
-
-  describe '#starts_after and #starts_before' do
-    context 'given an annotation with the first timestamp equal to 1 hour' do
-      let(:xml) { %Q{
-        <segment>
-        <movingRegion type="rect">
-        <rectRegion d="0" h="17.7779998779" t="01:00:01.000" w="25.0" x="7.117000103" y="5.07000017166"/>
-        <rectRegion d="0" h="17.7779998779" t="01:05:56.066" w="25.0" x="7.117000103" y="5.07000017166"/>
-        </movingRegion>
-        </segment>
-      } }
-      it { expect(annotation.starts_after? 3600).to be true }
-      it { expect(annotation.starts_after? 3610).to be_falsey }
-      it { expect(annotation.starts_before? 3600).to be_falsey }
-      it { expect(annotation.starts_before? 3610).to be true }
-    end
-
-    context 'given an annotation without timestamps' do
-      let(:xml) { '<segment></segment>' }
-      it { expect(annotation.starts_after? 0).to be_nil }
-      it { expect(annotation.starts_before? 0).to be_nil }
-    end
-
-    context 'given an annotation with "never" as the timestamp' do
-      let(:xml) { %Q{
-        <segment>
-        <movingRegion type="rect">
-        <rectRegion h="6.0" t="never" w="25.0" x="7.0" y="5.0"/>
-        <rectRegion h="6.0" t="never" w="25.0" x="7.0" y="5.0"/>
-        </movingRegion>
-        </segment>
-      } }
-      it { expect(annotation.starts_after? 0).to be_nil }
-      it { expect(annotation.starts_before? 0).to be_nil }
-    end
-
-    context 'given an annotation with "0" as the timestamp' do
-      let(:xml) { %Q{
-        <segment>
-        <movingRegion type="rect">
-        <rectRegion h="6.0" t="0" w="25.0" x="7.0" y="5.0"/>
-        </movingRegion>
-        </segment>
-      } }
-      it { expect(annotation.starts_after? 10).to be_falsey }
-      it { expect(annotation.starts_before? 10).to be true }
-    end
-  end
-end

data/spec/models/asset_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'yt/models/asset'
-
-describe Yt::Asset do
-  subject(:asset) { Yt::Asset.new data: data }
-
-  describe '#id' do
-    context 'given fetching a asset returns an id' do
-      let(:data) { {"id"=>"A123456789012345"} }
-      it { expect(asset.id).to eq 'A123456789012345' }
-    end
-  end
-
-  describe '#type' do
-    context 'given fetching a asset returns an type' do
-      let(:data) { {"type"=>"web"} }
-      it { expect(asset.type).to eq 'web' }
-    end
-  end
-
-  describe '#ownership_effective' do
-    context 'given fetching a asset returns an ownershipEffective' do
-      let(:data) {
-        {"ownershipEffective"=>{"kind"=>"youtubePartner#rightsOwnership",
-        "general"=>[{"ratio"=>100.0, "owner"=>"XOuN81q-MeEUVrsiZeK1lQ", "type"=>"exclude"}]}}
-      }
-      it { expect(asset.ownership_effective).to be_a Yt::Ownership }
-      it { expect(asset.ownership_effective.general_owners.first).to be_a Yt::RightOwner }
-      it { expect(asset.ownership_effective.general_owners.first.owner).to eq "XOuN81q-MeEUVrsiZeK1lQ" }
-    end
-  end
-end

data/spec/models/channel_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'yt/models/channel'
-
-describe Yt::Channel do
-  subject(:channel) { Yt::Channel.new attrs }
-
-  describe '#title' do
-    context 'given a snippet with a title' do
-      let(:attrs) { {snippet: {"title"=>"Fullscreen"}} }
-      it { expect(channel.title).to eq 'Fullscreen' }
-    end
-
-    context 'given a snippet without a title' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(channel.title).to eq '' }
-    end
-  end
-
-  describe '#description' do
-    context 'given a snippet with a description' do
-      let(:attrs) { {snippet: {"description"=>"A cool channel."}} }
-      it { expect(channel.description).to eq 'A cool channel.' }
-    end
-
-    context 'given a snippet without a description' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(channel.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/88x88.jpg"},
-        "medium"=>{"url"=> "http://example.com/240x240.jpg"},
-      }}} }
-      it { expect(channel.thumbnail_url).to eq 'http://example.com/88x88.jpg' }
-      it { expect(channel.thumbnail_url 'default').to eq 'http://example.com/88x88.jpg' }
-      it { expect(channel.thumbnail_url :default).to eq 'http://example.com/88x88.jpg' }
-      it { expect(channel.thumbnail_url :medium).to eq 'http://example.com/240x240.jpg' }
-      it { expect(channel.thumbnail_url :high).to be_nil }
-    end
-
-    context 'given a snippet without thumbnails' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(channel.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(channel.published_at.year).to be 2014 }
-    end
-  end
-
-  describe '#comment_count' do
-    context 'given a video with comments' do
-      let(:attrs) { {statistics: {"commentCount"=>"33"}} }
-      it { expect(channel.comment_count).to be 33 }
-    end
-  end
-
-  describe '#video_count' do
-    context 'given a video with videos' do
-      let(:attrs) { {statistics: {"videoCount"=>"42"}} }
-      it { expect(channel.video_count).to be 42 }
-    end
-  end
-
-  describe '#subscriber_count' do
-    context 'given a video with subscribers' do
-      let(:attrs) { {statistics: {"subscriberCount"=>"12"}} }
-      it { expect(channel.subscriber_count).to be 12 }
-    end
-  end
-
-  describe '#subscriber_count_visible?' do
-    context 'given a video with publicly visible subscribers' do
-      let(:attrs) { {statistics: {"hiddenSubscriberCount"=>false}} }
-      it { expect(channel).to be_subscriber_count_visible }
-    end
-
-    context 'given a video with hidden subscribers' do
-      let(:attrs) { {statistics: {"hiddenSubscriberCount"=>true}} }
-      it { expect(channel).not_to be_subscriber_count_visible }
-    end
-  end
-
-  describe '#content_owner' do
-    context 'given a content_owner_detail with a content owner' do
-      let(:attrs) { {content_owner_details: {"contentOwner"=>"FullScreen"}} }
-      it { expect(channel.content_owner).to eq 'FullScreen' }
-    end
-
-    context 'given a content_owner_detail without a content owner' do
-      let(:attrs) { {content_owner_details: {}} }
-      it { expect(channel.content_owner).to be_nil }
-    end
-  end
-
-  describe '#linked_at' do
-    context 'given a content_owner_detail with a timeLinked' do
-      let(:attrs) { {content_owner_details: {"timeLinked"=>"2014-04-22T19:14:49.000Z"}} }
-      it { expect(channel.linked_at.year).to be 2014 }
-    end
-
-    context 'given a content_owner_detail with a timeLinked' do
-      let(:attrs) { {content_owner_details: {}} }
-      it { expect(channel.linked_at).to be_nil }
-    end
-  end
-
-  describe '#snippet' do
-    context 'given fetching a channel returns a snippet' do
-      let(:attrs) { {snippet: {"title"=>"Fullscreen"}} }
-      it { expect(channel.snippet).to be_a Yt::Snippet }
-    end
-  end
-
-  describe '#status' do
-    context 'given fetching a channel returns a status' do
-      let(:attrs) { {status: {"privacyStatus"=>"public"}} }
-      it { expect(channel.status).to be_a Yt::Status }
-    end
-  end
-end

data/spec/models/claim_event_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'yt/models/claim_event'
-
-describe Yt::ClaimEvent do
-  subject(:claim_event) { Yt::ClaimEvent.new data: data }
-
-  describe '#time' do
-    context 'given fetching a claim_event returns a time' do
-      let(:data) { {"time"=>"2015-04-08T21:52:13.000Z"} }
-      it { expect(claim_event.time).to be_a Time }
-    end
-  end
-
-  describe '#type' do
-    context 'given fetching a claim_event returns a type' do
-      let(:data) { {"type"=>"claim_create"} }
-      it { expect(claim_event.type).to eq 'claim_create' }
-    end
-  end
-
-  describe '#source_type' do
-    context 'given fetching a claim_event returns a source_type' do
-      let(:data) { {'source'=>{'type' => 'cms_user'}} }
-      it { expect(claim_event.source_type).to eq 'cms_user' }
-    end
-  end
-
-  describe '#source_content_owner_id' do
-    context 'given fetching a claim_event returns a source_content_owner_id' do
-      let(:data) { {'source'=>{'contentOwnerId' => 'C1234'}} }
-      it { expect(claim_event.source_content_owner_id).to eq 'C1234' }
-    end
-  end
-
-  describe '#source_user_email' do
-    context 'given fetching a claim_event returns a source_user_email' do
-      let(:data) { {'source'=>{'userEmail' => 'email@fullscreen.net'}} }
-      it { expect(claim_event.source_user_email).to eq 'email@fullscreen.net' }
-    end
-  end
-
-  describe '#dispute_reason' do
-    context 'given fetching a claim_event returns a dispute_reason' do
-      let(:data) { {'typeDetails'=>{'disputeReason' => 'fair_use'}} }
-      it { expect(claim_event.dispute_reason).to eq 'fair_use' }
-    end
-  end
-
-  describe '#dispute_notes' do
-    context 'given fetching a claim_event returns dispute_notes' do
-      let(:data) { {'typeDetails'=>{'disputeNotes' => 'User entered notes here.'}} }
-      it { expect(claim_event.dispute_notes).to eq 'User entered notes here.' }
-    end
-  end
-
-  describe '#update_status' do
-    context 'given fetching a claim_event returns an update_status' do
-      let(:data) { {'typeDetails'=>{'updateStatus' => 'active'}} }
-      it { expect(claim_event.update_status).to eq 'active' }
-    end
-  end
-end

data/spec/models/claim_history_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'yt/models/claim_history'
-
-describe Yt::ClaimHistory do
-  subject(:claim_history) { Yt::ClaimHistory.new data: data }
-
-  describe '#id' do
-    context 'given fetching claim_history with an id' do
-      let(:data) { {"id"=>"acbd1234"}}
-      it { expect(claim_history.id).to eq "acbd1234" }
-    end
-  end
-
-  describe '#uploader_channel_id' do
-    context 'given fetching claim_history with an uploader_channel_id' do
-      let(:data) { {"uploaderChannelId"=>"C1234"}}
-      it { expect(claim_history.uploader_channel_id).to eq "C1234" }
-    end
-  end
-
-  describe '#events' do
-    context 'given fetching claim_history with associated events' do
-      let(:data) { {"event"=>[{"time"=>"2015-03-21T21:35:42.000Z"},{"time"=>"2015-03-21T21:35:42.000Z"}]} }
-      it { expect(claim_history.events.size).to eq 2 }
-    end
-  end
-end

data/spec/models/claim_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-require 'yt/models/claim'
-
-describe Yt::Claim do
-  subject(:claim) { Yt::Claim.new data: data }
-
-  describe '#id' do
-    context 'given fetching a claim returns an id' do
-      let(:data) { {"id"=>"aBcD1EfGHIk"} }
-      it { expect(claim.id).to eq 'aBcD1EfGHIk' }
-    end
-  end
-
-  describe '#asset_id' do
-    context 'given fetching a claim returns an assetId' do
-      let(:data) { {"assetId"=>"A123456789012601"} }
-      it { expect(claim.asset_id).to eq 'A123456789012601' }
-    end
-  end
-
-  describe '#video_id' do
-    context 'given fetching a claim returns an videoId' do
-      let(:data) { {"videoId"=>"9bZkp7q19f0"} }
-      it { expect(claim.video_id).to eq '9bZkp7q19f0' }
-    end
-  end
-
-  describe '#status' do
-    context 'given fetching a claim returns a status' do
-      let(:data) { {"status"=>"active"} }
-      it { expect(claim.status).to eq 'active' }
-    end
-  end
-
-  describe '#active?' do
-    context 'given fetching a claim returns an active status' do
-      let(:data) { {"status"=>"active"} }
-      it { expect(claim).to be_active }
-    end
-
-    context 'given fetching a claim does not return an active status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_active }
-    end
-  end
-
-  describe '#appealed?' do
-    context 'given fetching a claim returns an appealed status' do
-      let(:data) { {"status"=>"appealed"} }
-      it { expect(claim).to be_appealed }
-    end
-
-    context 'given fetching a claim does not return an appealed status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_appealed }
-    end
-  end
-
-  describe '#disputed?' do
-    context 'given fetching a claim returns an disputed status' do
-      let(:data) { {"status"=>"disputed"} }
-      it { expect(claim).to be_disputed }
-    end
-
-    context 'given fetching a claim does not return an disputed status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_disputed }
-    end
-  end
-
-  describe '#inactive?' do
-    context 'given fetching a claim returns an inactive status' do
-      let(:data) { {"status"=>"inactive"} }
-      it { expect(claim).to be_inactive }
-    end
-
-    context 'given fetching a claim does not return an inactive status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_inactive }
-    end
-  end
-
-  describe '#pending?' do
-    context 'given fetching a claim returns an pending status' do
-      let(:data) { {"status"=>"pending"} }
-      it { expect(claim).to be_pending }
-    end
-
-    context 'given fetching a claim does not return an pending status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_pending }
-    end
-  end
-
-  describe '#potential?' do
-    context 'given fetching a claim returns an potential status' do
-      let(:data) { {"status"=>"potential"} }
-      it { expect(claim).to be_potential }
-    end
-
-    context 'given fetching a claim does not return an potential status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_potential }
-    end
-  end
-
-  describe '#takedown?' do
-    context 'given fetching a claim returns an takedown status' do
-      let(:data) { {"status"=>"takedown"} }
-      it { expect(claim).to be_takedown }
-    end
-
-    context 'given fetching a claim does not return an takedown status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).not_to be_takedown }
-    end
-  end
-
-  describe '#has_unknown_status?' do
-    context 'given fetching a claim returns an unknown status' do
-      let(:data) { {"status"=>"unknown"} }
-      it { expect(claim).to have_unknown_status }
-    end
-
-    context 'given fetching a claim does not return an unknown status' do
-      let(:data) { {"status"=>"active"} }
-      it { expect(claim).not_to have_unknown_status }
-    end
-  end
-
-  describe '#content_type' do
-    context 'given fetching a claim returns a content type' do
-      let(:data) { {"contentType"=>"audio"} }
-      it { expect(claim.content_type).to eq 'audio' }
-    end
-  end
-
-  describe '#audio?' do
-    context 'given fetching a claim returns an audio content type' do
-      let(:data) { {"contentType"=>"audio"} }
-      it { expect(claim).to be_audio }
-    end
-
-    context 'given fetching a claim does not return an audio content type' do
-      let(:data) { {"contentType"=>"audiovisual"} }
-      it { expect(claim).not_to be_audio }
-    end
-  end
-
-  describe '#video?' do
-    context 'given fetching a claim returns an video content type' do
-      let(:data) { {"contentType"=>"video"} }
-      it { expect(claim).to be_video }
-    end
-
-    context 'given fetching a claim does not return an video content type' do
-      let(:data) { {"contentType"=>"audiovisual"} }
-      it { expect(claim).not_to be_video }
-    end
-  end
-
-  describe '#audiovisual?' do
-    context 'given fetching a claim returns an audiovisual content type' do
-      let(:data) { {"contentType"=>"audiovisual"} }
-      it { expect(claim).to be_audiovisual }
-    end
-
-    context 'given fetching a claim does not return an audiovisual content type' do
-      let(:data) { {"contentType"=>"audio"} }
-      it { expect(claim).not_to be_audiovisual }
-    end
-  end
-
-  describe '#created_at' do
-    context 'given fetching a claim returns a creation timestamp' do
-      let(:data) { {"timeCreated"=>"2014-04-22T19:14:49.000Z"} }
-      it { expect(claim.created_at.year).to be 2014 }
-    end
-  end
-
-  describe '#block_outside_ownership?' do
-    context 'given fetching a claim returns blockOutsideOwnership true' do
-      let(:data) { {"blockOutsideOwnership"=>true} }
-      it { expect(claim.block_outside_ownership?).to be true }
-    end
-
-    context 'given fetching a claim returns blockOutsideOwnership false' do
-      let(:data) { {"blockOutsideOwnership"=>false} }
-      it { expect(claim.block_outside_ownership?).to be false }
-    end
-  end
-
-  describe '#match_reference_id' do
-    context 'given fetching a claim returns matchInfo' do
-      let(:data) { {"matchInfo"=>{"referenceId"=>"0r3JDtcRLuQ"}} }
-      it { expect(claim.match_reference_id).to eq "0r3JDtcRLuQ" }
-    end
-  end
-
-  describe '#third_party?' do
-    context 'given fetching a claim returns thirdPartyClaim true' do
-      let(:data) { {"thirdPartyClaim"=>true} }
-      it { expect(claim.third_party?).to be true }
-    end
-
-    context 'given fetching a claim returns thirdPartyClaim true' do
-      let(:data) { {"thirdPartyClaim"=>false} }
-      it { expect(claim.third_party?).to be false }
-    end
-  end
-
-  describe '#source' do
-    context 'given fetching a claim returns a source' do
-      let(:data) { {"origin"=>{"source"=>"webUpload"}} }
-      it { expect(claim.source).to eq 'webUpload' }
-    end
-
-    context 'given fetching a claim does not return a source' do
-      let(:data) { {"origin"=>{}} }
-      it { expect(claim.source).to eq nil }
-    end
-  end
-end