yt 0.32.5 → 0.33.3

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

data/spec/models/comment_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'yt/models/comment'
-
-describe Yt::Comment do
-  subject(:comment) { Yt::Comment.new attrs }
-
-  describe '#snippet' do
-    context 'given fetching a comment returns a snippet' do
-      let(:attrs) { {snippet: {"videoId" => "12345"}} }
-      it { expect(comment.snippet).to be_a Yt::Snippet }
-    end
-  end
-
-  describe 'attributes' do
-    examples = {
-      video_id: {with: 'xyz123', without: nil},
-      parent_id: {with: 'abc123', without: nil},
-      text_display: {with: 'awesome', without: nil},
-      author_display_name: {with: 'John', without: nil},
-      like_count: {with: 10, without: nil},
-      updated_at: {input: '2016-03-22T12:56:56.3Z', with: Time.parse('2016-03-22T12:56:56.3Z'), without: nil},
-    }
-
-    examples.each do |attr, cases|
-      describe "##{attr}" do
-        context "given a snippet with a #{attr}" do
-          let(:attrs) {
-            {snippet: {"#{attr.to_s.camelize(:lower)}" => cases[:input] || cases[:with]}}}
-          it { expect(comment.send(attr)).to eq cases[:with] }
-        end
-
-        context "given a snippet without a #{attr}" do
-          let(:attrs) { {snippet: {}} }
-          it { expect(comment.send(attr)).to eq cases[:without] }
-        end
-      end
-    end
-  end
-end
-

data/spec/models/comment_thread_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-require 'yt/models/comment_thread'
-
-describe Yt::CommentThread do
-  subject(:comment_thread) { Yt::CommentThread.new attrs }
-
-  describe '#snippet' do
-    context 'given fetching a comment thread returns a snippet' do
-      let(:attrs) { {snippet: {"videoId" => "12345"}} }
-      it { expect(comment_thread.snippet).to be_a Yt::Snippet }
-    end
-  end
-
-  describe '#video_id' do
-    context 'given a snippet with a video id' do
-      let(:attrs) { {snippet: {"videoId"=>"12345"}} }
-      it { expect(comment_thread.video_id).to eq '12345' }
-    end
-
-    context 'given a snippet without a video id' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(comment_thread.video_id).to be_nil }
-    end
-  end
-
-  describe '#top_level_comment' do
-    context 'given a snippet with a top level comment' do
-      let(:attrs) { {snippet: {"topLevelComment"=> {}}} }
-      it { expect(comment_thread.top_level_comment).to be_a Yt::Comment }
-    end
-  end
-
-  describe 'attributes from #top_level_comment delegations' do
-    context 'with values' do
-      let(:attrs) { {snippet: {"topLevelComment"=> {"id" => "xyz123", "snippet" => {
-        "textDisplay" => "funny video!",
-        "authorDisplayName" => "fullscreen",
-        "likeCount" => 99,
-        "updatedAt" => "2016-03-22T12:56:56.3Z"}}}} }
-
-      it { expect(comment_thread.top_level_comment.id).to eq 'xyz123' }
-      it { expect(comment_thread.text_display).to eq 'funny video!' }
-      it { expect(comment_thread.author_display_name).to eq 'fullscreen' }
-      it { expect(comment_thread.like_count).to eq 99 }
-      it { expect(comment_thread.updated_at).to eq Time.parse('2016-03-22T12:56:56.3Z') }
-    end
-
-    context 'without values' do
-      let(:attrs) { {snippet: {"topLevelComment"=> {"snippet" => {}}}} }
-
-      it { expect(comment_thread.text_display).to be_nil }
-      it { expect(comment_thread.author_display_name).to be_nil }
-      it { expect(comment_thread.like_count).to be_nil }
-      it { expect(comment_thread.updated_at).to be_nil }
-    end
-  end
-
-  describe '#total_reply_count' do
-    context 'given a snippet with a total reply count' do
-      let(:attrs) { {snippet: {"totalReplyCount"=>1}} }
-      it { expect(comment_thread.total_reply_count).to eq 1 }
-    end
-
-    context 'given a snippet without a total reply count' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(comment_thread.total_reply_count).to be_nil }
-    end
-  end
-
-  describe '#can_reply?' do
-    context 'given a snippet with canReply set' do
-      let(:attrs) { {snippet: {"canReply"=>true}} }
-      it { expect(comment_thread.can_reply?).to be true }
-    end
-
-    context 'given a snippet without canReply set' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(comment_thread.can_reply?).to be false }
-    end
-  end
-
-  describe '#is_public?' do
-    context 'given a snippet with isPublic set' do
-      let(:attrs) { {snippet: {"isPublic"=>true}} }
-      it { expect(comment_thread).to be_public }
-    end
-
-    context 'given a snippet without isPublic set' do
-      let(:attrs) { {snippet: {}} }
-      it { expect(comment_thread).to_not be_public }
-    end
-  end
-end