yt 0.16.0 → 0.17.0

data/lib/yt/request.rb

@@ -33,12 +33,10 @@ module Yt
     # @option options [String] :host The host component of the request URI.
     # @option options [String] :path The path component of the request URI.
     # @option options [Hash] :params ({}) The params to use as the query
-    #   component of the request URI, for instance the Hash {a: 1, b: 2}
+    #   component of the request URI, for instance the Hash +{a: 1, b: 2}+
     #   corresponds to the query parameters "a=1&b=2".
     # @option options [Hash] :camelize_params (true) whether to transform
-    #   each key of params into a camel-case symbol before sending the
-    #   request. For instance, if set to true, the params {aBc: 1, d_e: 2,
-    #   'f' => 3} would be sent as {aBc: 1, dE: 2, f: 3}.
+    #   each key of params into a camel-case symbol before sending the request.
     # @option options [Hash] :request_format (:json) The format of the
     #   requesty body. If a request body is passed, it will be parsed
     #   according to this format before sending it in the request.

data/lib/yt/version.rb

@@ -1,3 +1,3 @@
 module Yt
-  VERSION = '0.16.0'
+  VERSION = '0.17.0'
 end

data/spec/models/content_detail_spec.rb

@@ -42,52 +42,4 @@ describe Yt::ContentDetail do
       it { expect(content_detail.duration).to eq 51 }
     end
   end
-
-  describe '#stereoscopic?' do
-    context 'given a 3D video' do
-      let(:data) { {"dimension"=>"3d"} }
-      it { expect(content_detail).to be_stereoscopic }
-    end
-
-    context 'given a 2D video' do
-      let(:data) { {"dimension"=>"2d"} }
-      it { expect(content_detail).not_to be_stereoscopic }
-    end
-  end
-
-  describe '#hd?' do
-    context 'given a high-definition video' do
-      let(:data) { {"definition"=>"hd"} }
-      it { expect(content_detail).to be_hd }
-    end
-
-    context 'given a standard-definition video' do
-      let(:data) { {"definition"=>"sd"} }
-      it { expect(content_detail).not_to be_hd }
-    end
-  end
-
-  describe '#captioned?' do
-    context 'given a video with captions' do
-      let(:data) { {"caption"=>"true"} }
-      it { expect(content_detail).to be_captioned }
-    end
-
-    context 'given a video without captions' do
-      let(:data) { {"caption"=>"false"} }
-      it { expect(content_detail).not_to be_captioned }
-    end
-  end
-
-  describe '#captioned?' do
-    context 'given a video with licensed content' do
-      let(:data) { {"licensedContent"=>true} }
-      it { expect(content_detail).to be_licensed }
-    end
-
-    context 'given a video without licensed content' do
-      let(:data) { {"licensedContent"=>false} }
-      it { expect(content_detail).not_to be_licensed }
-    end
-  end
 end

data/spec/models/file_detail_spec.rb

@@ -10,25 +10,4 @@ describe Yt::FileDetail do
       expect(file_detail.data).to eq data
     end
   end
-
-  describe '#file_size' do
-    context 'given a video with fileSize' do
-      let(:data) { {"fileSize"=>"8000000"} }
-      it { expect(file_detail.file_size).to be 8_000_000 }
-    end
-  end
-
-  describe '#file_type' do
-    context 'given a video with fileType' do
-      let(:data) { {"fileType"=>"video"} }
-      it { expect(file_detail.file_type).to eq 'video' }
-    end
-  end
-
-  describe '#container' do
-    context 'given a video with container' do
-      let(:data) { {"container"=>"mov"} }
-      it { expect(file_detail.container).to eq 'mov' }
-    end
-  end
 end

data/spec/models/live_streaming_detail_spec.rb

@@ -3,84 +3,4 @@ require 'yt/models/live_streaming_detail'
 
 describe Yt::LiveStreamingDetail do
   subject(:live_streaming_detail) { Yt::LiveStreamingDetail.new data: data }
-
-  describe '#actual_start_time' do
-    context 'given a non-live streaming video' do
-      let(:data) { {} }
-      it { expect(live_streaming_detail.actual_start_time).to be_nil }
-    end
-
-    context 'given a live streaming video that has not started yet' do
-      let(:data) { {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"} }
-      it { expect(live_streaming_detail.actual_start_time).to be_nil }
-    end
-
-    context 'given a live streaming video that has started' do
-      let(:data) { {"actualStartTime"=>"2014-08-01T17:48:40.678Z"} }
-      it { expect(live_streaming_detail.actual_start_time.year).to be 2014 }
-    end
-  end
-
-  describe '#actual_end_time' do
-    context 'given a non-live streaming video' do
-      let(:data) { {} }
-      it { expect(live_streaming_detail.actual_end_time).to be_nil }
-    end
-
-    context 'given a live streaming video that has not ended yet' do
-      let(:data) { {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"} }
-      it { expect(live_streaming_detail.actual_end_time).to be_nil }
-    end
-
-    context 'given a live streaming video that has ended' do
-      let(:data) { {"actualEndTime"=>"2014-08-01T17:48:40.678Z"} }
-      it { expect(live_streaming_detail.actual_end_time.year).to be 2014 }
-    end
-  end
-
-  describe '#scheduled_start_time' do
-    context 'given a non-live streaming video' do
-      let(:data) { {} }
-      it { expect(live_streaming_detail.scheduled_start_time).to be_nil }
-    end
-
-    context 'given a live streaming video' do
-      let(:data) { {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"} }
-      it { expect(live_streaming_detail.scheduled_start_time.year).to be 2017 }
-    end
-  end
-
-  describe '#scheduled_end_time' do
-    context 'given a non-live streaming video' do
-      let(:data) { {} }
-      it { expect(live_streaming_detail.scheduled_end_time).to be_nil }
-    end
-
-    context 'given a live streaming video that broadcasts indefinitely' do
-      let(:data) { {"scheduledStartTime"=>"2017-07-10T00:00:00.000Z"} }
-      it { expect(live_streaming_detail.scheduled_end_time).to be_nil }
-    end
-
-    context 'given a live streaming video with a scheduled ednd' do
-      let(:data) { {"scheduledEndTime"=>"2014-08-01T17:48:40.678Z"} }
-      it { expect(live_streaming_detail.scheduled_end_time.year).to be 2014 }
-    end
-  end
-
-  describe '#concurrent_viewers' do
-    context 'given a non-live streaming video' do
-      let(:data) { {} }
-      it { expect(live_streaming_detail.concurrent_viewers).to be_nil }
-    end
-
-    context 'given a current live streaming video with viewers' do
-      let(:data) { {"concurrentViewers"=>"1"} }
-      it { expect(live_streaming_detail.concurrent_viewers).to be 1 }
-    end
-
-    context 'given a past live streaming video' do
-      let(:data) { {"actualEndTime"=>"2013-08-01T17:48:40.678Z"} }
-      it { expect(live_streaming_detail.concurrent_viewers).to be_nil }
-    end
-  end
 end

data/spec/models/player_spec.rb

@@ -3,7 +3,6 @@ require 'yt/models/player'
 
 describe Yt::Player do
   subject(:player) { Yt::Player.new data: data }
-  let(:value) { "<iframe type='text/html' src='http://www.youtube.com/embed/BPNYv0vd78A' width='640' height='360' frameborder='0' allowfullscreen='true'/>" }
 
   describe '#data' do
     let(:data) { {"key"=>"value"} }
@@ -11,11 +10,4 @@ describe Yt::Player do
       expect(player.data).to eq data
     end
   end
-
-  describe '#embed_html' do
-    context 'given a video with embedHtml' do
-      let(:data) { {"embedHtml"=>value} }
-      it { expect(player.embed_html).to be value }
-    end
-  end
 end

data/spec/models/statistics_set_spec.rb

@@ -12,6 +12,7 @@ describe Yt::StatisticsSet do
     end
   end
 
+  # TODO: Remove these specs when these methods are tested in video, channel, ..
   describe '#view_count' do
     context 'given a video with views' do
       let(:data) { {"viewCount"=>value} }

data/spec/models/status_spec.rb

@@ -46,306 +46,4 @@ describe Yt::Status do
       it { expect(status).not_to be_unlisted }
     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_uploading }
-    end
-
-    context 'given fetching a status does not return uploadStatus "uploaded"' do
-      let(:data) { {"uploadStatus"=>"failed"} }
-      it { expect(status).not_to be_uploading }
-    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