yt 0.22.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6287e851c03a8285e094efa577c17f0a9ca6204
-  data.tar.gz: 0da6d402a9062dc8cc9e1759636d691f505eae13
+  metadata.gz: 5756c73d548ca942b1ea77046632204c4bd571c0
+  data.tar.gz: 3dc5604dc683f5207397a8438a89753e11f77104
 SHA512:
-  metadata.gz: f345bff512092cf0ff25bb9223fccbe1555fba58a71bf5711312b870322925a1335c929a88e84d3c2317cd69883fcb50b80d89a102b3b64ffc96475f6064185a
-  data.tar.gz: 9544b7238eca631c1f933a9789ff88480fb57025126048c7e1bc07a5d0427ec191d5bfb3e0064c41c8c7c22a14287012a0acb0e1621cafff10d67bece4d3aa2d
+  metadata.gz: 6db2497ab1f4e7fa497d1dcaa5ec259a8623e09b03758ad1db84009a06a7c40bf27e1abcb70118cf5e6e475b63e4004883bde843fd09539f48ddad79b55e1481
+  data.tar.gz: 4f559c21aa27f9feb93ccfa2eaefc05530c5dc0956c3b7b52eae95cfb09296e4f1eba4585bc9d4f54c92bfdf16db97d74cce7c305fec6cd62c595aa5eba9a7a5

data/CHANGELOG.md

@@ -6,6 +6,12 @@ For more information about changelogs, check
 [Keep a Changelog](http://keepachangelog.com) and
 [Vandamme](http://tech-angels.github.io/vandamme).
 
+## 0.22.1 - 2015-05-13
+
+* [FEATURE] New `by: :country` option for channel, video and playlist reports
+* [FEATURE] New `by: :state` option for channel, video and playlist reports
+* [FEATURE] New `:in` option to limit reports to a country
+
 ## 0.22.0 - 2015-04-30
 
 **How to upgrade**

data/README.md

@@ -41,7 +41,7 @@ To install on your system, run
 
 To use inside a bundled Ruby project, add this line to the Gemfile:
 
-    gem 'yt', '~> 0.22.0'
+    gem 'yt', '~> 0.22.1'
 
 Since the gem follows [Semantic Versioning](http://semver.org),
 indicating the full version in your Gemfile (~> *major*.*minor*.*patch*)

data/lib/yt/associations/has_reports.rb

@@ -22,7 +22,7 @@ module Yt
       #     for the entire time-range (under the key +:total+).
       #   @example Get the $1 for the whole last week:
       #     resource.$1 since: 2.weeks.ago, until: 1.week.ago, by: :range
-      #     # => {Wed, 8 May 2014..Tue, 14 May 2014 => 564.0,}
+      #     # => {total: 564.0}
       #   @macro report
 
       # @!macro [new] report_by_day
@@ -146,28 +146,31 @@ module Yt
         define_method metric do |options = {}|
           from = options[:since] || options[:from] || (metric == :viewer_percentage ? 3.months.ago : 5.days.ago)
           to = options[:until] || options[:to] || (metric == :viewer_percentage ? Date.today : 1.day.ago)
+          location = options[:in]
+          country = location.is_a?(Hash) ? location[:country] : location
+
           range = Range.new *[from, to].map(&:to_date)
           dimension = options[:by] || (metric == :viewer_percentage ? :gender_age_group : :day)
 
-          ivar = instance_variable_get "@#{metric}_#{dimension}"
-          instance_variable_set "@#{metric}_#{dimension}", ivar || {}
+          ivar = instance_variable_get "@#{metric}_#{dimension}_#{country}"
+          instance_variable_set "@#{metric}_#{dimension}_#{country}", ivar || {}
 
           case dimension
           when :day
             Hash[*range.flat_map do |date|
-              [date, instance_variable_get("@#{metric}_#{dimension}")[date] ||= send("range_#{metric}", range, dimension)[date]]
+              [date, instance_variable_get("@#{metric}_#{dimension}_#{country}")[date] ||= send("range_#{metric}", range, dimension, country)[date]]
             end]
           else
-            instance_variable_get("@#{metric}_#{dimension}")[range] ||= send("range_#{metric}", range, dimension)
+            instance_variable_get("@#{metric}_#{dimension}_#{country}")[range] ||= send("range_#{metric}", range, dimension, country)
           end
         end
       end
 
       def define_range_metric_method(metric, type)
-        define_method "range_#{metric}" do |date_range, dimension|
-          ivar = instance_variable_get "@range_#{metric}_#{dimension}"
-          instance_variable_set "@range_#{metric}_#{dimension}", ivar || {}
-          instance_variable_get("@range_#{metric}_#{dimension}")[date_range] ||= send("all_#{metric}").within date_range, dimension, type
+        define_method "range_#{metric}" do |date_range, dimension, country|
+          ivar = instance_variable_get "@range_#{metric}_#{dimension}_#{country}"
+          instance_variable_set "@range_#{metric}_#{dimension}_#{country}", ivar || {}
+          instance_variable_get("@range_#{metric}_#{dimension}_#{country}")[date_range] ||= send("all_#{metric}").within date_range, country, dimension, type
         end
         private "range_#{metric}"
       end

data/lib/yt/collections/reports.rb

@@ -13,6 +13,8 @@ module Yt
         hash[:video] = {name: 'video', parse: ->(video_id, value) { [Yt::Video.new(id: video_id, auth: @auth), value] } }
         hash[:playlist] = {name: 'playlist', parse: ->(playlist_id, value) { [Yt::Playlist.new(id: playlist_id, auth: @auth), value] } }
         hash[:device_type] = {name: 'deviceType', parse: ->(type, value) { [type.downcase.to_sym, value] } }
+        hash[:country] = {name: 'country', parse: ->(country_code, *values) { [country_code, values.last]  } }
+        hash[:state] = {name: 'province', parse: ->(country_and_state_code, *values) { [country_and_state_code[3..-1], values.last]  } }
         hash[:gender_age_group] = {name: 'gender,ageGroup', parse: ->(gender, *values) { [gender.downcase.to_sym, *values] }}
         hash[:gender] = {name: 'gender', parse: ->(gender, value) { [gender.downcase.to_sym, value] } }
         hash[:age_group] = {name: 'ageGroup', parse: ->(age_group, value) { [age_group[3..-1], value] } }
@@ -48,9 +50,10 @@ module Yt
 
       attr_writer :metric
 
-      def within(days_range, dimension, type, try_again = true)
+      def within(days_range, country, dimension, type, try_again = true)
         @days_range = days_range
         @dimension = dimension
+        @country = country
         if dimension == :gender_age_group # array of array
           Hash.new{|h,k| h[k] = Hash.new 0.0}.tap do |hash|
             each{|gender, age_group, value| hash[gender][age_group[3..-1]] = value}
@@ -101,6 +104,8 @@ module Yt
           params['max-results'] = 25 if @dimension == :embedded_player_location
           params['max-results'] = 25 if @dimension == :related_video
           params['sort'] = "-#{@metric.to_s.camelize(:lower)}" if @dimension.in? [:video, :playlist, :embedded_player_location, :related_video]
+          params[:filters] = ((params[:filters] || '').split(';') + ["country==US"]).compact.uniq.join(';') if @dimension == :state
+          params[:filters] = ((params[:filters] || '').split(';') + ["country==#{@country}"]).compact.uniq.join(';') if @country
           params[:filters] = ((params[:filters] || '').split(';') + ['isCurated==1']).compact.uniq.join(';') if @dimension == :playlist
           params[:filters] = ((params[:filters] || '').split(';') + ['insightPlaybackLocationType==EMBEDDED']).compact.uniq.join(';') if @dimension == :embedded_player_location
           params[:filters] = ((params[:filters] || '').split(';') + ['insightTrafficSourceType==RELATED_VIDEO']).compact.uniq.join(';') if @dimension == :related_video

data/lib/yt/version.rb

@@ -1,3 +1,3 @@
 module Yt
-  VERSION = '0.22.0'
+  VERSION = '0.22.1'
 end

data/spec/requests/as_content_owner/channel_spec.rb

@@ -35,6 +35,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'earnings can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:earnings) { channel.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) { 4.days.ago }
 
@@ -81,6 +115,17 @@ describe Yt::Channel, :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 = 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)
+        end
+      end
+
       describe 'views can be retrieved for a specific day' do
         context 'in which the channel was partnered' do
           let(:views) { channel.views_on 5.days.ago}
@@ -93,6 +138,57 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'views can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:views) { channel.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 single US state' do
+      #   let(:state_code) { 'TX' }
+      #
+      #   specify 'with the :in option set to {state: state_code}' do
+      #     require 'pry'; binding.pry; true;
+      #     views = channel.views in: {state: state_code}
+      #
+      #     expect(views.keys).to eq [state_code]
+      #   end
+      #
+      #   specify 'with the :in option set to {country: "US", state: state_code}' do
+      #     views = channel.views by: :state, in: {country: "US", state: state_code}
+      #     p views
+      #     expect(views.keys).to eq [state_code]
+      #   end
+      # end
+
       describe 'views can be retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -204,6 +300,28 @@ describe Yt::Channel, :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 = channel.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 = channel.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 channel was partnered' do
           let(:comments) { channel.comments_on 5.days.ago}
@@ -216,6 +334,40 @@ describe Yt::Channel, :partner do
         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 }
+        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(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 }
 
@@ -261,6 +413,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'comments 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
+          comments = channel.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 channel was partnered' do
           let(:likes) { channel.likes_on 5.days.ago}
@@ -273,6 +436,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'likes can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:likes) { channel.likes 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(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 }
 
@@ -318,6 +515,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'likes 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
+          likes = channel.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 channel was partnered' do
           let(:dislikes) { channel.dislikes_on 5.days.ago}
@@ -330,6 +538,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'dislikes can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:dislikes) { channel.dislikes 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(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 }
 
@@ -375,9 +617,21 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'dislikes 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
+          dislikes = channel.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 channel was partnered' do
-          let(:shares) { channel.shares_on ENV['YT_TEST_PARTNER_VIDEO_DATE']}
+          let(:date) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 95 }
+          let(:shares) { channel.shares_on date }
           it { expect(shares).to be_an Integer }
         end
 
@@ -387,6 +641,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'shares can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:shares) { channel.shares 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(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 }
 
@@ -432,6 +720,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'shares 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
+          shares = channel.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 channel was partnered' do
           let(:subscribers_gained) { channel.subscribers_gained_on 5.days.ago}
@@ -444,6 +743,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'gained subscribers can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:subscribers_gained) { channel.subscribers_gained 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(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 }
 
@@ -489,6 +822,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'gained subscribers 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
+          subscribers_gained = channel.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 channel was partnered' do
           let(:subscribers_lost) { channel.subscribers_lost_on 5.days.ago}
@@ -501,6 +845,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'lost subscribers can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:subscribers_lost) { channel.subscribers_lost 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(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 }
 
@@ -546,6 +924,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'lost subscribers 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
+          subscribers_lost = channel.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 channel was partnered' do
           let(:favorites_added) { channel.favorites_added_on 5.days.ago}
@@ -558,6 +947,40 @@ 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) { 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(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 }
 
@@ -603,6 +1026,17 @@ describe Yt::Channel, :partner do
         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 'removed favorites can be retrieved for a specific day' do
         context 'in which the channel was partnered' do
           let(:favorites_removed) { channel.favorites_removed_on 5.days.ago}
@@ -615,6 +1049,40 @@ describe Yt::Channel, :partner do
         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) { 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(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 retrieved for a range of days' do
         let(:date) { 4.days.ago }
 
@@ -660,6 +1128,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'removed 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_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 'estimated minutes watched can be retrieved for a specific day' do
         context 'in which the channel was partnered' do
           let(:estimated_minutes_watched) { channel.estimated_minutes_watched_on 5.days.ago}
@@ -672,6 +1151,40 @@ describe Yt::Channel, :partner do
         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 }
+        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 }
 
@@ -783,6 +1296,28 @@ describe Yt::Channel, :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 = channel.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 = channel.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 channel was partnered' do
           let(:average_view_duration) { channel.average_view_duration_on 5.days.ago}
@@ -795,6 +1330,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'average view duration can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:average_view_duration) { channel.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 }
 
@@ -840,6 +1409,28 @@ describe Yt::Channel, :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 = channel.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 = channel.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 channel was partnered' do
           let(:average_view_percentage) { channel.average_view_percentage_on 5.days.ago}
@@ -852,6 +1443,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'average view percentage can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:average_view_percentage) { channel.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 }
 
@@ -897,6 +1522,28 @@ describe Yt::Channel, :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 = channel.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 = channel.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 channel was partnered' do
           let(:impressions) { channel.impressions_on 20.days.ago}
@@ -909,6 +1556,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'impressions can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:impressions) { channel.impressions 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(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 }
 
@@ -954,6 +1635,17 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'impressions 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
+          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)
+        end
+      end
+
       describe 'monetized playbacks can be retrieved for a specific day' do
         context 'in which the channel was partnered' do
           let(:monetized_playbacks) { channel.monetized_playbacks_on 20.days.ago}
@@ -966,6 +1658,40 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'monetized playbacks can be retrieved for a single country' do
+        let(:country_code) { 'US' }
+        let(:monetized_playbacks) { channel.monetized_playbacks 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(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 }
 
@@ -1011,6 +1737,51 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'monetized playbacks 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
+          playbacks = channel.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 single country' do
+        let(:country_code) { 'US' }
+        let(:annotation_clicks) { channel.annotation_clicks 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(annotation_clicks.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(annotation_clicks.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(annotation_clicks.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(annotation_clicks.keys).to eq [country_code] }
+          end
+        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 }
@@ -1048,6 +1819,62 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'annotation clicks 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
+          clicks = channel.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: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          clicks = channel.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 single country' do
+        let(:country_code) { 'US' }
+        let(:annotation_click_through_rate) { channel.annotation_click_through_rate 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(annotation_click_through_rate.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(annotation_click_through_rate.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(annotation_click_through_rate.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(annotation_click_through_rate.keys).to eq [country_code] }
+          end
+        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 }
@@ -1085,6 +1912,62 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'annotation click-through rate 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
+          rate = channel.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: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          rate = channel.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 single country' do
+        let(:country_code) { 'US' }
+        let(:annotation_close_rate) { channel.annotation_close_rate 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(annotation_close_rate.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(annotation_close_rate.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(annotation_close_rate.keys).to eq [country_code] }
+          end
+
+          context 'with the :in option set to {country: country code}' do
+            let(:location) { {country: country_code} }
+            it { expect(annotation_close_rate.keys).to eq [country_code] }
+          end
+        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 }
@@ -1122,6 +2005,43 @@ describe Yt::Channel, :partner do
         end
       end
 
+      describe 'annotation close rate 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
+          rate = channel.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: 4.days.ago, until: 3.days.ago} }
+
+        specify 'with the :by option set to :state' do
+          rate = channel.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 single country' do
+        let(:country_code) { 'US' }
+        let(:viewer_percentage) { channel.viewer_percentage in: location }
+
+        context 'with the :in option set to the country code' do
+          let(:location) { country_code }
+          it { expect(viewer_percentage.keys).to match_array [:female, :male] }
+        end
+
+        context 'with the :in option set to {country: country code}' do
+          let(:location) { {country: country_code} }
+          it { expect(viewer_percentage.keys).to match_array [:female, :male] }
+        end
+      end
+
       describe 'viewer percentage can be retrieved for a range of days' do
         let(:viewer_percentage) { channel.viewer_percentage since: 1.year.ago, until: 10.days.ago}
         it { expect(viewer_percentage).to be_a Hash }