yt 0.25.13 → 0.32.2

data/spec/requests/as_content_owner/account_spec.rb

@@ -16,6 +16,10 @@ describe Yt::Account, :partner do
         expect(content_owners.first).to be_a Yt::ContentOwner
       end
 
+      specify 'includes the display name for each content owner' do
+        expect(content_owners.first.display_name).to be_a String
+      end
+
       specify 'ensures the content owners have the same credentials as the account' do
         expect(content_owners.first.access_token).to eq account.access_token
         expect(content_owners.first.refresh_token).to eq account.refresh_token

data/spec/requests/as_content_owner/bulk_report_job_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'yt/models/bulk_report_job'
+
+describe Yt::BulkReportJob, :partner do
+
+  describe '.bulk_reports' do
+    describe 'given the bulk report job has bulk reports' do
+      let(:job) { $content_owner.bulk_report_jobs.first }
+      let(:report) { job.bulk_reports.first }
+
+      it 'returns valid bulk reports' do
+        expect(report.id).to be_a String
+        expect(report.start_time).to be_a Time
+        expect(report.end_time).to be_a Time
+        expect(report.download_url).to be_a String
+      end
+    end
+  end
+end

data/spec/requests/as_content_owner/channel_spec.rb

@@ -11,17 +11,19 @@ describe Yt::Channel, :partner do
       let(:id) { ENV['YT_TEST_PARTNER_CHANNEL_ID'] }
 
       describe 'multiple reports can be retrieved at once' do
-        metrics = {views: Integer, uniques: Integer,
+        metrics = {views: Integer,
           estimated_minutes_watched: Integer, comments: Integer, likes: Integer,
           dislikes: Integer, shares: Integer, subscribers_gained: Integer,
-          subscribers_lost: Integer, favorites_added: Integer,
+          subscribers_lost: Integer,
           videos_added_to_playlists: Integer, videos_removed_from_playlists: Integer,
-          favorites_removed: Integer, average_view_duration: Integer,
+          average_view_duration: Integer,
           average_view_percentage: Float, annotation_clicks: Integer,
-          annotation_click_through_rate: Float,
-          annotation_close_rate: Float, earnings: Float, impressions: Integer,
+          annotation_click_through_rate: Float, annotation_close_rate: Float,
+          card_impressions: Integer, card_clicks: Integer,
+          card_click_rate: Float, card_teaser_impressions: Integer,
+          card_teaser_clicks: Integer, card_teaser_click_rate: Float,
+          estimated_revenue: Float, ad_impressions: Integer,
           monetized_playbacks: Integer, playback_based_cpm: Float}
-
         specify 'by day, and are chronologically sorted' do
           range = {since: 5.days.ago.to_date, until: 3.days.ago.to_date}
           result = channel.reports range.merge(only: metrics, by: :day)
@@ -57,13 +59,15 @@ describe Yt::Channel, :partner do
         end
       end
 
-      [:views, :uniques, :comments, :likes, :dislikes, :shares,
-       :subscribers_gained, :subscribers_lost, :favorites_added,
+      [:views, :comments, :likes, :dislikes, :shares,
+       :subscribers_gained, :subscribers_lost,
        :videos_added_to_playlists, :videos_removed_from_playlists,
-       :favorites_removed, :estimated_minutes_watched, :average_view_duration,
-       :average_view_percentage, :impressions, :monetized_playbacks,
-       :annotation_clicks, :annotation_click_through_rate, :playback_based_cpm,
-       :annotation_close_rate, :earnings].each do |metric|
+       :estimated_minutes_watched, :average_view_duration,
+       :average_view_percentage, :ad_impressions, :monetized_playbacks,
+       :annotation_clicks, :annotation_click_through_rate,
+       :card_impressions, :card_clicks, :card_click_rate,
+       :card_teaser_impressions, :card_teaser_clicks, :card_teaser_click_rate,
+       :playback_based_cpm, :annotation_close_rate, :estimated_revenue].each do |metric|
         describe "#{metric} can be retrieved for a range of days" do
           let(:date_in) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
           let(:date_out) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5 }
@@ -118,27 +122,14 @@ describe Yt::Channel, :partner do
        subscribers_gained: Integer, subscribers_lost: Integer,
        estimated_minutes_watched: Integer, average_view_duration: Integer,
        annotation_clicks: Integer, annotation_click_through_rate: Float,
-       favorites_added: Integer, favorites_removed: Integer,
+       card_impressions: Integer, card_clicks: Integer,
+       card_click_rate: Float, card_teaser_impressions: Integer,
+       card_teaser_clicks: Integer, card_teaser_click_rate: Float,
        videos_added_to_playlists: Integer, videos_removed_from_playlists: Integer,
-       average_view_percentage: Float, impressions: Integer,
+       average_view_percentage: Float, ad_impressions: Integer,
        shares: Integer, playback_based_cpm: Float,
        monetized_playbacks: Integer, annotation_close_rate: Float,
-       earnings: Float}.each do |metric, type|
-        describe "#{metric} can be retrieved for a specific day" do
-          let(:metric) { metric }
-          let(:result) { channel.public_send "#{metric}_on", date }
-
-          context 'in which the channel had data for the report' do
-            let(:date) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE'])  + 95  }
-            it { expect(result).to be_a type }
-          end
-
-          context 'in which the channel was not partnered' do
-            let(:date) { 5.days.from_now }
-            it { expect(result).to be_nil }
-          end
-        end
-
+       estimated_revenue: Float}.each do |metric, type|
         describe "#{metric} can be grouped by range" do
           let(:metric) { metric }
 
@@ -160,24 +151,24 @@ describe Yt::Channel, :partner do
         end
       end
 
-      describe 'earnings can be retrieved for a specific day' do
+      describe 'estimated_revenue can be retrieved for a specific day' do
         # NOTE: This test sounds redundant, but it’s actually a reflection of
         # another irrational behavior of YouTube API. In short, if you ask for
-        # the "earnings" metric of a day in which a channel made 0 USD, then
-        # the API returns "nil". But if you also for the "earnings" metric AND
+        # the "estimated_revenue" metric of a day in which a channel made 0 USD, then
+        # the API returns "nil". But if you also for the "estimated_revenue" metric AND
         # the "estimatedMinutesWatched" metric, then the API returns the
         # correct value of "0", while still returning nil for those days in
-        # which the earnings have not been estimated yet.
+        # which the estimated_revenue have not been estimated yet.
         context 'in which the channel did not make any money' do
-          let(:zero_date) { ENV['YT_TEST_PARTNER_CHANNEL_NO_EARNINGS_DATE'] }
-          let(:earnings) { channel.earnings_on zero_date}
-          it { expect(earnings).to eq 0 }
+          let(:zero_date) { ENV['YT_TEST_PARTNER_CHANNEL_NO_estimated_revenue_DATE'] }
+          let(:estimated_revenue) { channel.estimated_revenue_on zero_date}
+          it { expect(estimated_revenue).to eq 0 }
         end
       end
 
-      describe 'earnings can be retrieved for a single country' do
+      describe 'estimated_revenue can be retrieved for a single country' do
         let(:country_code) { 'US' }
-        let(:earnings) { channel.earnings since: date, by: by, in: location }
+        let(:estimated_revenue) { channel.estimated_revenue since: date, by: by, in: location }
         let(:date) { 4.days.ago }
 
         context 'and grouped by day' do
@@ -185,12 +176,12 @@ describe Yt::Channel, :partner do
 
           context 'with the :in option set to the country code' do
             let(:location) { country_code }
-            it { expect(earnings.keys.min).to eq date.to_date }
+            it { expect(estimated_revenue.keys.min).to eq date.to_date }
           end
 
           context 'with the :in option set to {country: country code}' do
             let(:location) { {country: country_code} }
-            it { expect(earnings.keys.min).to eq date.to_date }
+            it { expect(estimated_revenue.keys.min).to eq date.to_date }
           end
         end
 
@@ -199,34 +190,34 @@ describe Yt::Channel, :partner do
 
           context 'with the :in option set to the country code' do
             let(:location) { country_code }
-            it { expect(earnings.keys).to eq [country_code] }
+            it { expect(estimated_revenue.keys).to eq [country_code] }
           end
 
           context 'with the :in option set to {country: country code}' do
             let(:location) { {country: country_code} }
-            it { expect(earnings.keys).to eq [country_code] }
+            it { expect(estimated_revenue.keys).to eq [country_code] }
           end
         end
       end
 
-      describe 'earnings can be grouped by day' do
+      describe 'estimated_revenue can be grouped by day' do
         let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
         let(:keys) { range.values }
 
         specify 'with the :by option set to :day' do
-          earnings = channel.earnings range.merge by: :day
-          expect(earnings.keys).to eq range.values
+          estimated_revenue = channel.estimated_revenue range.merge by: :day
+          expect(estimated_revenue.keys).to eq range.values
         end
       end
 
-      describe 'earnings can be grouped by country' do
+      describe 'estimated_revenue can be grouped by country' do
         let(:range) { {since: 4.days.ago, until: 3.days.ago} }
 
         specify 'with the :by option set to :country' do
-          earnings = channel.earnings range.merge by: :country
-          expect(earnings.keys).to all(be_a String)
-          expect(earnings.keys.map(&:length).uniq).to eq [2]
-          expect(earnings.values).to all(be_a Float)
+          estimated_revenue = channel.estimated_revenue range.merge by: :country
+          expect(estimated_revenue.keys).to all(be_a String)
+          expect(estimated_revenue.keys.map(&:length).uniq).to eq [2]
+          expect(estimated_revenue.values).to all(be_a Float)
         end
       end
 
@@ -496,56 +487,6 @@ describe Yt::Channel, :partner do
         end
       end
 
-      describe 'uniques can be retrieved for a single country' do
-        let(:country_code) { 'US' }
-        let(:uniques) { channel.uniques since: date, by: by, in: location }
-        let(:date) { 4.days.ago }
-
-        context 'and grouped by day' do
-          let(:by) { :day }
-
-          context 'with the :in option set to the country code' do
-            let(:location) { country_code }
-            it { expect(uniques.keys.min).to eq date.to_date }
-          end
-
-          context 'with the :in option set to {country: country code}' do
-            let(:location) { {country: country_code} }
-            it { expect(uniques.keys.min).to eq date.to_date }
-          end
-        end
-      end
-
-      describe 'uniques can be retrieved for a single US state' do
-        let(:state_code) { 'NY' }
-        let(:result) { channel.uniques since: date, by: by, in: location }
-        let(:date) { 4.days.ago }
-
-        context 'and grouped by day' do
-          let(:by) { :day }
-
-          context 'with the :in option set to {state: state code}' do
-            let(:location) { {state: state_code} }
-            it { expect(result.keys.min).to eq date.to_date }
-          end
-
-          context 'with the :in option set to {country: "US", state: state code}' do
-            let(:location) { {country: 'US', state: state_code} }
-            it { expect(result.keys.min).to eq date.to_date }
-          end
-        end
-      end
-
-      describe 'uniques can be grouped by day' do
-        let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
-        let(:keys) { range.values }
-
-        specify 'with the :by option set to :day' do
-          uniques = channel.uniques range.merge by: :day
-          expect(uniques.keys).to eq range.values
-        end
-      end
-
       describe 'comments can be retrieved for a single country' do
         let(:country_code) { 'US' }
         let(:comments) { channel.comments since: date, by: by, in: location }
@@ -876,116 +817,6 @@ describe Yt::Channel, :partner do
         end
       end
 
-      describe 'favorites added can be retrieved for a single country' do
-        let(:country_code) { 'US' }
-        let(:favorites_added) { channel.favorites_added since: date, by: by, in: location }
-        let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
-
-        context 'and grouped by day' do
-          let(:by) { :day }
-
-          context 'with the :in option set to the country code' do
-            let(:location) { country_code }
-            it { expect(favorites_added.keys.min).to eq date.to_date }
-          end
-
-          context 'with the :in option set to {country: country code}' do
-            let(:location) { {country: country_code} }
-            it { expect(favorites_added.keys.min).to eq date.to_date }
-          end
-        end
-
-        context 'and grouped by country' do
-          let(:by) { :country }
-
-          context 'with the :in option set to the country code' do
-            let(:location) { country_code }
-            it { expect(favorites_added.keys).to eq [country_code] }
-          end
-
-          context 'with the :in option set to {country: country code}' do
-            let(:location) { {country: country_code} }
-            it { expect(favorites_added.keys).to eq [country_code] }
-          end
-        end
-      end
-
-      describe 'added favorites can be grouped by day' do
-        let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
-        let(:keys) { range.values }
-
-        specify 'with the :by option set to :day' do
-          favorites_added = channel.favorites_added range.merge by: :day
-          expect(favorites_added.keys).to eq range.values
-        end
-      end
-
-      describe 'added favorites can be grouped by country' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
-
-        specify 'with the :by option set to :country' do
-          favorites_added = channel.favorites_added range.merge by: :country
-          expect(favorites_added.keys).to all(be_a String)
-          expect(favorites_added.keys.map(&:length).uniq).to eq [2]
-          expect(favorites_added.values).to all(be_an Integer)
-        end
-      end
-
-      describe 'favorites removed can be retrieved for a single country' do
-        let(:country_code) { 'US' }
-        let(:favorites_removed) { channel.favorites_removed since: date, by: by, in: location }
-        let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
-
-        context 'and grouped by day' do
-          let(:by) { :day }
-
-          context 'with the :in option set to the country code' do
-            let(:location) { country_code }
-            it { expect(favorites_removed.keys.min).to eq date.to_date }
-          end
-
-          context 'with the :in option set to {country: country code}' do
-            let(:location) { {country: country_code} }
-            it { expect(favorites_removed.keys.min).to eq date.to_date }
-          end
-        end
-
-        context 'and grouped by country' do
-          let(:by) { :country }
-
-          context 'with the :in option set to the country code' do
-            let(:location) { country_code }
-            it { expect(favorites_removed.keys).to eq [country_code] }
-          end
-
-          context 'with the :in option set to {country: country code}' do
-            let(:location) { {country: country_code} }
-            it { expect(favorites_removed.keys).to eq [country_code] }
-          end
-        end
-      end
-
-      describe 'removed favorites can be grouped by day' do
-        let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
-        let(:keys) { range.values }
-
-        specify 'with the :by option set to :day' do
-          favorites_removed = channel.favorites_removed range.merge by: :day
-          expect(favorites_removed.keys).to eq range.values
-        end
-      end
-
-      describe 'removed favorites can be grouped by country' do
-        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE'], until: Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5} }
-
-        specify 'with the :by option set to :country' do
-          favorites_removed = channel.favorites_removed range.merge by: :country
-          expect(favorites_removed.keys).to all(be_a String)
-          expect(favorites_removed.keys.map(&:length).uniq).to eq [2]
-          expect(favorites_removed.values).to all(be_an Integer)
-        end
-      end
-
       describe 'videos added to playlists can be retrieved for a single country' do
         let(:country_code) { 'US' }
         let(:videos_added_to_playlists) { channel.videos_added_to_playlists since: date, by: by, in: location }
@@ -1020,27 +851,6 @@ describe Yt::Channel, :partner do
         end
       end
 
-      describe 'added favorites can be grouped by day' do
-        let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
-        let(:keys) { range.values }
-
-        specify 'with the :by option set to :day' do
-          videos_added_to_playlists = channel.videos_added_to_playlists range.merge by: :day
-          expect(videos_added_to_playlists.keys).to eq range.values
-        end
-      end
-
-      describe 'added favorites can be grouped by country' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
-
-        specify 'with the :by option set to :country' do
-          videos_added_to_playlists = channel.videos_added_to_playlists range.merge by: :country
-          expect(videos_added_to_playlists.keys).to all(be_a String)
-          expect(videos_added_to_playlists.keys.map(&:length).uniq).to eq [2]
-          expect(videos_added_to_playlists.values).to all(be_an Integer)
-        end
-      end
-
       describe 'videos removed from playlists can be retrieved for a single country' do
         let(:country_code) { 'US' }
         let(:videos_removed_from_playlists) { channel.videos_removed_from_playlists since: date, by: by, in: location }
@@ -1075,27 +885,6 @@ describe Yt::Channel, :partner do
         end
       end
 
-      describe 'removed favorites can be grouped by day' do
-        let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
-        let(:keys) { range.values }
-
-        specify 'with the :by option set to :day' do
-          videos_removed_from_playlists = channel.videos_removed_from_playlists range.merge by: :day
-          expect(videos_removed_from_playlists.keys).to eq range.values
-        end
-      end
-
-      describe 'removed favorites can be grouped by country' do
-        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE'], until: Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5} }
-
-        specify 'with the :by option set to :country' do
-          videos_removed_from_playlists = channel.videos_removed_from_playlists range.merge by: :country
-          expect(videos_removed_from_playlists.keys).to all(be_a String)
-          expect(videos_removed_from_playlists.keys.map(&:length).uniq).to eq [2]
-          expect(videos_removed_from_playlists.values).to all(be_an Integer)
-        end
-      end
-
       describe 'estimated minutes watched can be retrieved for a single country' do
         let(:country_code) { 'US' }
         let(:estimated_minutes_watched) { channel.estimated_minutes_watched since: date, by: by, in: location }
@@ -1480,9 +1269,9 @@ describe Yt::Channel, :partner do
         end
       end
 
-      describe 'impressions can be retrieved for a single country' do
+      describe 'ad_impressions can be retrieved for a single country' do
         let(:country_code) { 'US' }
-        let(:impressions) { channel.impressions since: date, by: by, in: location }
+        let(:ad_impressions) { channel.ad_impressions since: date, by: by, in: location }
         let(:date) { ENV['YT_TEST_PARTNER_PLAYLIST_DATE'] }
 
         context 'and grouped by day' do
@@ -1490,12 +1279,12 @@ describe Yt::Channel, :partner do
 
           context 'with the :in option set to the country code' do
             let(:location) { country_code }
-            it { expect(impressions.keys.min).to eq date.to_date }
+            it { expect(ad_impressions.keys.min).to eq date.to_date }
           end
 
           context 'with the :in option set to {country: country code}' do
             let(:location) { {country: country_code} }
-            it { expect(impressions.keys.min).to eq date.to_date }
+            it { expect(ad_impressions.keys.min).to eq date.to_date }
           end
         end
 
@@ -1504,34 +1293,34 @@ describe Yt::Channel, :partner do
 
           context 'with the :in option set to the country code' do
             let(:location) { country_code }
-            it { expect(impressions.keys).to eq [country_code] }
+            it { expect(ad_impressions.keys).to eq [country_code] }
           end
 
           context 'with the :in option set to {country: country code}' do
             let(:location) { {country: country_code} }
-            it { expect(impressions.keys).to eq [country_code] }
+            it { expect(ad_impressions.keys).to eq [country_code] }
           end
         end
       end
 
-      describe 'impressions can be grouped by day' do
+      describe 'ad_impressions can be grouped by day' do
         let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
         let(:keys) { range.values }
 
         specify 'with the :by option set to :day' do
-          impressions = channel.impressions range.merge by: :day
-          expect(impressions.keys).to eq range.values
+          ad_impressions = channel.ad_impressions range.merge by: :day
+          expect(ad_impressions.keys).to eq range.values
         end
       end
 
-      describe 'impressions can be grouped by country' do
+      describe 'ad_impressions can be grouped by country' do
         let(:range) { {since: ENV['YT_TEST_PARTNER_PLAYLIST_DATE']} }
 
         specify 'with the :by option set to :country' do
-          impressions = channel.impressions range.merge by: :country
-          expect(impressions.keys).to all(be_a String)
-          expect(impressions.keys.map(&:length).uniq).to eq [2]
-          expect(impressions.values).to all(be_an Integer)
+          ad_impressions = channel.ad_impressions range.merge by: :country
+          expect(ad_impressions.keys).to all(be_a String)
+          expect(ad_impressions.keys.map(&:length).uniq).to eq [2]
+          expect(ad_impressions.values).to all(be_an Integer)
         end
       end
 
@@ -2033,8 +1822,8 @@ describe Yt::Channel, :partner do
     context 'not managed by the authenticated Content Owner' do
       let(:id) { 'UCBR8-60-B28hp2BmDPdntcQ' }
 
-      specify 'earnings and impressions cannot be retrieved' do
-        expect{channel.earnings}.to raise_error Yt::Errors::Forbidden
+      specify 'estimated_revenue and ad_impressions cannot be retrieved' do
+        expect{channel.estimated_revenue}.to raise_error Yt::Errors::Forbidden
         expect{channel.views}.to raise_error Yt::Errors::Forbidden
       end
 
@@ -2044,4 +1833,4 @@ describe Yt::Channel, :partner do
       end
     end
   end
-end
+end