yt 0.25.13 → 0.32.2

data/spec/requests/as_content_owner/content_owner_spec.rb

@@ -14,6 +14,71 @@ describe Yt::ContentOwner, :partner do
     end
   end
 
+  describe '.videos' do
+    let(:video) { $content_owner.videos.where(order: 'viewCount').first }
+
+    specify 'returns the videos in network with the content owner with their tags and category ID' do
+      expect(video).to be_a Yt::Video
+      expect(video.tags).not_to be_empty
+      expect(video.category_id).not_to be_nil
+    end
+
+    describe '.includes(:snippet)' do
+      let(:video) { $content_owner.videos.includes(:snippet).first }
+
+      specify 'eager-loads the *full* snippet of each video' do
+        expect(video.instance_variable_defined? :@snippet).to be true
+        expect(video.channel_title).to be
+        expect(video.snippet).to be_complete
+      end
+    end
+
+    describe '.includes(:statistics, :status)' do
+      let(:video) { $content_owner.videos.includes(:statistics, :status).first }
+
+      specify 'eager-loads the statistics and status of each video' do
+        expect(video.instance_variable_defined? :@statistics_set).to be true
+        expect(video.instance_variable_defined? :@status).to be true
+      end
+    end
+
+    describe '.includes(:content_details)' do
+      let(:video) { $content_owner.videos.includes(:content_details).first }
+
+      specify 'eager-loads the statistics of each video' do
+        expect(video.instance_variable_defined? :@content_detail).to be true
+      end
+    end
+
+    describe '.includes(:claim)' do
+      let(:videos) { $content_owner.videos.includes(:claim) }
+      let(:video_with_claim) { videos.find{|v| v.claim.present?} }
+
+      specify 'eager-loads the claim of each video and its asset' do
+        expect(video_with_claim.claim).to be_a Yt::Claim
+        expect(video_with_claim.claim.id).to be_a String
+        expect(video_with_claim.claim.video_id).to eq video_with_claim.id
+        expect(video_with_claim.claim.asset).to be_a Yt::Asset
+        expect(video_with_claim.claim.asset.id).to be_a String
+      end
+    end
+  end
+
+  describe '.video_groups' do
+    let(:video_group) { $content_owner.video_groups.first }
+
+    specify 'returns the first video-group created by the account' do
+      expect(video_group).to be_a Yt::VideoGroup
+      expect(video_group.title).to be_a String
+      expect(video_group.item_count).to be_an Integer
+      expect(video_group.published_at).to be_a Time
+    end
+
+    specify 'allows to run reports against each video-group' do
+      expect(video_group.views).to be
+    end
+  end
+
   describe 'claims' do
     let(:asset_id) { ENV['YT_TEST_PARTNER_ASSET_ID'] }
     let(:video_id) { ENV['YT_TEST_PARTNER_CLAIMABLE_VIDEO_ID'] }
@@ -227,6 +292,29 @@ describe Yt::ContentOwner, :partner do
     end
   end
 
+  describe '.assets' do
+    describe 'given the content owner has assets' do
+      let(:asset) { $content_owner.assets.first }
+
+      it 'returns valid asset' do
+        expect(asset.id).to be_a String
+        expect(asset.type).to be_a String
+        expect(asset.title).to be_a String
+        expect(asset.custom_id).to be_a String
+      end
+    end
+  end
+
+  describe '.bulk_report_jobs' do
+    describe 'given the content owner has bulk report jobs' do
+      let(:job) { $content_owner.bulk_report_jobs.first }
+
+      it 'returns valid job' do
+        expect(job.id).to be_a String
+        expect(job.report_type_id).to be_a String
+      end
+    end
+  end
   # @note: The following test works, but YouTube API endpoint to mark
   #   an asset as 'invalid' (soft-delete) does not work, and apparently
   #   there is no way to update the status of a asset.
@@ -238,4 +326,4 @@ describe Yt::ContentOwner, :partner do
   #   after { @asset.delete } # This does not seem to work
   #   it { expect(@asset).to be_a Yt::Asset }
   # end
-end
+end

data/spec/requests/as_content_owner/playlist_spec.rb

@@ -100,21 +100,6 @@ describe Yt::Playlist, :partner do
           end
         end
 
-        describe "#{metric} can be retrieved for a specific day" do
-          let(:metric) { metric }
-          let(:result) { playlist.public_send "#{metric}_on", date }
-
-          context 'in which the playlist had data' do
-            let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
-            it { expect(result).to be_a type }
-          end
-
-          context 'in the future' do
-            let(:date) { 5.days.from_now }
-            it { expect(result).to be_nil }
-          end
-        end
-
         describe "#{metric} can be grouped by range" do
           let(:metric) { metric }
 

data/spec/requests/as_content_owner/video_group_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'yt/models/video_group'
+require 'yt/models/group_item'
+
+describe Yt::VideoGroup, :partner do
+  subject(:video_group) { Yt::VideoGroup.new id: id, auth: $content_owner }
+
+  context 'given a channel-group', :partner do
+    context 'managed by the authenticated Content Owner' do
+      let(:id) { ENV['YT_TEST_PARTNER_CHANNEL_GROUP_ID'] }
+
+      specify '.videos loads each video of each channel' do
+        video = video_group.videos.first
+        expect(video.instance_variable_defined? :@snippet).to be true
+        expect(video.instance_variable_defined? :@status).to be true
+        expect(video.instance_variable_defined? :@statistics_set).to be true
+      end
+
+      specify '.channels loads each channel' do
+        channel = video_group.channels.first
+        expect(channel.instance_variable_defined? :@snippet).to be true
+      end
+    end
+  end
+
+  context 'given a video-group', :partner do
+    context 'managed by the authenticated Content Owner' do
+      let(:id) { ENV['YT_TEST_PARTNER_VIDEO_GROUP_ID'] }
+
+      specify 'the title can be retrieved' do
+        expect(video_group.title).to be_a(String)
+        expect(video_group.title).not_to be_empty
+      end
+
+      specify 'the number of videos in the group can be retrieved' do
+        expect(video_group.item_count).to be_an(Integer)
+        expect(video_group.item_count).not_to be_zero
+      end
+
+      specify '.group_items retrieves the group items' do
+        expect(video_group.group_items.count).to be_an(Integer)
+        expect(video_group.group_items.map{|g| g}).to all(be_a Yt::GroupItem)
+      end
+
+      specify '.group_items.includes(:video) eager-loads each video' do
+        item = video_group.group_items.includes(:video).first
+        expect(item.video.instance_variable_defined? :@snippet).to be true
+        expect(item.video.instance_variable_defined? :@status).to be true
+        expect(item.video.instance_variable_defined? :@statistics_set).to be true
+      end
+
+      specify '.videos loads each video' do
+        video = video_group.videos.first
+        expect(video.instance_variable_defined? :@snippet).to be true
+        expect(video.instance_variable_defined? :@status).to be true
+        expect(video.instance_variable_defined? :@statistics_set).to be true
+      end
+
+      specify '.channels loads each channel' do
+        channel = video_group.channels.first
+        expect(channel.instance_variable_defined? :@snippet).to be true
+      end
+
+      describe 'multiple reports can be retrieved at once' do
+        metrics = {views: Integer,
+          estimated_minutes_watched: Integer, comments: Integer, likes: Integer,
+          dislikes: Integer, shares: Integer, subscribers_gained: Integer,
+          subscribers_lost: Integer,
+          videos_added_to_playlists: Integer, videos_removed_from_playlists: Integer,
+          average_view_duration: Integer,
+          card_impressions: Integer, card_clicks: Integer,
+          card_click_rate: Float, card_teaser_impressions: Integer,
+          card_teaser_clicks: Integer, card_teaser_click_rate: Float,
+          average_view_percentage: Float, annotation_clicks: Integer,
+          annotation_click_through_rate: Float,
+          annotation_close_rate: Float, estimated_revenue: Float, ad_impressions: Integer,
+          monetized_playbacks: Integer}
+
+        specify 'by day, and are chronologically sorted' do
+          range = {since: 5.days.ago.to_date, until: 3.days.ago.to_date}
+          result = video_group.reports range.merge(only: metrics, by: :day)
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Date)
+            expect(result[metric].values).to all(be_a type)
+            expect(result[metric].keys.sort).to eq result[metric].keys
+          end
+        end
+
+        # NOTE: all the other filters also apply, not tested for brevity
+      end
+
+      describe 'viewer_percentage can be grouped by age group' do
+        let(:range) { {since: 1.year.ago.to_date, until: 1.week.ago.to_date} }
+        let(:keys) { range.values }
+
+        specify 'with the :by option set to :age_group' do
+          viewer_percentage = video_group.viewer_percentage range.merge by: :age_group
+          expect(viewer_percentage.keys - %w(65- 35-44 45-54 13-17 25-34 55-64 18-24)).to be_empty
+          expect(viewer_percentage.values).to all(be_instance_of Float)
+        end
+      end
+    end
+
+    context 'not managed by the authenticated Content Owner' do
+      let(:id) { 'ABExJp9gAAA' }
+
+      specify 'views cannot be retrieved' do
+        expect{video_group.views}.to raise_error Yt::Error
+      end
+    end
+  end
+end

data/spec/requests/as_content_owner/video_spec.rb

@@ -13,13 +13,15 @@ describe Yt::Video, :partner do
         it { expect{video.advertising_options_set}.not_to raise_error }
       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,
+       :estimated_minutes_watched, :average_view_duration,
+       :average_view_percentage, :ad_impressions, :monetized_playbacks,
        :annotation_clicks, :annotation_click_through_rate, :playback_based_cpm,
-       :annotation_close_rate, :earnings].each do |metric|
+       :card_impressions, :card_clicks, :card_click_rate,
+       :card_teaser_impressions, :card_teaser_clicks, :card_teaser_click_rate,
+       :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 }
@@ -88,60 +90,18 @@ describe Yt::Video, :partner do
         end
       end
 
-      {views: Integer, comments: Integer, dislikes: Integer,
-       estimated_minutes_watched: Integer, average_view_duration: Integer,
-       average_view_percentage: Float, impressions: Integer,
-       subscribers_lost: Integer, subscribers_gained: Integer, likes: Integer,
-       monetized_playbacks: Integer, earnings: Float}.each do |metric, type|
-        describe "#{metric} can be retrieved for a specific day" do
-          let(:metric) { metric }
-          let(:result) { video.public_send "#{metric}_on", date }
-
-          context 'in which the video had data' do
-            let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
-            it { expect(result).to be_a type }
-          end
-
-          context 'in the future' do
-            let(:date) { 5.days.from_now }
-            it { expect(result).to be_nil }
-          end
-        end
-      end
-
       {views: Integer, comments: Integer, likes: Integer, dislikes: Integer,
        shares: Integer, subscribers_gained: Integer, subscribers_lost: Integer,
-       favorites_added: Integer,
        videos_added_to_playlists: Integer, videos_removed_from_playlists: Integer,
        estimated_minutes_watched: Integer, average_view_duration: Integer,
-       average_view_percentage: Float, impressions: Integer,
+       average_view_percentage: Float, ad_impressions: Integer,
        monetized_playbacks: Integer, annotation_clicks: Integer,
        annotation_click_through_rate: Float, annotation_close_rate: Float,
-       earnings: Float}.each do |metric, type|
-        describe "#{metric} can be grouped by range" do
-          let(:metric) { metric }
-
-          context 'without a :by option (default)' do
-            let(:result) { video.public_send metric }
-            specify do
-              expect(result.size).to be 1
-              expect(result[:total]).to be_a type
-            end
-          end
-
-          context 'with the :by option set to :range' do
-            let(:result) { video.public_send metric, by: :range }
-            specify do
-              expect(result.size).to be 1
-              expect(result[:total]).to be_a type
-            end
-          end
-        end
-      end
-
-      {favorites_removed: Integer}.each do |metric, type|
+       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}.each do |metric, type|
         describe "#{metric} can be grouped by range" do
-          let(:id) { 'NeMlqbX2Ifg' }
           let(:metric) { metric }
 
           context 'without a :by option (default)' do
@@ -163,12 +123,14 @@ describe Yt::Video, :partner do
       end
 
       [:views, :comments, :likes, :dislikes, :shares,
-       :subscribers_gained, :subscribers_lost, :favorites_added,
+       :subscribers_gained, :subscribers_lost,
        :videos_added_to_playlists, :videos_removed_from_playlists,
        :estimated_minutes_watched, :average_view_duration,
-       :average_view_percentage, :impressions, :monetized_playbacks,
+       :average_view_percentage, :ad_impressions, :monetized_playbacks,
+       :card_impressions, :card_clicks, :card_click_rate,
+       :card_teaser_impressions, :card_teaser_clicks, :card_teaser_click_rate,
        :annotation_clicks, :annotation_click_through_rate,
-       :annotation_close_rate, :earnings].each do |metric|
+       :annotation_close_rate, :estimated_revenue].each do |metric|
         describe "#{metric} can be retrieved for a single country" do
           let(:result) { video.public_send metric, options }
 
@@ -189,6 +151,8 @@ describe Yt::Video, :partner do
       end
 
       [:views, :annotation_clicks, :annotation_click_through_rate,
+       :card_impressions, :card_clicks, :card_click_rate,
+       :card_teaser_impressions, :card_teaser_clicks, :card_teaser_click_rate,
        :annotation_close_rate].each do |metric|
         describe "#{metric} can be retrieved for a single country" do
           let(:result) { video.public_send metric, options }
@@ -210,15 +174,18 @@ describe Yt::Video, :partner do
       end
 
       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,
+          card_impressions: Integer, card_clicks: Integer,
+          card_click_rate: Float, card_teaser_impressions: Integer,
+          card_teaser_clicks: Integer, card_teaser_click_rate: Float,
           annotation_click_through_rate: Float,
-          annotation_close_rate: Float, earnings: Float, impressions: Integer,
+          annotation_close_rate: Float, estimated_revenue: Float, ad_impressions: Integer,
           monetized_playbacks: Integer}
 
         specify 'by day' do
@@ -255,24 +222,24 @@ describe Yt::Video, :partner do
         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 = video.earnings range.merge by: :day
-          expect(earnings.keys).to eq range.values
+          estimated_revenue = video.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 = video.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 = video.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
 
@@ -383,10 +350,31 @@ describe Yt::Video, :partner do
 
       describe 'views can be grouped by device type' do
         let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+        let(:keys) { Yt::Collections::Reports::DEVICE_TYPES.keys }
 
         specify 'with the :by option set to :device_type' do
           views = video.views range.merge by: :device_type
-          expect(views.keys).to all(be_instance_of Symbol)
+          expect(views.keys - keys).to be_empty
+          expect(views.values).to all(be_an Integer)
+        end
+      end
+
+      describe 'views can be grouped by operating system' do
+        let(:keys) { Yt::Collections::Reports::OPERATING_SYSTEMS.keys }
+
+        specify 'with the :by option set to :operating_system' do
+          views = video.views by: :operating_system
+          expect(views.keys - keys).to be_empty
+          expect(views.values).to all(be_an Integer)
+        end
+      end
+
+      describe 'views can be grouped by YouTube product' do
+        let(:keys) { Yt::Collections::Reports::YOUTUBE_PRODUCTS.keys }
+
+        specify 'with the :by option set to :youtube_product' do
+          views = video.views by: :youtube_product
+          expect(views.keys - keys).to be_empty
           expect(views.values).to all(be_an Integer)
         end
       end
@@ -423,33 +411,14 @@ describe Yt::Video, :partner do
         end
       end
 
-      describe 'uniques can be retrieved for a single US state' do
-        let(:state_code) { 'NY' }
-        let(:result) { video.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 }
+      describe 'views can be grouped by subscribed statuses' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+        let(:keys) { Yt::Collections::Reports::SUBSCRIBED_STATUSES.keys }
 
-        specify 'with the :by option set to :day' do
-          uniques = video.uniques range.merge by: :day
-          expect(uniques.keys).to eq range.values
+        specify 'with the :by option set to subscribed statuses' do
+          views = video.views range.merge by: :subscribed_status
+          expect(views.keys - keys).to be_empty
+          expect(views.values).to all(be_an Integer)
         end
       end
 
@@ -621,49 +590,6 @@ describe Yt::Video, :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
-          favorites_added = video.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: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
-
-        specify 'with the :by option set to :country' do
-          favorites_added = video.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 '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 = video.favorites_removed range.merge by: :day
-          expect(favorites_removed.keys).to eq range.values
-        end
-      end
-
-      # TODO: Remove "removed favorites" since it’s deprecated!
-      # describe 'removed favorites can be grouped by country' do
-      #   let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
-      #
-      #   specify 'with the :by option set to :country' do
-      #     favorites_removed = video.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 'estimated minutes watched can be retrieved for a single US state' do
         let(:state_code) { 'NY' }
         let(:minutes) { video.estimated_minutes_watched since: date, by: by, in: location }
@@ -928,24 +854,24 @@ describe Yt::Video, :partner do
         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 = video.impressions range.merge by: :day
-          expect(impressions.keys).to eq range.values
+          ad_impressions = video.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_VIDEO_DATE']} }
 
         specify 'with the :by option set to :country' do
-          impressions = video.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 = video.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
 
@@ -1282,4 +1208,4 @@ describe Yt::Video, :partner do
       end
     end
   end
-end
+end