yt 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61f559b96e49f82854993bc9fa8be3e6afab9aaa
-  data.tar.gz: cd332a6c0162c3c28abadd06c7c50cce24823924
+  metadata.gz: 82e7f06077dbcb70fc043948d27f297d26583085
+  data.tar.gz: 6b0d5b8bca60d7ce6595105ec076942675b1d448
 SHA512:
-  metadata.gz: e310ae789d8cb9c390c2b39681faa251ec90b3b0c0189aec22d3e81719c1b13a65ca6ede2e996a108956eb0d5c342c1a99198405bd61a4eed371623f819b990e
-  data.tar.gz: ac16bdf814bcab2fb1f6bb704ed00c890b13fe07824cb8d1dcaa27f2d940dd08c5492ba1623110c188ef0923eca874512f74e40426faf6274dfb7c8698f3510d
+  metadata.gz: 311d30cd632fcdbbee8887fa4e834afc0be54640522530152bc758b0423ea3c852ee1a0b7fefee0a4bbd6f7f6b8ce77005422172dafaecd99463cedffe8f21cb
+  data.tar.gz: 89a54825dfb15fe1d94b4f2aec38395355d8cd51d2d336ce98184557e41ec99e9fe31eb87a8e9349e4f92cff5cff3fb5504f10714dd774332d382ebca71469c4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yt (0.8.0)
+    yt (0.8.1)
       activesupport
 
 GEM

data/HISTORY.md

@@ -2,6 +2,7 @@ v0.8 - 2014/07/18
 -----------------
 
 * [breaking change] channel.subscribe returns nil (not raise an error) when trying to subscribe to your own channel
+* Add all the status fields to Video (upload status, failure reason, rejection reason, scheduled time, license, embeddable, public stats viewable)
 
 v0.7 - 2014/06/18
 -----------------

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.8.0'
+    gem 'yt', '~> 0.8.1'
 
 Since the gem follows [Semantic Versioning](http://semver.org),
 indicating the full version in your Gemfile (~> *major*.*minor*.*patch*)
@@ -201,13 +201,40 @@ video.description #=> "The new Fullscreen Creator Platform gives creators and br
 video.description.has_link_to_channel? #=> true
 video.thumbnail_url #=> "https://i1.ytimg.com/vi/MESycYJytkU/default.jpg"
 video.published_at #=> 2013-07-09 16:27:32 UTC
-video.public? #=> true
 video.tags #=> []
 video.channel_id #=> "UCxO1tY8h1AhOz0T4ENwmpow"
 video.channel_title #=> "Fullscreen"
 video.category_id #=> "22"
 video.live_broadcast_content #=> "none"
 
+video.public? #=> true
+video.uploaded? #=> false
+video.rejected? #=> false
+video.failed? #=> true
+video.processed? #=> false
+video.deleted? #=> false
+video.uses_unsupported_codec? #=> true
+video.has_failed_conversion? #=> false
+video.empty? #=> false
+video.invalid? #=> false
+video.too_small? #=> false
+video.aborted? #=> false
+video.claimed? #=> false
+video.infringes_copyright? #=> false
+video.duplicate? #=> false
+video.inappropriate? #=> false
+video.too_long? #=> false
+video.violates_terms_of_use? #=> false
+video.infringes_trademark? #=> false
+video.belongs_to_closed_account? #=> false
+video.belongs_to_suspended_account? #=> false
+video.scheduled? #=> true
+video.scheduled_at #=> Tue, 27 May 2014 12:50:00
+video.licensed_as_creative_commons? #=> true
+video.licensed_as_standard_youtube? #=> false
+video.embeddable? #=> false
+video.has_public_stats_viewable? #=> false
+
 video.duration #=> 86
 video.hd? #=> true
 video.stereoscopic? #=> false
@@ -544,18 +571,6 @@ This will fail unless you have set up a test YouTube application and some
 tests YouTube accounts to hit the API. Once again, you probably don’t need
 this, since Travis CI already takes care of running this kind of tests.
 
-How to contribute
-=================
-
-Yt needs your support!
-The goal of Yt is to provide a Ruby interface for all the methods exposed by
-the [YouTube Data API (v3)](https://developers.google.com/youtube/v3) and by
-the [YouTube Analytics API](https://developers.google.com/youtube/analytics).
-
-If you find that a method is missing, fork the project, add the missing code,
-write the appropriate tests, then submit a pull request, and it will gladly
-be merged!
-
 How to release new versions
 ===========================
 
@@ -571,5 +586,20 @@ Remember that the yt gem follows [Semantic Versioning](http://semver.org).
 Any new release that is fully backward-compatible should bump the *patch* version (0.0.x).
 Any new version that breaks compatibility should bump the *minor* version (0.x.0)
 
-Don’t hesitate to send code comments, issues or pull requests through GitHub!
-All feedback is appreciated. A [googol](http://en.wikipedia.org/wiki/Googol) of thanks! :)
+How to contribute
+=================
+
+Yt needs your support!
+The goal of Yt is to provide a Ruby interface for all the methods exposed by
+the [YouTube Data API (v3)](https://developers.google.com/youtube/v3) and by
+the [YouTube Analytics API](https://developers.google.com/youtube/analytics).
+
+If you find that a method is missing, fork the project, add the missing code,
+write the appropriate tests, then submit a pull request, and it will gladly
+be merged!
+
+Don’t hesitate to send code comments, issues or pull requests through GitHub
+and to spread the love on Twitter by following [@ytgem](https://twitter.com/intent/user?screen_name=ytgem) – 
+all feedback is appreciated.
+
+![yt4](https://cloud.githubusercontent.com/assets/7408595/3638115/0ef9d6bc-1037-11e4-831a-787204e9b979.png)

data/lib/yt/models/snippet.rb

@@ -115,6 +115,8 @@ module Yt
         @category_id ||= @data['categoryId']
       end
 
+      BROADCAST_TYPES = %q(live none upcoming)
+
       # @return [String] if the resource is a video, whether the resource is a
       #   live broadcast. Valid values are: live, none, upcoming.
       # @return [nil] if the resource is a channel.

data/lib/yt/models/status.rb

@@ -1,32 +1,318 @@
 module Yt
   module Models
-    # Encapsulates information about the privacy status of a resource, for
-    # instance a channel.
+    # Contains information about the status of a resource. The details of the
+    # status are different for the different types of resources.
+    #
+    # Resources with a
+    # status are: channels, playlists, playlist items and videos.
     # @see https://developers.google.com/youtube/v3/docs/channels#resource
+    # @see https://developers.google.com/youtube/v3/docs/videos#resource
+    # @see https://developers.google.com/youtube/v3/docs/playlists#resource
+    # @see https://developers.google.com/youtube/v3/docs/playlistItems#resource
     class Status
       def initialize(options = {})
         @data = options[:data]
       end
 
-      # @return [Boolean] whether the resource is public
+# Privacy status
+
+      PRIVACY_STATUSES = %q(private public unlisted)
+
+      # @return [String] the privacy status of the resource. Valid values are:
+      #   private, public, unlisted.
+      def privacy_status
+        @privacy_status ||= @data['privacyStatus']
+      end
+
+      # @return [Boolean] whether the resource is public.
       def public?
         privacy_status == 'public'
       end
 
-      # @return [Boolean] whether the resource is private
+      # @return [Boolean] whether the resource is private.
       def private?
         privacy_status == 'private'
       end
 
-      # @return [Boolean] whether the resource is unlisted
+      # @return [Boolean] whether the resource is unlisted.
       def unlisted?
         privacy_status == 'unlisted'
       end
 
-      # @return [String] the privacy status of the channel.
-      # Valid values are: private, public, unlisted
-      def privacy_status
-        @privacy_status ||= @data['privacyStatus']
+# Upload status (Video only)
+
+      # Returns the upload status of a video.
+      # @return [String] if the resource is a video, the status of the
+      #   uploaded video. Valid values are: deleted, failed, processed,
+      #   rejected, uploaded.
+      # @return [nil] if the resource is not a video.
+      def upload_status
+        @upload_status ||= @data['uploadStatus']
+      end
+
+      # Returns whether an uploaded video was deleted.
+      # @return [Boolean] if the resource is a video, whether the uploaded
+      #   video was deleted by the user.
+      # @return [nil] if the resource is not a video.
+      def deleted?
+        upload_status == 'deleted' if video?
+      end
+
+      # Returns whether a video failed to upload. If true, the reason why
+      # the video upload failed can be obtained with +failure_reason+.
+      # @return [Boolean] if the resource is a video, whether the video failed
+      #   to upload.
+      # @return [nil] if the resource is not a video.
+      def failed?
+        upload_status == 'failed' if video?
+      end
+
+      # Returns whether an uploaded video is being processed by YouTube.
+      # @return [Boolean] if the resource is a video, whether the uploaded
+      #   video is being processed by YouTube.
+      # @return [nil] if the resource is not a video.
+      def processed?
+        upload_status == 'processed' if video?
+      end
+
+      # Returns whether the video was rejected by YouTube. If true, the reason
+      # why the video was rejected can be obtained with +rejection_reason+.
+      # @return [Boolean] if the resource is a video, whether the video was
+      #  rejected by YouTube.
+      # @return [nil] if the resource is not a video.
+      def rejected?
+        upload_status == 'rejected' if video?
+      end
+
+      # Returns whether a video was successfully uploaded to YouTube.
+      # @return [Boolean] if the resource is a video, whether the video was
+      #   successfully uploaded.
+      # @return [nil] if the resource is not a video.
+      def uploaded?
+        upload_status == 'uploaded' if video?
+      end
+
+# Failure reason (Video only)
+
+      # Returns the reason why a video failed to upload.
+      # @return [String] if resource is a video with a 'failed' upload status,
+      #   the reason why the video failed to upload. Valid values are: codec,
+      #   conversion, emptyFile, invalidFile, tooSmall, uploadAborted.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      def failure_reason
+        @failure_reason ||= @data['failureReason']
+      end
+
+      # Returns whether a video upload failed because of the codec.
+      # @return [Boolean] if the resource is a video, whether the video uses
+      #   a codec not supported by YouTube.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      # @see https://support.google.com/youtube/answer/1722171
+      def uses_unsupported_codec?
+        failure_reason == 'codec' if video?
+      end
+
+      # Returns whether YouTube was unable to convert an uploaded video.
+      # @return [Boolean] if the resource is a video, whether YouTube was
+      #   unable to convert the video.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      def has_failed_conversion?
+        failure_reason == 'conversion' if video?
+      end
+
+      # Returns whether a video upload failed because the file was empty.
+      # @return [Boolean] if the resource is a video, whether the video file
+      #   is empty.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      def empty?
+        failure_reason == 'emptyFile' if video?
+      end
+
+      # Returns whether a video upload failed because of the file format.
+      # @return [Boolean] if the resource is a video, whether the video uses
+      #   a file format not supported by YouTube.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      # @see https://support.google.com/youtube/troubleshooter/2888402?hl=en
+      def invalid?
+        failure_reason == 'invalidFile' if video?
+      end
+
+      # Returns whether a video upload failed because the file was too small.
+      # @return [Boolean] if the resource is a video, whether the video file
+      #   is too small for YouTube.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      def too_small?
+        failure_reason == 'tooSmall' if video?
+      end
+
+      # Returns whether a video upload failed because the upload was aborted.
+      # @return [Boolean] if the resource is a video, whether the uploading
+      #   process was aborted.
+      # @return [nil] if the resource is not a video or upload has not failed.
+      def aborted?
+        failure_reason == 'uploadAborted' if video?
+      end
+
+# Rejection reason (Video only)
+
+      # Returns the reason why a video was rejected by YouTube.
+      # @return [String] if resource is a video with a 'rejected' upload
+      #   status, the reason why the video was rejected. Valid values are:
+      #   claim, copyright, duplicate, inappropriate, length, termsOfUse,
+      #   trademark, uploaderAccountClosed, uploaderAccountSuspended.
+      # @return [nil] if the resource is not a rejected video.
+      def rejection_reason
+        @rejection_reason ||= @data['rejectionReason']
+      end
+
+      # Returns whether a video was rejected because it was claimed.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video was claimed by a different account.
+      # @return [nil] if the resource is not a rejected video.
+      def claimed?
+        rejection_reason == 'claim' if video?
+      end
+
+      # Returns whether a video was rejected because of copyright infringement.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video commits a copyright infringement.
+      # @return [nil] if the resource is not a rejected video.
+      def infringes_copyright?
+        rejection_reason == 'copyright' if video?
+      end
+
+      # Returns whether a video was rejected because it is a duplicate.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video is a duplicate of another uploaded video.
+      # @return [nil] if the resource is not a rejected video.
+      def duplicate?
+        rejection_reason == 'duplicate' if video?
+      end
+
+      # Returns whether a video was rejected because of inappropriate content.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video contains inappropriate content.
+      # @return [nil] if the resource is not a rejected video.
+      def inappropriate?
+        rejection_reason == 'inappropriate' if video?
+      end
+
+      # Returns whether a video was rejected because it is too long.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video exceeds the maximum duration.
+      # @return [nil] if the resource is not a rejected video.
+      # @see https://support.google.com/youtube/answer/71673?hl=en
+      def too_long?
+        rejection_reason == 'length' if video?
+      end
+
+      # Returns whether a video was rejected because it violates terms of use.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video commits a terms of use violation.
+      # @return [nil] if the resource is not a rejected video.
+      def violates_terms_of_use?
+        rejection_reason == 'termsOfUse' if video?
+      end
+
+      # Returns whether a video was rejected because of trademark infringement.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   video commits a trademark infringement.
+      # @return [nil] if the resource is not a rejected video.
+      # @see https://support.google.com/youtube/answer/2801979?hl=en
+      def infringes_trademark?
+        rejection_reason == 'trademark' if video?
+      end
+
+      # Returns whether a video was rejected because the account was closed.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   account associated with the video has been closed.
+      # @return [nil] if the resource is not a rejected video.
+      def belongs_to_closed_account?
+        rejection_reason == 'uploaderAccountClosed' if video?
+      end
+
+      # Returns whether a video was rejected because the account was suspended.
+      # @return [Boolean] if the resource is a rejected video, whether the
+      #   account associated with the video has been suspended.
+      # @return [nil] if the resource is not a rejected video.
+      def belongs_to_suspended_account?
+        rejection_reason == 'uploaderAccountSuspended' if video?
+      end
+
+# Scheduled publication (Video only)
+
+      # Returns the date and time when a video is scheduled to be published.
+      # @return [Time] if resource is a private video scheduled to be
+      #   published, the date and time when the video is scheduled to publish.
+      # @return [nil] if the resource is not a private video scheduled to be
+      #   published.
+      def scheduled_at
+        @scheduled_at ||= Time.parse @data['publishAt'] if scheduled?
+      end
+
+      # Returns whether the video is scheduled to be published.
+      # @return [Boolean] if the resource is a video, whether it is currently
+      #   private and is scheduled to become public in the future.
+      # @return [nil] if the resource is not a video.
+      def scheduled?
+        private? && @data['publishAt'] if video?
+      end
+
+# License (Video only)
+
+      # Returns the video’s license.
+      # @return [String] if resource is a video, its license. Valid values are:
+      #   creativeCommon, youtube.
+      # @return [nil] if the resource is not a video.
+      def license
+        @license ||= @data['license']
+      end
+
+      # Returns whether the video uses a Creative Commons license.
+      # @return [Boolean] if the resource is a video, whether it uses a
+      #   Creative Commons license.
+      # @return [nil] if the resource is not a video.
+      # @see https://support.google.com/youtube/answer/2797468?hl=en
+      def licensed_as_creative_commons?
+        license == 'creativeCommon' if video?
+      end
+
+      # Returns whether the video uses the Standard YouTube license.
+      # @return [Boolean] if the resource is a video, whether it uses the
+      #   Standard YouTube license.
+      # @return [nil] if the resource is not a video.
+      # @see https://www.youtube.com/static?template=terms
+      def licensed_as_standard_youtube?
+        license == 'youtube' if video?
+      end
+
+# Embed (Video only)
+
+      # Returns whether the video can be embedded on another website.
+      # @return [Boolean] if the resource is a video, whether it can be
+      #   embedded on another website.
+      # @return [nil] if the resource is not a video.
+      def embeddable?
+        @embeddable ||= @data['embeddable']
+      end
+
+# Public stats (Video only)
+
+      # Returns whether the video statistics are publicly viewable.
+      # @return [Boolean] if the resource is a video, whether the extended
+      #   video statistics on the video’s watch page are publicly viewable.
+      #   By default, those statistics are viewable, and statistics like a
+      #   video’s viewcount and ratings will still be publicly visible even
+      #   if this property’s value is set to false.
+      # @return [nil] if the resource is not a video.
+      def has_public_stats_viewable?
+        @public_stats_viewable ||= @data['publicStatsViewable']
+      end
+
+    private
+
+      def video?
+        upload_status.present?
       end
     end
   end

data/lib/yt/models/video.rb

@@ -8,6 +8,15 @@ module Yt
       delegate :tags, :channel_id, :channel_title, :category_id,
         :live_broadcast_content, to: :snippet
 
+      delegate :deleted?, :failed?, :processed?, :rejected?, :uploaded?,
+        :uses_unsupported_codec?, :has_failed_conversion?, :empty?, :invalid?,
+        :too_small?, :aborted?, :claimed?, :infringes_copyright?, :duplicate?,
+        :scheduled_at, :scheduled?, :too_long?, :violates_terms_of_use?,
+        :inappropriate?, :infringes_trademark?, :belongs_to_closed_account?,
+        :belongs_to_suspended_account?, :licensed_as_creative_commons?,
+        :licensed_as_standard_youtube?, :has_public_stats_viewable?,
+        :embeddable?, to: :status
+
       # @!attribute [r] content_detail
       #   @return [Yt::Models::ContentDetail] the video’s content details.
       has_one :content_detail

data/lib/yt/version.rb

@@ -1,3 +1,3 @@
 module Yt
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 end

data/spec/models/status_spec.rb

@@ -10,7 +10,7 @@ describe Yt::Status do
       it { expect(status).to be_public }
     end
 
-    context 'given fetching a status does not returns privacyStatus "public"' do
+    context 'given fetching a status does not return privacyStatus "public"' do
       let(:data) { {} }
       it { expect(status).not_to be_public }
     end
@@ -22,7 +22,7 @@ describe Yt::Status do
       it { expect(status).to be_private }
     end
 
-    context 'given fetching a status does not returns privacyStatus "private"' do
+    context 'given fetching a status does not return privacyStatus "private"' do
       let(:data) { {} }
       it { expect(status).not_to be_private }
     end
@@ -34,9 +34,311 @@ describe Yt::Status do
       it { expect(status).to be_unlisted }
     end
 
-    context 'given fetching a status does not returns privacyStatus "unlisted"' do
+    context 'given fetching a status does not return privacyStatus "unlisted"' do
       let(:data) { {} }
       it { expect(status).not_to be_unlisted }
     end
   end
-end
+
+  describe '#deleted?' do
+    context 'given fetching a status returns uploadStatus "deleted"' do
+      let(:data) { {"uploadStatus"=>"deleted"} }
+      it { expect(status).to be_deleted }
+    end
+
+    context 'given fetching a status does not return uploadStatus "deleted"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).not_to be_deleted }
+    end
+  end
+
+  describe '#failed?' do
+    context 'given fetching a status returns uploadStatus "failed"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).to be_failed }
+    end
+
+    context 'given fetching a status does not return uploadStatus "failed"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).not_to be_failed }
+    end
+  end
+
+  describe '#processed?' do
+    context 'given fetching a status returns uploadStatus "processed"' do
+      let(:data) { {"uploadStatus"=>"processed"} }
+      it { expect(status).to be_processed }
+    end
+
+    context 'given fetching a status does not return uploadStatus "processed"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).not_to be_processed }
+    end
+  end
+
+  describe '#rejected?' do
+    context 'given fetching a status returns uploadStatus "rejected"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status).to be_rejected }
+    end
+
+    context 'given fetching a status does not return uploadStatus "rejected"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).not_to be_rejected }
+    end
+  end
+
+  describe '#uploaded?' do
+    context 'given fetching a status returns uploadStatus "uploaded"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).to be_uploaded }
+    end
+
+    context 'given fetching a status does not return uploadStatus "uploaded"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).not_to be_uploaded }
+    end
+  end
+
+  describe '#uses_unsupported_codec?' do
+    context 'given fetching a status returns failureReason "codec"' do
+      let(:data) { {"uploadStatus"=>"failed", "failureReason"=>"codec"} }
+      it { expect(status.uses_unsupported_codec?).to be true }
+    end
+
+    context 'given fetching a status does not return failureReason "codec"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status.uses_unsupported_codec?).to be false }
+    end
+  end
+
+  describe '#conversion_failed?' do
+    context 'given fetching a status returns failureReason "conversion"' do
+      let(:data) { {"uploadStatus"=>"failed", "failureReason"=>"conversion"} }
+      it { expect(status).to have_failed_conversion }
+    end
+
+    context 'given fetching a status does not return failureReason "conversion"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).not_to have_failed_conversion }
+    end
+  end
+
+  describe '#empty_file?' do
+    context 'given fetching a status returns failureReason "emptyFile"' do
+      let(:data) { {"uploadStatus"=>"failed", "failureReason"=>"emptyFile"} }
+      it { expect(status).to be_empty }
+    end
+
+    context 'given fetching a status does not return failureReason "emptyFile"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).not_to be_empty }
+    end
+  end
+
+  describe '#invalid_file?' do
+    context 'given fetching a status returns failureReason "invalidFile"' do
+      let(:data) { {"uploadStatus"=>"failed", "failureReason"=>"invalidFile"} }
+      it { expect(status).to be_invalid }
+    end
+
+    context 'given fetching a status does not return failureReason "invalidFile"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).not_to be_invalid }
+    end
+  end
+
+  describe '#too_small?' do
+    context 'given fetching a status returns failureReason "tooSmall"' do
+      let(:data) { {"uploadStatus"=>"failed", "failureReason"=>"tooSmall"} }
+      it { expect(status).to be_too_small }
+    end
+
+    context 'given fetching a status does not return failureReason "tooSmall"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).not_to be_too_small }
+    end
+  end
+
+  describe '#upload_aborted?' do
+    context 'given fetching a status returns failureReason "uploadAborted"' do
+      let(:data) { {"uploadStatus"=>"failed", "failureReason"=>"uploadAborted"} }
+      it { expect(status).to be_aborted }
+    end
+
+    context 'given fetching a status does not return failureReason "uploadAborted"' do
+      let(:data) { {"uploadStatus"=>"failed"} }
+      it { expect(status).not_to be_aborted }
+    end
+  end
+
+  describe '#claimed?' do
+    context 'given fetching a status returns rejectionReason "claim"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"claim"} }
+      it { expect(status).to be_claimed }
+    end
+
+    context 'given fetching a status does not return rejectionReason "claim"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status).not_to be_claimed }
+    end
+  end
+
+  describe '#infringes_copyright?' do
+    context 'given fetching a status returns rejectionReason "copyright"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"copyright"} }
+      it { expect(status.infringes_copyright?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "copyright"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status.infringes_copyright?).to be false }
+    end
+  end
+
+  describe '#duplicate?' do
+    context 'given fetching a status returns rejectionReason "duplicate"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"duplicate"} }
+      it { expect(status).to be_duplicate }
+    end
+
+    context 'given fetching a status does not return rejectionReason "duplicate"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status).not_to be_duplicate }
+    end
+  end
+
+  describe '#inappropriate?' do
+    context 'given fetching a status returns rejectionReason "inappropriate"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"inappropriate"} }
+      it { expect(status).to be_inappropriate }
+    end
+
+    context 'given fetching a status does not return rejectionReason "inappropriate"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status).not_to be_inappropriate }
+    end
+  end
+
+  describe '#too_long?' do
+    context 'given fetching a status returns rejectionReason "length"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"length"} }
+      it { expect(status).to be_too_long }
+    end
+
+    context 'given fetching a status does not return rejectionReason "length"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status).not_to be_too_long }
+    end
+  end
+
+  describe '#violates_terms_of_use?' do
+    context 'given fetching a status returns rejectionReason "termsOfUse"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"termsOfUse"} }
+      it { expect(status.violates_terms_of_use?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "termsOfUse"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status.violates_terms_of_use?).to be false }
+    end
+  end
+
+  describe '#infringes_trademark?' do
+    context 'given fetching a status returns rejectionReason "trademark"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"trademark"} }
+      it { expect(status.infringes_trademark?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "trademark"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status.infringes_trademark?).to be false }
+    end
+  end
+
+  describe '#belongs_to_closed_account?' do
+    context 'given fetching a status returns rejectionReason "uploaderAccountClosed"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"uploaderAccountClosed"} }
+      it { expect(status.belongs_to_closed_account?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "uploaderAccountClosed"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status.belongs_to_closed_account?).to be false }
+    end
+  end
+
+  describe '#belongs_to_suspended_account?' do
+    context 'given fetching a status returns rejectionReason "uploaderAccountSuspended"' do
+      let(:data) { {"uploadStatus"=>"rejected", "rejectionReason"=>"uploaderAccountSuspended"} }
+      it { expect(status.belongs_to_suspended_account?).to be true }
+    end
+
+    context 'given fetching a status does not return rejectionReason "uploaderAccountSuspended"' do
+      let(:data) { {"uploadStatus"=>"rejected"} }
+      it { expect(status.belongs_to_suspended_account?).to be false }
+    end
+  end
+
+  describe '#scheduled_at and #scheduled' do
+    context 'given fetching a status returns "publishAt"' do
+      let(:data) { {"uploadStatus"=>"uploaded", "privacyStatus"=>"private", "publishAt"=>"2014-04-22T19:14:49.000Z"} }
+      it { expect(status).to be_scheduled }
+      it { expect(status.scheduled_at.year).to be 2014 }
+    end
+
+    context 'given fetching a status does not returns "publishAt"' do
+      let(:data) { {"uploadStatus"=>"uploaded", "privacyStatus"=>"private"} }
+      it { expect(status).not_to be_scheduled }
+      it { expect(status.scheduled_at).not_to be }
+    end
+  end
+
+  describe '#licensed_as_creative_commons?' do
+    context 'given fetching a status returns license "creativeCommon"' do
+      let(:data) { {"uploadStatus"=>"uploaded", "license"=>"creativeCommon"} }
+      it { expect(status).to be_licensed_as_creative_commons }
+    end
+
+    context 'given fetching a status does not return license "creativeCommon"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).not_to be_licensed_as_creative_commons }
+    end
+  end
+
+  describe '#licensed_as_standard_youtube?' do
+    context 'given fetching a status returns license "youtube"' do
+      let(:data) { {"uploadStatus"=>"uploaded", "license"=>"youtube"} }
+      it { expect(status).to be_licensed_as_standard_youtube }
+    end
+
+    context 'given fetching a status does not return license "youtube"' do
+      let(:data) { {"uploadStatus"=>"uploaded"} }
+      it { expect(status).not_to be_licensed_as_standard_youtube }
+    end
+  end
+
+  describe '#embeddable?' do
+    context 'given fetching a status returns "embeddable" true' do
+      let(:data) { {"uploadStatus"=>"uploaded", "embeddable"=>true} }
+      it { expect(status).to be_embeddable }
+    end
+
+    context 'given fetching a status returns "embeddable" false' do
+      let(:data) { {"uploadStatus"=>"uploaded", "embeddable"=>false} }
+      it { expect(status).not_to be_embeddable }
+    end
+  end
+
+  describe '#has_public_stats_viewable?' do
+    context 'given fetching a status returns "publicStatsViewable" true' do
+      let(:data) { {"publicStatsViewable"=>true} }
+      it { expect(status).to have_public_stats_viewable }
+    end
+
+    context 'given fetching a status returns "publicStatsViewable" false' do
+      let(:data) { {"publicStatsViewable"=>false} }
+      it { expect(status).not_to have_public_stats_viewable }
+    end
+  end
+end

data/spec/requests/as_account/channel_spec.rb

@@ -8,19 +8,20 @@ describe Yt::Channel, :device_app do
   context 'given someone else’s channel' do
     let(:id) { 'UCxO1tY8h1AhOz0T4ENwmpow' }
 
-    it 'returns valid snippet data' do
-      expect(channel.snippet).to be_a Yt::Snippet
+    it 'returns valid metadata' do
       expect(channel.title).to be_a String
-      expect(channel.description).to be_a Yt::Description
+      expect(channel.description).to be_a String
       expect(channel.thumbnail_url).to be_a String
       expect(channel.published_at).to be_a Time
+      expect(channel.privacy_status).to be_in Yt::Status::PRIVACY_STATUSES
+      expect(channel.view_count).to be_an Integer
+      expect(channel.comment_count).to be_an Integer
+      expect(channel.video_count).to be_an Integer
+      expect(channel.subscriber_count).to be_an Integer
+      expect(channel.subscriber_count_visible?).to be_in [true, false]
     end
 
-    it { expect(channel.status).to be_a Yt::Status }
-    it { expect(channel.statistics_set).to be_a Yt::StatisticsSet }
-    it { expect(channel.videos).to be_a Yt::Collections::Videos }
     it { expect(channel.videos.first).to be_a Yt::Video }
-    it { expect(channel.playlists).to be_a Yt::Collections::Playlists }
     it { expect(channel.playlists.first).to be_a Yt::Playlist }
     it { expect{channel.create_playlist}.to raise_error Yt::Errors::RequestError }
     it { expect{channel.delete_playlists}.to raise_error Yt::Errors::RequestError }

data/spec/requests/as_account/playlist_item_spec.rb

@@ -7,10 +7,9 @@ describe Yt::PlaylistItem, :device_app do
   context 'given an existing playlist item' do
     let(:id) { 'PLjW_GNR5Ir0GWEP_oveGBNjTvKkYyZfsna1TZDCBP-Z8' }
 
-    it 'returns valid snippet data' do
-      expect(item.snippet).to be_a Yt::Snippet
+    it 'returns valid metadata' do
       expect(item.title).to be_a String
-      expect(item.description).to be_a Yt::Description
+      expect(item.description).to be_a String
       expect(item.thumbnail_url).to be_a String
       expect(item.published_at).to be_a Time
       expect(item.channel_id).to be_a String
@@ -18,7 +17,8 @@ describe Yt::PlaylistItem, :device_app do
       expect(item.playlist_id).to be_a String
       expect(item.position).to be_an Integer
       expect(item.video_id).to be_a String
-      expect(item.video).to be_a Yt::Models::Video
+      expect(item.video).to be_a Yt::Video
+      expect(item.privacy_status).to be_in Yt::Status::PRIVACY_STATUSES
     end
   end
 

data/spec/requests/as_account/playlist_spec.rb

@@ -9,19 +9,17 @@ describe Yt::Playlist, :device_app do
   context 'given an existing playlist' do
     let(:id) { 'PLSWYkYzOrPMRCK6j0UgryI8E0NHhoVdRc' }
 
-    it 'returns valid snippet data' do
-      expect(playlist.snippet).to be_a Yt::Snippet
+    it 'returns valid metadata' do
       expect(playlist.title).to be_a String
-      expect(playlist.description).to be_a Yt::Description
+      expect(playlist.description).to be_a String
       expect(playlist.thumbnail_url).to be_a String
       expect(playlist.published_at).to be_a Time
       expect(playlist.tags).to be_an Array
       expect(playlist.channel_id).to be_a String
       expect(playlist.channel_title).to be_a String
+      expect(playlist.privacy_status).to be_in Yt::Status::PRIVACY_STATUSES
     end
 
-    it { expect(playlist.status).to be_a Yt::Status }
-    it { expect(playlist.playlist_items).to be_a Yt::Collections::PlaylistItems }
     it { expect(playlist.playlist_items.first).to be_a Yt::PlaylistItem }
   end
 

data/spec/requests/as_account/video_spec.rb

@@ -11,22 +11,55 @@ describe Yt::Video, :device_app do
 
     it { expect(video.content_detail).to be_a Yt::ContentDetail }
 
-    it 'returns valid snippet data' do
-      expect(video.snippet).to be_a Yt::Snippet
+    it 'returns valid metadata' do
       expect(video.title).to be_a String
-      expect(video.description).to be_a Yt::Description
+      expect(video.description).to be_a String
       expect(video.thumbnail_url).to be_a String
       expect(video.published_at).to be_a Time
+      expect(video.privacy_status).to be_in Yt::Status::PRIVACY_STATUSES
       expect(video.tags).to be_an Array
       expect(video.channel_id).to be_a String
       expect(video.channel_title).to be_a String
       expect(video.category_id).to be_a String
-      expect(video.live_broadcast_content).to be_a String
+      expect(video.live_broadcast_content).to be_in Yt::Snippet::BROADCAST_TYPES
+      expect(video.view_count).to be_an Integer
+      expect(video.like_count).to be_an Integer
+      expect(video.dislike_count).to be_an Integer
+      expect(video.favorite_count).to be_an Integer
+      expect(video.comment_count).to be_an Integer
+      expect(video.duration).to be_an Integer
+      expect(video.hd?).to be_in [true, false]
+      expect(video.stereoscopic?).to be_in [true, false]
+      expect(video.captioned?).to be_in [true, false]
+      expect(video.licensed?).to be_in [true, false]
+      expect(video.deleted?).to be_in [true, false]
+      expect(video.failed?).to be_in [true, false]
+      expect(video.processed?).to be_in [true, false]
+      expect(video.rejected?).to be_in [true, false]
+      expect(video.uploaded?).to be_in [true, false]
+      expect(video.uses_unsupported_codec?).to be_in [true, false]
+      expect(video.has_failed_conversion?).to be_in [true, false]
+      expect(video.empty?).to be_in [true, false]
+      expect(video.invalid?).to be_in [true, false]
+      expect(video.too_small?).to be_in [true, false]
+      expect(video.aborted?).to be_in [true, false]
+      expect(video.claimed?).to be_in [true, false]
+      expect(video.infringes_copyright?).to be_in [true, false]
+      expect(video.duplicate?).to be_in [true, false]
+      expect(video.scheduled_at.class).to be_in [NilClass, Time]
+      expect(video.scheduled?).to be_in [true, false]
+      expect(video.too_long?).to be_in [true, false]
+      expect(video.violates_terms_of_use?).to be_in [true, false]
+      expect(video.inappropriate?).to be_in [true, false]
+      expect(video.infringes_trademark?).to be_in [true, false]
+      expect(video.belongs_to_closed_account?).to be_in [true, false]
+      expect(video.belongs_to_suspended_account?).to be_in [true, false]
+      expect(video.licensed_as_creative_commons?).to be_in [true, false]
+      expect(video.licensed_as_standard_youtube?).to be_in [true, false]
+      expect(video.has_public_stats_viewable?).to be_in [true, false]
+      expect(video.embeddable?).to be_in [true, false]
     end
 
-    it { expect(video.rating).to be_a Yt::Rating }
-    it { expect(video.status).to be_a Yt::Status }
-    it { expect(video.statistics_set).to be_a Yt::StatisticsSet }
     it { expect{video.update}.to fail }
 
     context 'that I like' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yt
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Claudio Baccigalupo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-19 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport