yt 0.32.5 → 0.33.3

data/spec/collections/claims_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/claims'
-require 'yt/models/content_owner'
-
-describe Yt::Collections::Claims do
-  let(:content_owner) { Yt::ContentOwner.new owner_name: 'any-name' }
-  let(:collection) { Yt::Collections::Claims.new parent: content_owner, auth: content_owner }
-  let(:page) { {items: [], token: 'any-token'} }
-  let(:query) { {q: 'search string'} }
-
-  describe "#insert" do
-    let(:attributes) {
-      {
-        asset_id: 'some_asset_id',
-        video_id: 'some_video_id',
-        content_type: 'audiovisual',
-        policy: { id: 'some_policy_id' },
-        match_info: { match_segments: [ { manual_segment: { start: "00:01:00.000", finish: "00:02:00.000" } } ] },
-        is_manual_claim: true
-      }
-    }
-
-    before do
-      allow(collection).to receive(:do_insert)
-      collection.insert(attributes.deep_dup)
-    end
-
-    it 'calls do_insert with appropriate body' do
-      body = {
-        asset_id: 'some_asset_id',
-        video_id: 'some_video_id',
-        content_type: 'audiovisual',
-        policy: { id: 'some_policy_id' },
-        match_info: { matchSegments: [ { manual_segment: { start: "00:01:00.000", finish: "00:02:00.000" } } ] }
-      }
-      expect(collection).to have_received(:do_insert).with(
-        params: { is_manual_claim: true, on_behalf_of_content_owner: content_owner.owner_name },
-        body: body
-      )
-    end
-  end
-
-  describe '#count' do
-    context 'called once with .where(query) and once without' do
-      after do
-        collection.where(query).count
-        collection.count
-      end
-
-      it 'only applies the query on the first call' do
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).to include query
-          page
-        end
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).not_to include query
-          page
-        end
-      end
-    end
-  end
-end

data/spec/collections/comment_threads_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/comment_threads'
-require 'yt/models/video'
-require 'yt/models/channel'
-
-describe Yt::Collections::CommentThreads do
-  subject(:collection) { Yt::Collections::CommentThreads.new parent: parent}
-
-  describe '#size', :ruby2 do
-    describe 'sends only one request and return the total results' do
-      let(:total_results) { 1234 }
-      let(:parent) { Yt::Video.new id: 'any-id' }
-
-      before do
-        expect_any_instance_of(Yt::Request).to receive(:run).once do
-          double(body: {'pageInfo'=>{'totalResults'=>total_results}})
-        end
-      end
-      it { expect(collection.size).to be total_results }
-    end
-  end
-
-  describe '#count' do
-    let(:query) { {q: 'search string'} }
-    let(:parent) { Yt::Video.new id: 'any-id' }
-    let(:page) { {items: [], token: 'any-token'} }
-
-    context 'called once with .where(query) and once without' do
-      after do
-        collection.where(query).count
-        collection.count
-      end
-
-      it 'only applies the query on the first call' do
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).to include query
-          page
-        end
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).not_to include query
-          page
-        end
-      end
-    end
-  end
-end

data/spec/collections/playlist_items_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'yt/models/playlist'
-require 'yt/models/playlist_item'
-require 'yt/collections/playlist_items'
-
-describe Yt::Collections::PlaylistItems do
-  subject(:collection) { Yt::Collections::PlaylistItems.new parent: playlist }
-  let(:playlist) { Yt::Playlist.new id: 'LLxO1tY8h1AhOz0T4ENwmpow' }
-  let(:attrs) { {id: '9bZkp7q19f0', kind: :video} }
-  let(:msg) { {response_body: {error: {errors: [{reason: reason}]}}}.to_json }
-  before { expect(collection).to behave }
-
-  describe '#insert' do
-    let(:playlist_item) { Yt::PlaylistItem.new }
-
-    context 'given an existing video' do
-      let(:behave) { receive(:do_insert).and_return playlist_item }
-
-      it { expect(collection.insert attrs).to eq playlist_item }
-    end
-
-    context 'given an unknown video' do
-      let(:reason) { 'videoNotFound' }
-      let(:behave) { receive(:do_insert).and_raise Yt::Error, msg }
-
-      it { expect{collection.insert attrs}.to fail.with 'videoNotFound' }
-      it { expect{collection.insert attrs, ignore_errors: true}.not_to fail }
-    end
-
-    context 'given a forbidden video' do
-      let(:reason) { 'forbidden' }
-      let(:behave) { receive(:do_insert).and_raise Yt::Error, msg }
-
-      it { expect{collection.insert attrs}.to fail.with 'forbidden' }
-      it { expect{collection.insert attrs, ignore_errors: true}.not_to fail }
-    end
-  end
-
-  describe '#delete_all' do
-    let(:behave) { receive(:do_delete_all).and_return [true] }
-
-    it { expect(collection.delete_all).to eq [true] }
-  end
-end

data/spec/collections/playlists_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/playlists'
-
-describe Yt::Collections::Playlists do
-  subject(:collection) { Yt::Collections::Playlists.new }
-  before { expect(collection).to behave }
-
-  describe '#insert' do
-    let(:playlist) { Yt::Playlist.new }
-    # TODO: separate stubs to show options translate into do_insert params
-    let(:behave) { receive(:do_insert).and_return playlist }
-
-    it { expect(collection.insert).to eq playlist }
-  end
-
-  describe '#delete_all' do
-    let(:behave) { receive(:do_delete_all).and_return [true] }
-
-    it { expect(collection.delete_all).to eq [true] }
-  end
-
-  describe '#delete_all' do
-    let(:behave) { receive(:do_delete_all).and_return [true] }
-
-    it { expect(collection.delete_all).to eq [true] }
-  end
-end

data/spec/collections/policies_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/policies'
-require 'yt/models/content_owner'
-
-describe Yt::Collections::Policies do
-  subject(:collection) { Yt::Collections::Policies.new parent: content_owner }
-  let(:content_owner) { Yt::ContentOwner.new owner_name: 'any-name' }
-  let(:page) { {items: [], token: 'any-token'} }
-  let(:query) { {id: 'any-id'} }
-
-  describe '#count' do
-    context 'called once with .where(query) and once without' do
-      after do
-        collection.where(query).count
-        collection.count
-      end
-
-      it 'only applies the query on the first call' do
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).to include query
-          page
-        end
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).not_to include query
-          page
-        end
-      end
-    end
-  end
-end

data/spec/collections/references_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/references'
-require 'yt/models/content_owner'
-
-describe Yt::Collections::References do
-  subject(:collection) { Yt::Collections::References.new parent: content_owner }
-  let(:content_owner) { Yt::ContentOwner.new id: 'any-id' }
-  let(:page) { {items: [], token: 'any-token'} }
-  let(:query) { {id: 'reference-id'} }
-
-  describe '#count' do
-    context 'called once with .where(query) and once without' do
-      after do
-        collection.where(query).count
-        collection.count
-      end
-
-      it 'only applies the query on the first call' do
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).to include query
-          page
-        end
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).not_to include query
-          page
-        end
-      end
-    end
-  end
-end

data/spec/collections/reports_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/reports'
-require 'yt/models/content_owner'
-
-describe Yt::Collections::Reports do
-  subject(:reports) { Yt::Collections::Reports.new(parent: content_owner).tap{|reports| reports.metrics = {views: Integer}} }
-  let(:content_owner) { Yt::ContentOwner.new owner_name: 'any-name' }
-  let(:error){ {reason: reason, message: message} }
-  let(:msg) { {response_body: {error: {errors: [error]}}}.to_json }
-
-  describe '#within' do
-    let(:result) { reports.within Range.new(5.days.ago, 4.days.ago), nil, nil, :day, nil, nil }
-    context 'given the request raises error 400 with "Invalid Query" message' do
-      let(:reason) { 'badRequest' }
-      let(:message) { 'Invalid query. Query did not conform to the expectations' }
-      before { expect(reports).to receive(:list).once.and_raise Yt::Error, msg }
-      let(:try_again) { expect(reports).to receive(:list).at_least(:once) }
-
-      context 'every time' do
-        before { try_again.and_raise Yt::Error, msg }
-        it { expect{result}.to fail }
-      end
-
-      context 'but returns a success code 2XX the second time' do
-        before { try_again.and_return [views: {total: 20}] }
-        it { expect{result}.not_to fail }
-      end
-    end
-  end
-end

data/spec/collections/subscriptions_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/subscriptions'
-
-describe Yt::Collections::Subscriptions do
-  subject(:collection) { Yt::Collections::Subscriptions.new }
-  let(:msg) { {response_body: {error: {errors: [{reason: reason}]}}}.to_json }
-  before { expect(collection).to behave }
-
-  describe '#insert' do
-    context 'given a new subscription' do
-      let(:subscription) { Yt::Subscription.new }
-      let(:behave) { receive(:do_insert).and_return subscription }
-
-      it { expect(collection.insert).to eq subscription }
-    end
-
-    context 'given a duplicate subscription' do
-      let(:reason) { 'subscriptionDuplicate' }
-      let(:behave) { receive(:do_insert).and_raise Yt::Error, msg }
-
-      it { expect{collection.insert}.to fail.with 'subscriptionDuplicate' }
-      it { expect{collection.insert ignore_errors: true}.not_to fail }
-    end
-  end
-end

data/spec/collections/videos_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'yt/collections/videos'
-require 'yt/models/channel'
-
-describe Yt::Collections::Videos do
-  subject(:collection) { Yt::Collections::Videos.new parent: channel }
-  let(:channel) { Yt::Channel.new id: 'any-id' }
-  let(:page) { {items: [], token: 'any-token'} }
-
-  describe '#size', :ruby2 do
-    describe 'sends only one request and return the total results' do
-      let(:total_results) { 123456 }
-      before do
-        expect_any_instance_of(Yt::Request).to receive(:run).once do
-          double(body: {'pageInfo'=>{'totalResults'=>total_results}})
-        end
-      end
-      it { expect(collection.size).to be total_results }
-    end
-  end
-
-  describe '#count' do
-    let(:query) { {q: 'search string'} }
-
-    context 'called once with .where(query) and once without' do
-      after do
-        collection.where(query).count
-        collection.count
-      end
-
-      it 'only applies the query on the first call' do
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).to include query
-          page
-        end
-        expect(collection).to receive(:fetch_page) do |options|
-          expect(options[:params]).not_to include query
-          page
-        end
-      end
-    end
-  end
-end

data/spec/constants/geography_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'yt/constants/geography'
-
-describe 'Yt::COUNTRIES' do
-  it 'returns all country codes and names' do
-    expect(Yt::COUNTRIES[:US]).to eq 'United States'
-    expect(Yt::COUNTRIES['IT']).to eq 'Italy'
-  end
-end
-
-describe 'Yt::US_STATES' do
-  it 'returns all U.S. state codes and names' do
-    expect(Yt::US_STATES[:CA]).to eq 'California'
-    expect(Yt::US_STATES['CO']).to eq 'Colorado'
-  end
-end

data/spec/errors/forbidden_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'yt/errors/forbidden'
-
-describe Yt::Errors::Forbidden do
-  let(:msg) { %r{^A request to YouTube API was considered forbidden by the server} }
-
-  describe '#exception' do
-    it { expect{raise Yt::Errors::Forbidden}.to raise_error msg }
-  end
-end

data/spec/errors/missing_auth_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'yt/errors/missing_auth'
-
-describe Yt::Errors::MissingAuth do
-  subject(:error) { raise Yt::Errors::MissingAuth, params }
-  let(:params) { {} }
-  let(:msg) { %r{^A request to YouTube API was sent without a valid authentication} }
-
-  describe '#exception' do
-    it { expect{error}.to raise_error msg }
-
-    context 'given the user can authenticate via web' do
-      let(:params) { {scopes: 'youtube', authentication_url: 'http://google.example.com/auth', redirect_uri: 'http://localhost/'} }
-      let(:msg) { %r{^You can ask YouTube accounts to authenticate your app} }
-      it { expect{error}.to raise_error msg }
-    end
-
-    context 'given the user can authenticate via device code' do
-      let(:params) { {scopes: 'youtube', user_code: 'abcdefgh', verification_url: 'http://google.com/device'} }
-      let(:msg) { %r{^Please authenticate your app by visiting the page} }
-      it { expect{error}.to raise_error msg }
-    end
-  end
-end

data/spec/errors/no_items_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'yt/errors/no_items'
-
-describe Yt::Errors::NoItems do
-  let(:msg) { %r{^A request to YouTube API returned no items} }
-
-  describe '#exception' do
-    it { expect{raise Yt::Errors::NoItems}.to raise_error msg }
-  end
-end

data/spec/errors/request_error_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'yt/errors/request_error'
-
-describe Yt::Errors::RequestError do
-  subject(:error) { raise Yt::Errors::RequestError, params }
-  let(:params) { {} }
-  let(:msg) { %r{^A request to YouTube API failed} }
-
-  describe '#exception' do
-    it { expect{error}.to raise_error msg }
-
-    context 'given the exception includes sensitive data' do
-      let(:body) { 'some secret token' }
-      let(:curl) { 'curl -H "Authorization: secret-token"' }
-      let(:params) { {response_body: body, request_curl: curl}.to_json }
-
-      describe 'given a log level of :debug or :devel' do
-        before(:all) { Yt.configuration.log_level = :debug }
-        specify 'exposes sensitive data' do
-          expect{error}.to raise_error do |error|
-            expect(error.message).to include 'secret'
-          end
-        end
-      end
-
-      describe 'given a different log level' do
-        before(:all) { Yt.configuration.log_level = :info }
-        specify 'hides sensitive data' do
-          expect{error}.to raise_error do |error|
-            expect(error.message).not_to include 'secret'
-          end
-        end
-      end
-    end
-  end
-end
-
-describe Yt::Error do
-  let(:msg) { %r{^A request to YouTube API failed} }
-
-  describe '#exception' do
-    it { expect{raise Yt::Error}.to raise_error msg }
-  end
-end