yt 0.22.0 → 0.22.1

data/spec/requests/as_content_owner/playlist_spec.rb

@@ -22,6 +22,40 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'views can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:views) { playlist.views 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(views.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(views.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(views.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(views.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'views can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -124,6 +158,28 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'views 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
+          views = playlist.views range.merge by: :country
+          expect(views.keys).to all(be_a String)
+          expect(views.keys.map(&:length).uniq).to eq [2]
+          expect(views.values).to all(be_an Integer)
+        end
+      end
+
+      describe 'views can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          views = playlist.views range.merge by: :state
+          expect(views.keys).to all(be_a String)
+          expect(views.keys.map(&:length).uniq).to eq [2]
+          expect(views.values).to all(be_an Integer)
+        end
+      end
+
       describe 'estimated minutes watched can be retrieved for a specific day' do
         context 'in which the playlist was viewed' do
           let(:minutes) { playlist.estimated_minutes_watched_on ENV['YT_TEST_PARTNER_PLAYLIST_DATE']}
@@ -136,6 +192,40 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'estimated minutes watched can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:estimated_minutes_watched) { playlist.estimated_minutes_watched 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(estimated_minutes_watched.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(estimated_minutes_watched.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(estimated_minutes_watched.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(estimated_minutes_watched.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'estimated minutes watched can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -238,6 +328,28 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'estimated minutes watched 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
+          minutes = playlist.estimated_minutes_watched range.merge by: :country
+          expect(minutes.keys).to all(be_a String)
+          expect(minutes.keys.map(&:length).uniq).to eq [2]
+          expect(minutes.values).to all(be_a Float)
+        end
+      end
+
+      describe 'estimated minutes watched can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          minutes = playlist.estimated_minutes_watched range.merge by: :state
+          expect(minutes.keys).to all(be_a String)
+          expect(minutes.keys.map(&:length).uniq).to eq [2]
+          expect(minutes.values).to all(be_a Float)
+        end
+      end
+
       describe 'viewer percentage can be retrieved for a range of days' do
         let(:viewer_percentage) { playlist.viewer_percentage since: 1.year.ago, until: 10.days.ago}
         it { expect(viewer_percentage).to be_a Hash }
@@ -301,6 +413,40 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'average view duration can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:average_view_duration) { playlist.average_view_duration 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(average_view_duration.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(average_view_duration.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(average_view_duration.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(average_view_duration.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'average view duration can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -346,6 +492,28 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'average view duration 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
+          duration = playlist.average_view_duration range.merge by: :country
+          expect(duration.keys).to all(be_a String)
+          expect(duration.keys.map(&:length).uniq).to eq [2]
+          expect(duration.values).to all(be_a Float)
+        end
+      end
+
+      describe 'average view duration can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          duration = playlist.average_view_duration range.merge by: :state
+          expect(duration.keys).to all(be_a String)
+          expect(duration.keys.map(&:length).uniq).to eq [2]
+          expect(duration.values).to all(be_a Float)
+        end
+      end
+
       describe 'playlist starts can be retrieved for a specific day' do
         context 'in which the playlist was viewed' do
           let(:playlist_starts) { playlist.playlist_starts_on ENV['YT_TEST_PARTNER_PLAYLIST_DATE']}
@@ -358,6 +526,40 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'playlist starts can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:playlist_starts) { playlist.playlist_starts 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(playlist_starts.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(playlist_starts.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(playlist_starts.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(playlist_starts.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'playlist starts can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -403,6 +605,28 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'playlist starts 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
+          starts = playlist.playlist_starts range.merge by: :country
+          expect(starts.keys).to all(be_a String)
+          expect(starts.keys.map(&:length).uniq).to eq [2]
+          expect(starts.values).to all(be_an Integer)
+        end
+      end
+
+      describe 'playlist starts can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          starts = playlist.playlist_starts range.merge by: :state
+          expect(starts.keys).to all(be_a String)
+          expect(starts.keys.map(&:length).uniq).to eq [2]
+          expect(starts.values).to all(be_an Integer)
+        end
+      end
+
       describe 'average time in playlist can be retrieved for a specific day' do
         context 'in which the playlist was viewed' do
           let(:average_time_in_playlist) { playlist.average_time_in_playlist_on ENV['YT_TEST_PARTNER_PLAYLIST_DATE']}
@@ -415,6 +639,40 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'average time in playlist can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:average_time_in_playlist) { playlist.average_time_in_playlist 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(average_time_in_playlist.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(average_time_in_playlist.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(average_time_in_playlist.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(average_time_in_playlist.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'average time in playlist can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -460,6 +718,28 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'average time in playlist 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
+          time = playlist.average_time_in_playlist range.merge by: :country
+          expect(time.keys).to all(be_a String)
+          expect(time.keys.map(&:length).uniq).to eq [2]
+          expect(time.values).to all(be_a Float)
+        end
+      end
+
+      describe 'average time in playlist can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          time = playlist.average_time_in_playlist range.merge by: :state
+          expect(time.keys).to all(be_a String)
+          expect(time.keys.map(&:length).uniq).to eq [2]
+          expect(time.values).to all(be_a Float)
+        end
+      end
+
       describe 'views per playlist start can be retrieved for a specific day' do
         context 'in which the playlist was viewed' do
           let(:views_per_playlist_start) { playlist.views_per_playlist_start_on ENV['YT_TEST_PARTNER_PLAYLIST_DATE']}
@@ -472,6 +752,40 @@ describe Yt::Playlist, :partner do
         end
       end
 
+      describe 'views per playlist start can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:views_per_playlist_start) { playlist.views_per_playlist_start 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(views_per_playlist_start.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(views_per_playlist_start.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(views_per_playlist_start.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(views_per_playlist_start.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'views per playlist start can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -516,6 +830,28 @@ describe Yt::Playlist, :partner do
           expect(views_per_playlist_start.keys).to eq range.values
         end
       end
+
+      describe 'views per playlist start 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
+          views = playlist.views_per_playlist_start range.merge by: :country
+          expect(views.keys).to all(be_a String)
+          expect(views.keys.map(&:length).uniq).to eq [2]
+          expect(views.values).to all(be_a Float)
+        end
+      end
+
+      describe 'views per playlist start can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          views = playlist.views_per_playlist_start range.merge by: :state
+          expect(views.keys).to all(be_a String)
+          expect(views.keys.map(&:length).uniq).to eq [2]
+          expect(views.values).to all(be_a Float)
+        end
+      end
     end
 
     context 'not managed by the authenticated Content Owner' do

data/spec/requests/as_content_owner/video_spec.rb

@@ -25,6 +25,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'earnings can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:earnings) { video.earnings 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(earnings.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 }
+          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(earnings.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] }
+          end
+        end
+      end
+
       describe 'earnings can be retrieved for a range of days' do
         let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
 
@@ -63,6 +97,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'earnings 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)
+        end
+      end
+
       describe 'views can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:views) { video.views_on 5.days.ago}
@@ -75,6 +120,41 @@ describe Yt::Video, :partner do
         end
       end
 
+
+      describe 'views can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:views) { video.views 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(views.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(views.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(views.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(views.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'views can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -141,7 +221,7 @@ describe Yt::Video, :partner do
       end
 
       describe 'views can be grouped by embedded player location' do
-        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE'], until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :embedded_player_location' do
           views = video.views range.merge by: :embedded_player_location
@@ -168,6 +248,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'views 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
+          views = video.views range.merge by: :country
+          expect(views.keys).to all(be_a String)
+          expect(views.keys.map(&:length).uniq).to eq [2]
+          expect(views.values).to all(be_an Integer)
+        end
+      end
+
+      describe 'views can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          views = video.views range.merge by: :state
+          expect(views.keys).to all(be_a String)
+          expect(views.keys.map(&:length).uniq).to eq [2]
+          expect(views.values).to all(be_an Integer)
+        end
+      end
+
       describe 'comments can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:comments) { video.comments_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -180,6 +282,41 @@ describe Yt::Video, :partner do
         end
       end
 
+
+      describe 'comments can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:comments) { video.comments 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(comments.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(comments.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(comments.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(comments.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'comments can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -225,6 +362,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'comments can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          comments = video.comments range.merge by: :country
+          expect(comments.keys).to all(be_a String)
+          expect(comments.keys.map(&:length).uniq).to eq [2]
+          expect(comments.values).to all(be_an Integer)
+        end
+      end
+
       describe 'likes can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:likes) { video.likes_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -237,6 +385,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'likes can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:likes) { video.likes 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(likes.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(likes.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(likes.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(likes.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'likes can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -282,6 +464,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'likes can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          likes = video.likes range.merge by: :country
+          expect(likes.keys).to all(be_a String)
+          expect(likes.keys.map(&:length).uniq).to eq [2]
+          expect(likes.values).to all(be_an Integer)
+        end
+      end
+
       describe 'dislikes can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:dislikes) { video.dislikes_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -294,6 +487,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'dislikes can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:dislikes) { video.dislikes 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(dislikes.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(dislikes.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(dislikes.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(dislikes.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'dislikes can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -339,9 +566,21 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'dislikes can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          dislikes = video.dislikes range.merge by: :country
+          expect(dislikes.keys).to all(be_a String)
+          expect(dislikes.keys.map(&:length).uniq).to eq [2]
+          expect(dislikes.values).to all(be_an Integer)
+        end
+      end
+
       describe 'shares can be retrieved for a specific day' do
         context 'in which the video was partnered' do
-          let(:shares) { video.shares_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
+          let(:date) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 95 }
+          let(:shares) { video.shares_on date }
           it { expect(shares).to be_an Integer }
         end
 
@@ -351,6 +590,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'shares can be retrieved for a single country' do
+        let(:country_code) { 'PT' }
+        let(:shares) { video.shares since: date, by: by, in: location }
+        let(:date) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 95 }
+
+        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(shares.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(shares.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(shares.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(shares.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'shares can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -396,6 +669,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'shares can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          shares = video.shares range.merge by: :country
+          expect(shares.keys).to all(be_a String)
+          expect(shares.keys.map(&:length).uniq).to eq [2]
+          expect(shares.values).to all(be_an Integer)
+        end
+      end
+
       describe 'gained subscribers can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:subscribers_gained) { video.subscribers_gained_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -408,6 +692,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'gained subscribers can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:subscribers_gained) { video.subscribers_gained 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(subscribers_gained.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(subscribers_gained.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(subscribers_gained.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(subscribers_gained.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'gained subscribers can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -453,6 +771,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'gained subscribers can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          subscribers_gained = video.subscribers_gained range.merge by: :country
+          expect(subscribers_gained.keys).to all(be_a String)
+          expect(subscribers_gained.keys.map(&:length).uniq).to eq [2]
+          expect(subscribers_gained.values).to all(be_an Integer)
+        end
+      end
+
       describe 'lost subscribers can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:subscribers_lost) { video.subscribers_lost_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -465,6 +794,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'lost subscribers can be retrieved for a single country' do
+        let(:country_code) { 'BR' }
+        let(:subscribers_lost) { video.subscribers_lost 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(subscribers_lost.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(subscribers_lost.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(subscribers_lost.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(subscribers_lost.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'lost subscribers can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -510,6 +873,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'lost subscribers can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          subscribers_lost = video.subscribers_lost range.merge by: :country
+          expect(subscribers_lost.keys).to all(be_a String)
+          expect(subscribers_lost.keys.map(&:length).uniq).to eq [2]
+          expect(subscribers_lost.values).to all(be_an Integer)
+        end
+      end
+
       describe 'added favorites can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:favorites_added) { video.favorites_added_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -522,6 +896,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'favorites added can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:favorites_added) { video.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 retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -567,6 +975,17 @@ describe Yt::Video, :partner do
         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 retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:favorites_removed) { video.favorites_removed_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -579,6 +998,41 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'favorites removed can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:favorites_removed) { video.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
+
+        # TODO: Remove "removed favorites" since it’s deprecated!
+        # 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 retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -625,6 +1079,18 @@ describe Yt::Video, :partner do
         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 specific day' do
         context 'in which the video was partnered' do
           let(:estimated_minutes_watched) { video.estimated_minutes_watched_on 5.days.ago}
@@ -637,6 +1103,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'estimated minutes watched can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:estimated_minutes_watched) { video.estimated_minutes_watched 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(estimated_minutes_watched.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(estimated_minutes_watched.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(estimated_minutes_watched.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(estimated_minutes_watched.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'estimated minutes watched can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -730,6 +1230,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'estimated minutes watched 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
+          minutes = video.estimated_minutes_watched range.merge by: :country
+          expect(minutes.keys).to all(be_a String)
+          expect(minutes.keys.map(&:length).uniq).to eq [2]
+          expect(minutes.values).to all(be_a Float)
+        end
+      end
+
+      describe 'estimated minutes watched can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          minutes = video.estimated_minutes_watched range.merge by: :state
+          expect(minutes.keys).to all(be_a String)
+          expect(minutes.keys.map(&:length).uniq).to eq [2]
+          expect(minutes.values).to all(be_a Float)
+        end
+      end
+
       describe 'average view duration can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:average_view_duration) { video.average_view_duration_on 5.days.ago}
@@ -742,6 +1264,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'average view duration can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:average_view_duration) { video.average_view_duration 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(average_view_duration.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(average_view_duration.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(average_view_duration.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(average_view_duration.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'average view duration can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -787,6 +1343,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'average view duration 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
+          duration = video.average_view_duration range.merge by: :country
+          expect(duration.keys).to all(be_a String)
+          expect(duration.keys.map(&:length).uniq).to eq [2]
+          expect(duration.values).to all(be_a Float)
+        end
+      end
+
+      describe 'average view duration can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          duration = video.average_view_duration range.merge by: :state
+          expect(duration.keys).to all(be_a String)
+          expect(duration.keys.map(&:length).uniq).to eq [2]
+          expect(duration.values).to all(be_a Float)
+        end
+      end
+
       describe 'average view percentage can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:average_view_percentage) { video.average_view_percentage_on 5.days.ago}
@@ -799,6 +1377,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'average view percentage can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:average_view_percentage) { video.average_view_percentage 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(average_view_percentage.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(average_view_percentage.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(average_view_percentage.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(average_view_percentage.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'average view percentage can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -844,6 +1456,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'average view percentage 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
+          percentage = video.average_view_percentage range.merge by: :country
+          expect(percentage.keys).to all(be_a String)
+          expect(percentage.keys.map(&:length).uniq).to eq [2]
+          expect(percentage.values).to all(be_a Float)
+        end
+      end
+
+      describe 'average view percentage can be grouped by state' do
+        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          percentage = video.average_view_percentage range.merge by: :state
+          expect(percentage.keys).to all(be_a String)
+          expect(percentage.keys.map(&:length).uniq).to eq [2]
+          expect(percentage.values).to all(be_a Float)
+        end
+      end
+
       describe 'impressions can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:impressions) { video.impressions_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -856,6 +1490,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'impressions can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:impressions) { video.impressions 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(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 }
+          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(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] }
+          end
+        end
+      end
+
       describe 'impressions can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -901,6 +1569,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe '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)
+        end
+      end
+
       describe 'monetized playbacks can be retrieved for a specific day' do
         context 'in which the video was partnered' do
           let(:monetized_playbacks) { video.monetized_playbacks_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
@@ -913,6 +1592,40 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'monetized playbacks can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:monetized_playbacks) { video.monetized_playbacks 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(monetized_playbacks.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(monetized_playbacks.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(monetized_playbacks.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(monetized_playbacks.keys).to eq [country_code] }
+          end
+        end
+      end
+
       describe 'monetized playbacks can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -958,6 +1671,17 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'monetized playbacks can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          playbacks = video.monetized_playbacks range.merge by: :country
+          expect(playbacks.keys).to all(be_a String)
+          expect(playbacks.keys.map(&:length).uniq).to eq [2]
+          expect(playbacks.values).to all(be_an Integer)
+        end
+      end
+
       describe 'annotation clicks can be retrieved for a range of days' do
         let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
         let(:date_to) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5 }
@@ -995,6 +1719,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'annotation clicks can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          clicks = video.annotation_clicks range.merge by: :country
+          expect(clicks.keys).to all(be_a String)
+          expect(clicks.keys.map(&:length).uniq).to eq [2]
+          expect(clicks.values).to all(be_an Integer)
+        end
+      end
+
+      describe 'annotation clicks can be grouped by state' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :state' do
+          clicks = video.annotation_clicks range.merge by: :state
+          expect(clicks.keys).to all(be_a String)
+          expect(clicks.keys.map(&:length).uniq).to eq [2]
+          expect(clicks.values).to all(be_an Integer)
+        end
+      end
+
       describe 'annotation click-through rate can be retrieved for a range of days' do
         let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
         let(:date_to) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5 }
@@ -1032,6 +1778,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'annotation click-through rate can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          rate = video.annotation_click_through_rate range.merge by: :country
+          expect(rate.keys).to all(be_a String)
+          expect(rate.keys.map(&:length).uniq).to eq [2]
+          expect(rate.values).to all(be_a Float)
+        end
+      end
+
+      describe 'annotation click-through rate can be grouped by state' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :state' do
+          rate = video.annotation_click_through_rate range.merge by: :state
+          expect(rate.keys).to all(be_a String)
+          expect(rate.keys.map(&:length).uniq).to eq [2]
+          expect(rate.values).to all(be_a Float)
+        end
+      end
+
       describe 'annotation close rate can be retrieved for a range of days' do
         let(:date) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
         let(:date_to) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5 }
@@ -1069,6 +1837,28 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'annotation close rate can be grouped by country' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :country' do
+          rate = video.annotation_close_rate range.merge by: :country
+          expect(rate.keys).to all(be_a String)
+          expect(rate.keys.map(&:length).uniq).to eq [2]
+          expect(rate.values).to all(be_a Float)
+        end
+      end
+
+      describe 'annotation close rate can be grouped by state' do
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
+
+        specify 'with the :by option set to :state' do
+          rate = video.annotation_close_rate range.merge by: :state
+          expect(rate.keys).to all(be_a String)
+          expect(rate.keys.map(&:length).uniq).to eq [2]
+          expect(rate.values).to all(be_a Float)
+        end
+      end
+
       describe 'viewer percentage can be retrieved for a range of days' do
         let(:viewer_percentage) { video.viewer_percentage since: 1.year.ago, until: 10.days.ago}
         it { expect(viewer_percentage).to be_a Hash }