yt 0.23.0 → 0.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 684b3fcaa4ab0f5f3ad32ec7296601f71e549e4a
-  data.tar.gz: f6026fcc1c013dd12ef05c53fe1e4ff2964fb4a8
+  metadata.gz: 004e3876d58c7c369d0e2a215d41234ad37f7b57
+  data.tar.gz: c4cc02ed5cf02d23858e7de931d5bc1bea63c932
 SHA512:
-  metadata.gz: c050616344cebcb10223924565f11d1c00f6d06900afb7c955e8a5ed6f999c96c3af6860402007b433769a1d5ddcdbae221ad4f93de8e35f18e2b0924d7dc62b
-  data.tar.gz: e3d73c055a6cd8a2ffba67fc90066b0e412e7aa2a2c968fbf349892e18ade346b1758d73bf96d33b73033cfacef87b7846bffc94bd26e9e863020ed75390d807
+  metadata.gz: 691d6757cb7112eb8993d6c81b98cc44bd15a31a50e73c1294761563ba15117adde788c04d89003f23eb23f24bead8ca0aa5d4d0b7856da4287969c5836ab9fd
+  data.tar.gz: 3f488e8e0c4bbffe17c9b78177f61a4ee7ed535ba483217d7f71980bcd11f9939ddf52588a5f2dd0e244fae15023af9449b8539de930c7ed2bba43f15d8953c7

data/CHANGELOG.md

@@ -6,6 +6,11 @@ For more information about changelogs, check
 [Keep a Changelog](http://keepachangelog.com) and
 [Vandamme](http://tech-angels.github.io/vandamme).
 
+## 0.23.1 - 2015-05-19
+
+* [FEATURE] New `by: :month` option for reports.
+* [FEATURE] New `.reports` method to fetch multiple metrics at once.
+
 ## 0.23.0 - 2015-05-18
 
 **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.23.0'
+    gem 'yt', '~> 0.23.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

@@ -3,6 +3,23 @@ module Yt
     # @private
     # Provides methods to access the analytics reports of a resource.
     module HasReports
+      # @!macro [new] reports
+      #   Returns the reports for the given metrics grouped by the given dimension.
+      #   @!method reports(options = {})
+      #   @param [Hash] options the metrics, time-range and dimensions for the reports.
+      #   @option options [Array<Symbol>] :only The metrics to generate reports
+      #     for.
+      #   @option options [Symbol] :by (:day) The dimension to collect metrics
+      #     by. Accepted values are: +:day+, +:month+.
+      #   @option options [#to_date] :since The first day of the time-range.
+      #     Also aliased as +:from+.
+      #   @option options [#to_date] :until The last day of the time-range.
+      #     Also aliased as +:to+.
+      #   @return [Hash<Symbol, Hash>] the reports for each metric specified.
+      #   @example Get the views and estimated minutes watched by day for last week:
+      #     resource.reports only: [:views, :estimated_minutes_watched] since: 1.week.ago, by: :day
+      #     # => {views: {Wed, 8 May 2014 => 12, Thu, 9 May 2014 => 34, …}, estimated_minutes_watched: {Wed, 8 May 2014 => 9.0, Thu, 9 May 2014 => 6.0, …}}
+
       # @!macro [new] report
       #   Returns the $1 grouped by the given dimension.
       #   @!method $1(options = {})
@@ -18,6 +35,11 @@ module Yt
       #   @example Get the $1 for each day of last week:
       #     resource.$1 since: 2.weeks.ago, until: 1.week.ago, by: :day
       #     # => {Wed, 8 May 2014 => 12.0, Thu, 9 May 2014 => 34.0, …}
+      #   @return [Hash<Range<Date, Date>, $2>] if grouped by month, the $1
+      #     for each month in the time-range.
+      #   @example Get the $1 for this and last month:
+      #     resource.$1 since: 1.month.ago, by: :month
+      #     # => {Wed, 01 Apr 2014..Thu, 30 Apr 2014 => 12.0, Fri, 01 May 2014..Sun, 31 May 2014 => 34.0, …}
       #   @macro report
 
       # @!macro [new] report_with_range
@@ -48,19 +70,19 @@ module Yt
 
       # @!macro [new] report_by_day
       #   @option options [Symbol] :by (:day) The dimension to collect $1 by.
-      #     Accepted values are: +:day+.
+      #     Accepted values are: +:day+, +:month+.
       #   @macro report_with_day
 
       # @!macro [new] report_by_day_and_country
       #   @option options [Symbol] :by (:day) The dimension to collect $1 by.
-      #     Accepted values are: +:day+, :+range+.
+      #     Accepted values are: +:day+, +:month+, :+range+.
       #   @macro report_with_day
       #   @macro report_with_range
       #   @macro report_with_country
 
       # @!macro [new] report_by_day_and_state
       #   @option options [Symbol] :by (:day) The dimension to collect $1 by.
-      #     Accepted values are: +:day+, :+range+.
+      #     Accepted values are: +:day+, +:month+, :+range+.
       #   @macro report_with_day
       #   @macro report_with_range
       #   @macro report_with_country_and_state
@@ -96,7 +118,7 @@ module Yt
 
       # @!macro [new] report_by_video_dimensions
       #   @option options [Symbol] :by (:day) The dimension to collect $1 by.
-      #     Accepted values are: +:day+, +:range+, +:traffic_source+,
+      #     Accepted values are: +:day+, +:month+, +:range+, +:traffic_source+,
       #     +:search_term+, +:playback_location+, +:related_video+,
       #     +:embedded_player_location+.
       #   @return [Hash<Symbol, $2>] if grouped by embedded player location,
@@ -122,7 +144,7 @@ module Yt
 
       # @!macro [new] report_by_channel_dimensions
       #   @option options [Symbol] :by (:day) The dimension to collect $1 by.
-      #     Accepted values are: +:day+, +:range+, +:traffic_source+,
+      #     Accepted values are: +:day+, +:month+, +:range+, +:traffic_source+,
       #     +:search_term+, +:playback_location+, +:related_video+, +:video+,
       #     +:playlist+, +:embedded_player_location+.
       #   @return [Hash<Symbol, $2>] if grouped by embedded player location,
@@ -135,7 +157,7 @@ module Yt
 
       # @!macro [new] report_by_playlist_dimensions
       #   @option options [Symbol] :by (:day) The dimension to collect $1 by.
-      #     Accepted values are: +:day+, +:range+, +:traffic_source+,
+      #     Accepted values are: +:day+, +:month+, +:range+, +:traffic_source+,
       #     +:playback_location+, +:related_video+, +:video+,
       #     +:playlist+.
       #   @macro report_with_channel_dimensions
@@ -179,8 +201,9 @@ module Yt
 
         define_metric_on_method metric
         define_metric_method metric
-        define_range_metric_method metric, type
-        define_all_metric_method metric
+        define_reports_method metric, type
+        define_range_metric_method metric
+        define_all_metric_method metric, type
       end
 
     private
@@ -191,20 +214,45 @@ module Yt
         end
       end
 
+      def define_reports_method(metric, type)
+        (@metrics ||= {})[metric] = type
+        define_method :reports do |options = {}|
+          from = options[:since] || options[:from] || (options[:by].in?([:day, :month]) ? 5.days.ago : '2005-02-01')
+          to = options[:until] || options[:to] || Date.today
+          location = options[:in]
+          country = location.is_a?(Hash) ? location[:country] : location
+          state = location[:state] if location.is_a?(Hash)
+          dimension = options[:by] || (metric == :viewer_percentage ? :gender_age_group : :range)
+          if dimension == :month
+            from = from.to_date.beginning_of_month
+            to = to.to_date.beginning_of_month
+          end
+          date_range = Range.new *[from, to].map(&:to_date)
+
+          only = options.fetch :only, []
+          reports = Collections::Reports.of(self).tap do |reports|
+            reports.metrics =  self.class.instance_variable_get(:@metrics).select{|k, v| k.in? only}
+          end
+          reports.within date_range, country, state, dimension
+        end unless defined?(reports)
+      end
+
       def define_metric_method(metric)
         define_method metric do |options = {}|
-          from = options[:since] || options[:from] || (options[:by] == :day ? 5.days.ago : '2005-02-01')
+          from = options[:since] || options[:from] || (options[:by].in?([:day, :month]) ? 5.days.ago : '2005-02-01')
           to = options[:until] || options[:to] || Date.today
           location = options[:in]
           country = location.is_a?(Hash) ? location[:country] : location
           state = location[:state] if location.is_a?(Hash)
-
-          range = Range.new *[from, to].map(&:to_date)
           dimension = options[:by] || (metric == :viewer_percentage ? :gender_age_group : :range)
+          if dimension == :month
+            from = from.to_date.beginning_of_month
+            to = to.to_date.beginning_of_month
+          end
+          range = Range.new *[from, to].map(&:to_date)
 
           ivar = instance_variable_get "@#{metric}_#{dimension}_#{country}_#{state}"
           instance_variable_set "@#{metric}_#{dimension}_#{country}_#{state}", ivar || {}
-
           case dimension
           when :day
             Hash[*range.flat_map do |date|
@@ -216,23 +264,23 @@ module Yt
         end
       end
 
-      def define_range_metric_method(metric, type)
+      def define_range_metric_method(metric)
         define_method "range_#{metric}" do |date_range, dimension, country, state|
           ivar = instance_variable_get "@range_#{metric}_#{dimension}_#{country}_#{state}"
           instance_variable_set "@range_#{metric}_#{dimension}_#{country}_#{state}", ivar || {}
-          instance_variable_get("@range_#{metric}_#{dimension}_#{country}_#{state}")[date_range] ||= send("all_#{metric}").within date_range, country, state, dimension, type
+          instance_variable_get("@range_#{metric}_#{dimension}_#{country}_#{state}")[date_range] ||= send("all_#{metric}").within date_range, country, state, dimension
         end
         private "range_#{metric}"
       end
 
-      def define_all_metric_method(metric)
+      def define_all_metric_method(metric, type)
         define_method "all_#{metric}" do
           # @note Asking for the "earnings" metric of a day in which a channel
           # made 0 USD returns the wrong "nil". But adding to the request the
           # "estimatedMinutesWatched" metric returns the correct value 0.
-          query = metric
-          query = "estimatedMinutesWatched,#{metric}" if metric == :earnings
-          Collections::Reports.of(self).tap{|reports| reports.metric = query}
+          metrics = {metric => type}
+          metrics[:estimated_minutes_watched] = Integer if metric == :earnings
+          Collections::Reports.of(self).tap{|reports| reports.metrics = metrics}
         end
         private "all_#{metric}"
       end

data/lib/yt/collections/reports.rb

@@ -4,21 +4,22 @@ module Yt
   module Collections
     # @private
     class Reports < Base
-      DIMENSIONS = Hash.new({name: 'day', parse: ->(day, *values) {[Date.iso8601(day), values.last]} }).tap do |hash|
-        hash[:range] = {parse: ->(*values) { [:total, values.last]} }
-        hash[:traffic_source] = {name: 'insightTrafficSourceType', parse: ->(source, value) {[TRAFFIC_SOURCES.key(source), value]} }
-        hash[:playback_location] = {name: 'insightPlaybackLocationType', parse: ->(location, value) {[PLAYBACK_LOCATIONS.key(location), value]} }
-        hash[:embedded_player_location] = {name: 'insightPlaybackLocationDetail', parse: ->(url, value) {[url, value]} }
-        hash[:related_video] = {name: 'insightTrafficSourceDetail', parse: ->(video_id, value) { [Yt::Video.new(id: video_id, auth: @auth), value] } }
-        hash[:search_term] = {name: 'insightTrafficSourceDetail', parse: ->(search_term, value) { [search_term, value] } }
-        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]  } }
+      DIMENSIONS = Hash.new({name: 'day', parse: ->(day, *values) { @metrics.keys.zip(values.map{|v| {Date.iso8601(day) => v}}).to_h} }).tap do |hash|
+        hash[:month] = {name: 'month', parse: ->(month, *values) { @metrics.keys.zip(values.map{|v| {Range.new(Date.strptime(month, '%Y-%m').beginning_of_month, Date.strptime(month, '%Y-%m').end_of_month) => v} }).to_h} }
+        hash[:range] = {parse: ->(*values) { @metrics.keys.zip(values.map{|v| {total: v}}).to_h } }
+        hash[:traffic_source] = {name: 'insightTrafficSourceType', parse: ->(source, *values) { @metrics.keys.zip(values.map{|v| {TRAFFIC_SOURCES.key(source) => v}}).to_h} }
+        hash[:playback_location] = {name: 'insightPlaybackLocationType', parse: ->(location, *values) { @metrics.keys.zip(values.map{|v| {PLAYBACK_LOCATIONS.key(location) => v}}).to_h} }
+        hash[:embedded_player_location] = {name: 'insightPlaybackLocationDetail', parse: ->(url, *values) {@metrics.keys.zip(values.map{|v| {url => v}}).to_h} }
+        hash[:related_video] = {name: 'insightTrafficSourceDetail', parse: ->(video_id, *values) { @metrics.keys.zip(values.map{|v| {Yt::Video.new(id: video_id, auth: @auth) => v}}).to_h} }
+        hash[:search_term] = {name: 'insightTrafficSourceDetail', parse: ->(search_term, *values) {@metrics.keys.zip(values.map{|v| {search_term => v}}).to_h} }
+        hash[:video] = {name: 'video', parse: ->(video_id, *values) { @metrics.keys.zip(values.map{|v| {Yt::Video.new(id: video_id, auth: @auth) => v}}).to_h} }
+        hash[:playlist] = {name: 'playlist', parse: ->(playlist_id, *values) { @metrics.keys.zip(values.map{|v| {Yt::Playlist.new(id: playlist_id, auth: @auth) => v}}).to_h} }
+        hash[:device_type] = {name: 'deviceType', parse: ->(type, *values) {@metrics.keys.zip(values.map{|v| {type.downcase.to_sym => v}}).to_h} }
+        hash[:country] = {name: 'country', parse: ->(country_code, *values) { @metrics.keys.zip(values.map{|v| {country_code => v}}).to_h} }
+        hash[:state] = {name: 'province', parse: ->(country_and_state_code, *values) { @metrics.keys.zip(values.map{|v| {country_and_state_code[3..-1] => v}}).to_h} }
         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] } }
+        hash[:gender] = {name: 'gender', parse: ->(gender, *values) {@metrics.keys.zip(values.map{|v| {gender.downcase.to_sym => v}}).to_h} }
+        hash[:age_group] = {name: 'ageGroup', parse: ->(age_group, *values) {@metrics.keys.zip(values.map{|v| {age_group[3..-1] => v}}).to_h} }
       end
 
       # @see https://developers.google.com/youtube/analytics/v1/dimsmets/dims#Traffic_Source_Dimensions
@@ -49,9 +50,9 @@ module Yt
         mobile: 'MOBILE' # only present for data < September 10, 2013
       }
 
-      attr_writer :metric
+      attr_writer :metrics
 
-      def within(days_range, country, state, dimension, type, try_again = true)
+      def within(days_range, country, state, dimension, try_again = true)
         @days_range = days_range
         @dimension = dimension
         @country = country
@@ -61,7 +62,18 @@ module Yt
             each{|gender, age_group, value| hash[gender][age_group[3..-1]] = value}
           end
         else
-          Hash[*flat_map{|value| [value.first, type_cast(value.last, type)]}]
+          hash = flat_map do |hashes|
+            hashes.map do |metric, values|
+              [metric, values.transform_values{|v| type_cast(v, @metrics[metric])}]
+            end.to_h
+          end
+          hash = hash.inject(@metrics.transform_values{|v| {}}) do |result, hash|
+            result.deep_merge hash
+          end
+          if dimension == :month
+            hash = hash.transform_values{|h| h.sort_by{|range, v| range.first}.to_h}
+          end
+          (@metrics.one? || @metrics.keys == [:earnings, :estimated_minutes_watched]) ? hash[@metrics.keys.first] : hash
         end
       # NOTE: Once in a while, YouTube responds with 400 Error and the message
       # "Invalid query. Query did not conform to the expectations."; in this
@@ -70,7 +82,7 @@ module Yt
       # same query is a workaround that works and can hardly cause any damage.
       # Similarly, once in while YouTube responds with a random 503 error.
       rescue Yt::Error => e
-        try_again && rescue?(e) ? sleep(3) && within(days_range, country, state, dimension, type, false) : raise
+        try_again && rescue?(e) ? sleep(3) && within(days_range, country, state, dimension, false) : raise
       end
 
     private
@@ -99,12 +111,12 @@ module Yt
         @parent.reports_params.tap do |params|
           params['start-date'] = @days_range.begin
           params['end-date'] = @days_range.end
-          params['metrics'] = @metric.to_s.camelize(:lower)
+          params['metrics'] = @metrics.keys.join(',').to_s.camelize(:lower)
           params['dimensions'] = DIMENSIONS[@dimension][:name] unless @dimension == :range
           params['max-results'] = 10 if @dimension == :video
           params['max-results'] = 200 if @dimension == :playlist
           params['max-results'] = 25 if @dimension.in? [:embedded_player_location, :related_video, :search_term]
-          params['sort'] = "-#{@metric.to_s.camelize(:lower)}" if @dimension.in? [:video, :playlist, :embedded_player_location, :related_video, :search_term]
+          params['sort'] = "-#{@metrics.keys.join(',').to_s.camelize(:lower)}" if @dimension.in? [:video, :playlist, :embedded_player_location, :related_video, :search_term]
           params[:filters] = ((params[:filters] || '').split(';') + ["country==US"]).compact.uniq.join(';') if @dimension == :state && !@state
           params[:filters] = ((params[:filters] || '').split(';') + ["country==#{@country}"]).compact.uniq.join(';') if @country && !@state
           params[:filters] = ((params[:filters] || '').split(';') + ["province==US-#{@state}"]).compact.uniq.join(';') if @state

data/lib/yt/models/channel.rb

@@ -103,6 +103,8 @@ module Yt
 
     ### ANALYTICS ###
 
+      # @macro reports
+
       # @macro report_by_channel_dimensions
       has_report :views, Integer
 

data/lib/yt/models/playlist.rb

@@ -151,6 +151,8 @@ module Yt
 
     ### ANALYTICS ###
 
+      # @macro reports
+
       # @macro report_by_playlist_dimensions
       has_report :views, Integer
 

data/lib/yt/models/video.rb

@@ -372,6 +372,8 @@ module Yt
 
     ### ANALYTICS ###
 
+      # @macro reports
+
       # @macro report_by_video_dimensions
       has_report :views, Integer
 

data/lib/yt/version.rb

@@ -1,3 +1,3 @@
 module Yt
-  VERSION = '0.23.0'
+  VERSION = '0.23.1'
 end

data/spec/collections/reports_spec.rb

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

data/spec/requests/as_content_owner/channel_spec.rb

@@ -10,6 +10,39 @@ describe Yt::Channel, :partner do
     context 'managed by the authenticated Content Owner' do
       let(:id) { ENV['YT_TEST_PARTNER_CHANNEL_ID'] }
 
+      describe 'multiple reports can be retrieved at once' do
+        metrics = {views: Integer, uniques: Integer,
+          estimated_minutes_watched: Float, comments: Integer, likes: Integer,
+          dislikes: Integer, shares: Integer, subscribers_gained: Integer,
+          subscribers_lost: Integer, favorites_added: Integer,
+          favorites_removed: Integer, average_view_duration: Float,
+          average_view_percentage: Float, annotation_clicks: Integer,
+          annotation_click_through_rate: Float,
+          annotation_close_rate: Float, earnings: Float, impressions: Integer,
+          monetized_playbacks: Integer}
+
+        specify 'by day' do
+          range = {since: 5.days.ago.to_date, until: 3.days.ago.to_date}
+          result = channel.reports range.merge(only: metrics, by: :day)
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Date)
+            expect(result[metric].values).to all(be_a type)
+          end
+        end
+
+        specify 'by month' do
+          result = channel.reports only: metrics, by: :month, since: 1.month.ago
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Range)
+            expect(result[metric].keys.map &:first).to all(be_a Date)
+            expect(result[metric].keys.map &:first).to eq result[metric].keys.map(&:first).map(&:beginning_of_month)
+            expect(result[metric].keys.map &:last).to all(be_a Date)
+            expect(result[metric].keys.map &:last).to eq result[metric].keys.map(&:last).map(&:end_of_month)
+            expect(result[metric].values).to all(be_a type)
+          end
+        end
+      end
+
       [:views, :uniques, :comments, :likes, :dislikes, :shares,
        :subscribers_gained, :subscribers_lost, :favorites_added,
        :favorites_removed, :estimated_minutes_watched, :average_view_duration,
@@ -24,14 +57,32 @@ describe Yt::Channel, :partner do
 
           context 'with a given start and end (:since/:until option)' do
             let(:options) { {by: :day, since: date_in, until: date_out} }
-            it { expect(result.keys.min).to eq date_in.to_date }
-            it { expect(result.keys.max).to eq date_out.to_date }
+            specify do
+              expect(result.keys.min).to eq date_in.to_date
+              expect(result.keys.max).to eq date_out.to_date
+            end
           end
 
           context 'with a given start and end (:from/:to option)' do
             let(:options) { {by: :day, from: date_in, to: date_out} }
-            it { expect(result.keys.min).to eq date_in.to_date }
-            it { expect(result.keys.max).to eq date_out.to_date }
+            specify do
+              expect(result.keys.min).to eq date_in.to_date
+              expect(result.keys.max).to eq date_out.to_date
+            end
+          end
+        end
+
+        describe "#{metric} can be grouped by month" do
+          let(:metric) { metric }
+
+          let(:result) { channel.public_send metric, by: :month, since: 3.months.ago }
+          specify do
+            expect(result.keys).to eq(result.keys.sort_by{|range| range.first})
+            expect(result.keys).to all(be_a Range)
+            expect(result.keys.map &:first).to all(be_a Date)
+            expect(result.keys.map &:first).to eq result.keys.map(&:first).map(&:beginning_of_month)
+            expect(result.keys.map &:last).to all(be_a Date)
+            expect(result.keys.map &:last).to eq result.keys.map(&:last).map(&:end_of_month)
           end
         end
       end
@@ -59,29 +110,24 @@ describe Yt::Channel, :partner do
             it { expect(result).to be_nil }
           end
         end
-      end
 
-      {views: Integer, comments: Integer, likes: Integer, dislikes: Integer,
-       shares: Integer, subscribers_gained: Integer, subscribers_lost: Integer,
-       favorites_added: Integer, favorites_removed: Integer,
-       estimated_minutes_watched: Float, average_view_duration: Float,
-       average_view_percentage: Float, impressions: Integer,
-       monetized_playbacks: Integer, annotation_clicks: Integer,
-       annotation_click_through_rate: Float, annotation_close_rate: Float,
-       earnings: Float}.each do |metric, type|
         describe "#{metric} can be grouped by range" do
           let(:metric) { metric }
 
           context 'without a :by option (default)' do
             let(:result) { channel.public_send metric }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
 
           context 'with the :by option set to :range' do
             let(:result) { channel.public_send metric, by: :range }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
         end
       end
@@ -1398,7 +1444,7 @@ describe Yt::Channel, :partner do
       end
 
       describe 'annotation clicks can be grouped by country' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :country' do
           clicks = channel.annotation_clicks range.merge by: :country
@@ -1409,7 +1455,7 @@ describe Yt::Channel, :partner do
       end
 
       describe 'annotation clicks can be grouped by state' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :state' do
           clicks = channel.annotation_clicks range.merge by: :state
@@ -1508,7 +1554,7 @@ describe Yt::Channel, :partner do
       end
 
       describe 'annotation click-through rate can be grouped by state' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :state' do
           rate = channel.annotation_click_through_rate range.merge by: :state

data/spec/requests/as_content_owner/playlist_spec.rb

@@ -10,8 +10,36 @@ describe Yt::Playlist, :partner do
     context 'managed by the authenticated Content Owner' do
       let(:id) { ENV['YT_TEST_PARTNER_PLAYLIST_ID'] }
 
-      [:views, :estimated_minutes_watched, :average_view_duration,
-       :playlist_starts, :average_time_in_playlist, :views_per_playlist_start].each do |metric|
+      describe 'multiple reports can be retrieved at once' do
+        metrics = {views: Integer, estimated_minutes_watched: Float,
+         average_view_duration: Float, playlist_starts: Integer,
+         average_time_in_playlist: Float, views_per_playlist_start: Float}
+
+        specify 'by day' do
+          range = {since: 5.days.ago.to_date, until: 3.days.ago.to_date}
+          result = playlist.reports range.merge(only: metrics, by: :day)
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Date)
+            expect(result[metric].values).to all(be_a type)
+          end
+        end
+
+        specify 'by month' do
+          result = playlist.reports only: metrics, by: :month, since: 1.month.ago
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Range)
+            expect(result[metric].keys.map &:first).to all(be_a Date)
+            expect(result[metric].keys.map &:first).to eq result[metric].keys.map(&:first).map(&:beginning_of_month)
+            expect(result[metric].keys.map &:last).to all(be_a Date)
+            expect(result[metric].keys.map &:last).to eq result[metric].keys.map(&:last).map(&:end_of_month)
+            expect(result[metric].values).to all(be_a type)
+          end
+        end
+      end
+
+      {views: Integer, estimated_minutes_watched: Float, average_view_duration: Float,
+       playlist_starts: Integer, average_time_in_playlist: Float,
+       views_per_playlist_start: Float}.each do |metric, type|
         describe "#{metric} can be retrieved for a range of days" do
           let(:date_in) { ENV['YT_TEST_PARTNER_VIDEO_DATE'] }
           let(:date_out) { Date.parse(ENV['YT_TEST_PARTNER_VIDEO_DATE']) + 5 }
@@ -20,21 +48,33 @@ describe Yt::Playlist, :partner do
 
           context 'with a given start and end (:since/:until option)' do
             let(:options) { {by: :day, since: date_in, until: date_out} }
-            it { expect(result.keys.min).to eq date_in.to_date }
-            it { expect(result.keys.max).to eq date_out.to_date }
+            specify do
+              expect(result.keys.min).to eq date_in.to_date
+              expect(result.keys.max).to eq date_out.to_date
+            end
           end
 
           context 'with a given start and end (:from/:to option)' do
             let(:options) { {by: :day, from: date_in, to: date_out} }
-            it { expect(result.keys.min).to eq date_in.to_date }
-            it { expect(result.keys.max).to eq date_out.to_date }
+            specify do
+              expect(result.keys.min).to eq date_in.to_date
+              expect(result.keys.max).to eq date_out.to_date
+            end
+          end
+        end
+
+        describe "#{metric} can be grouped by month" do
+          let(:metric) { metric }
+          let(:result) { playlist.public_send metric, by: :month, since: 1.month.ago }
+          specify do
+            expect(result.keys).to all(be_a Range)
+            expect(result.keys.map &:first).to all(be_a Date)
+            expect(result.keys.map &:first).to eq result.keys.map(&:first).map(&:beginning_of_month)
+            expect(result.keys.map &:last).to all(be_a Date)
+            expect(result.keys.map &:last).to eq result.keys.map(&:last).map(&:end_of_month)
           end
         end
-      end
 
-      {views: Integer, estimated_minutes_watched: Float, average_view_duration: Float,
-       playlist_starts: Integer, average_time_in_playlist: Float,
-       views_per_playlist_start: Float}.each do |metric, type|
         describe "#{metric} can be retrieved for a specific day" do
           let(:metric) { metric }
           let(:result) { playlist.public_send "#{metric}_on", date }
@@ -55,14 +95,18 @@ describe Yt::Playlist, :partner do
 
           context 'without a :by option (default)' do
             let(:result) { playlist.public_send metric }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
 
           context 'with the :by option set to :range' do
             let(:result) { playlist.public_send metric, by: :range }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
         end
 

data/spec/requests/as_content_owner/video_spec.rb

@@ -27,14 +27,50 @@ describe Yt::Video, :partner do
 
           context 'with a given start and end (:since/:until option)' do
             let(:options) { {by: :day, since: date_in, until: date_out} }
-            it { expect(result.keys.min).to eq date_in.to_date }
-            it { expect(result.keys.max).to eq date_out.to_date }
+            specify do
+              expect(result.keys.min).to eq date_in.to_date
+              expect(result.keys.max).to eq date_out.to_date
+            end
           end
 
           context 'with a given start and end (:from/:to option)' do
             let(:options) { {by: :day, from: date_in, to: date_out} }
-            it { expect(result.keys.min).to eq date_in.to_date }
-            it { expect(result.keys.max).to eq date_out.to_date }
+            specify do
+              expect(result.keys.min).to eq date_in.to_date
+              expect(result.keys.max).to eq date_out.to_date
+            end
+          end
+        end
+
+        describe "#{metric} can be grouped by month" do
+          let(:metric) { metric }
+
+          let(:result) { video.public_send metric, by: :month, since: 1.month.ago }
+          specify do
+            expect(result.keys).to all(be_a Range)
+            expect(result.keys.map &:first).to all(be_a Date)
+            expect(result.keys.map &:first).to eq result.keys.map(&:first).map(&:beginning_of_month)
+            expect(result.keys.map &:last).to all(be_a Date)
+            expect(result.keys.map &:last).to eq result.keys.map(&:last).map(&:end_of_month)
+          end
+        end
+
+        describe "#{metric} can be retrieved for a single country" do
+          let(:result) { video.public_send metric, options }
+
+          context 'and grouped by day' do
+            let(:date_in) { 5.days.ago }
+            let(:options) { {by: :day, since: date_in, in: location} }
+
+            context 'with the :in option set to the country code' do
+              let(:location) { 'US' }
+              it { expect(result.keys.min).to eq date_in.to_date }
+            end
+
+            context 'with the :in option set to {country: country code}' do
+              let(:location) { {country: 'US'} }
+              it { expect(result.keys.min).to eq date_in.to_date }
+            end
           end
         end
       end
@@ -73,14 +109,18 @@ describe Yt::Video, :partner do
 
           context 'without a :by option (default)' do
             let(:result) { video.public_send metric }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
 
           context 'with the :by option set to :range' do
             let(:result) { video.public_send metric, by: :range }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
         end
       end
@@ -92,39 +132,17 @@ describe Yt::Video, :partner do
 
           context 'without a :by option (default)' do
             let(:result) { video.public_send metric }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
+            end
           end
 
           context 'with the :by option set to :range' do
             let(:result) { video.public_send metric, by: :range }
-            it { expect(result.size).to be 1 }
-            it { expect(result[:total]).to be_a type }
-          end
-        end
-      end
-
-      [:views, :uniques, :comments, :likes, :dislikes, :shares,
-       :subscribers_gained, :subscribers_lost, :favorites_added,
-       :favorites_removed, :estimated_minutes_watched, :average_view_duration,
-       :average_view_percentage, :impressions, :monetized_playbacks,
-       :annotation_clicks, :annotation_click_through_rate,
-       :annotation_close_rate, :earnings].each do |metric|
-        describe "#{metric} can be retrieved for a single country" do
-          let(:result) { video.public_send metric, options }
-
-          context 'and grouped by day' do
-            let(:date_in) { 5.days.ago }
-            let(:options) { {by: :day, since: date_in, in: location} }
-
-            context 'with the :in option set to the country code' do
-              let(:location) { 'US' }
-              it { expect(result.keys.min).to eq date_in.to_date }
-            end
-
-            context 'with the :in option set to {country: country code}' do
-              let(:location) { {country: 'US'} }
-              it { expect(result.keys.min).to eq date_in.to_date }
+            specify do
+              expect(result.size).to be 1
+              expect(result[:total]).to be_a type
             end
           end
         end
@@ -176,6 +194,39 @@ describe Yt::Video, :partner do
         end
       end
 
+      describe 'multiple reports can be retrieved at once' do
+        metrics = {views: Integer, uniques: Integer,
+          estimated_minutes_watched: Float, comments: Integer, likes: Integer,
+          dislikes: Integer, shares: Integer, subscribers_gained: Integer,
+          subscribers_lost: Integer, favorites_added: Integer,
+          favorites_removed: Integer, average_view_duration: Float,
+          average_view_percentage: Float, annotation_clicks: Integer,
+          annotation_click_through_rate: Float,
+          annotation_close_rate: Float, earnings: Float, impressions: Integer,
+          monetized_playbacks: Integer}
+
+        specify 'by day' do
+          range = {since: 5.days.ago.to_date, until: 3.days.ago.to_date}
+          result = video.reports range.merge(only: metrics, by: :day)
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Date)
+            expect(result[metric].values).to all(be_a type)
+          end
+        end
+
+        specify 'by month' do
+          result = video.reports only: metrics, by: :month, since: 1.month.ago
+          metrics.each do |metric, type|
+            expect(result[metric].keys).to all(be_a Range)
+            expect(result[metric].keys.map &:first).to all(be_a Date)
+            expect(result[metric].keys.map &:first).to eq result[metric].keys.map(&:first).map(&:beginning_of_month)
+            expect(result[metric].keys.map &:last).to all(be_a Date)
+            expect(result[metric].keys.map &:last).to eq result[metric].keys.map(&:last).map(&:end_of_month)
+            expect(result[metric].values).to all(be_a type)
+          end
+        end
+      end
+
       describe 'earnings can be grouped by day' do
         let(:range) { {since: 4.days.ago.to_date, until: 3.days.ago.to_date} }
         let(:keys) { range.values }
@@ -271,7 +322,7 @@ describe Yt::Video, :partner do
       end
 
       describe 'views can be grouped by related video' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :related_video' do
           views = video.views range.merge by: :related_video
@@ -280,7 +331,7 @@ describe Yt::Video, :partner do
       end
 
       describe 'views can be grouped by search term' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :search_term' do
           views = video.views range.merge by: :search_term
@@ -289,7 +340,7 @@ describe Yt::Video, :partner do
       end
 
       describe 'views can be grouped by device type' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :device_type' do
           views = video.views range.merge by: :device_type
@@ -299,7 +350,7 @@ describe Yt::Video, :partner do
       end
 
       describe 'views can be grouped by country' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :country' do
           views = video.views range.merge by: :country
@@ -310,7 +361,7 @@ describe Yt::Video, :partner do
       end
 
       describe 'views can be grouped by state' do
-        let(:range) { {since: 4.days.ago, until: 3.days.ago} }
+        let(:range) { {since: ENV['YT_TEST_PARTNER_VIDEO_DATE']} }
 
         specify 'with the :by option set to :state' do
           views = video.views range.merge by: :state

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yt
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.23.1
 platform: ruby
 authors:
 - Claudio Baccigalupo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-18 00:00:00.000000000 Z
+date: 2015-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport