vibedeck-youtube_it 0.0.1

data/lib/youtube_it.rb

@@ -0,0 +1,75 @@
+require 'logger'
+require 'open-uri'
+require 'net/https'
+require 'digest/md5'
+require 'rexml/document'
+require 'builder'
+require 'oauth'
+require 'faraday'
+
+class YouTubeIt
+  
+  # Base error class for the extension
+  class Error < RuntimeError
+  end
+  
+  # URL-escape a string. Stolen from Camping (wonder how many Ruby libs in the wild can say the same)
+  def self.esc(s) #:nodoc:
+    s.to_s.gsub(/[^ \w.-]+/n){'%'+($&.unpack('H2'*$&.size)*'%').upcase}.tr(' ', '+')
+  end
+  
+  # Set the logger for the library
+  def self.logger=(any_logger)
+    @logger = any_logger
+  end
+
+  # Get the logger for the library (by default will log to STDOUT). TODO: this is where we grab the Rails logger too
+  def self.logger
+    @logger ||= create_default_logger
+  end
+  
+  # Gets mixed into the classes to provide the logger method
+  module Logging #:nodoc:
+    
+    # Return the base logger set for the library
+    def logger
+      YouTubeIt.logger
+    end
+  end
+    
+  private
+    def self.create_default_logger
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::DEBUG
+      logger
+    end
+end
+
+%w( 
+  version
+  client
+  record
+  parser
+  model/author
+  model/category
+  model/comment
+  model/contact
+  model/content
+  model/playlist
+  model/rating
+  model/subscription
+  model/thumbnail
+  model/user
+  model/video
+  request/base_search
+  request/error
+  request/user_search
+  request/standard_search
+  request/video_upload
+  request/video_search
+  response/video_search
+  middleware/faraday_authheader.rb  
+  middleware/faraday_oauth.rb  
+  middleware/faraday_youtubeit.rb
+  chain_io
+).each{|m| require File.dirname(__FILE__) + '/youtube_it/' + m }

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'date'
+require 'test/unit'
+require 'pp'
+require 'open-uri'
+require 'nokogiri'
+require File.dirname(__FILE__) + '/../lib/youtube_it'
+
+YouTubeIt.logger.level = Logger::ERROR
+

data/test/test_chain_io.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class TestChainIO < Test::Unit::TestCase
+  def setup
+    @klass = YouTubeIt::ChainIO # save typing
+  end
+  
+  def test_should_support_read_from_one_io
+    io = @klass.new "abcd"
+    assert io.respond_to?(:read)
+    assert_equal "ab", io.read(2)
+    assert_equal "cd", io.read(2)
+    assert_equal false, io.read(2)
+  end
+  
+  def test_should_skip_over_depleted_streams
+    io = @klass.new '', '', '', '', 'ab'
+    assert_equal 'ab', io.read(2)
+  end
+  
+  def test_should_read_across_nultiple_streams_with_large_offset
+    io = @klass.new 'abc', '', 'def', '', 'ghij'
+    assert_equal 'abcdefgh', io.read(8)
+  end
+
+  def test_should_return_false_for_empty_items
+    io = @klass.new '', '', '', '', ''
+    assert_equal false, io.read(8)
+  end
+  
+  def test_should_support_overzealous_read
+    io = @klass.new "ab"
+    assert_equal "ab", io.read(5000)
+  end
+  
+  def test_should_predict_expected_length
+    io = @klass.new "ab", "cde"
+    assert_equal 5, io.expected_length
+  end
+
+  def test_should_predict_expected_length_with_prepositioned_io
+    first_buf = StringIO.new("ab")
+    first_buf.read(1)
+    
+    io = @klass.new first_buf, "cde"
+    assert_equal 4, io.expected_length
+  end
+  
+  def test_should_predict_expected_length_with_file_handle
+    test_size = File.size(__FILE__)
+    first_buf = StringIO.new("ab")
+    first_buf.read(1)
+    
+    io = @klass.new File.open(__FILE__), first_buf
+    assert_equal test_size + 1, io.expected_length
+  end
+  
+  def test_greedy
+    io = YouTubeIt::GreedyChainIO.new("a" * (1024 * 513))
+    chunk = io.read(123)
+    assert_equal 1024 * 512, chunk.length, "Should have read the first 512 KB chunk at once instead"
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,418 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class TestClient < Test::Unit::TestCase
+
+  OPTIONS = {:title => "test title",
+             :description => "test description",
+             :category => 'People',
+             :keywords => %w[test]}
+  ACCOUNT = {:user => "tubeit20101", :passwd => "youtube_it", :dev_key => "AI39si411VBmO4Im9l0rfRsORXDI6F5AX5NlTIA4uHSWqa-Cgf-jUQG-6osUBB3PTLawLHlkKXPLr3B0pNcGU9wkNd11gIgdPg" }
+  RAILS_ENV = "test"
+
+  def setup
+    #clientlogin
+    @client = YouTubeIt::Client.new(:username => ACCOUNT[:user], :password => ACCOUNT[:passwd] , :dev_key => ACCOUNT[:dev_key])
+    #authsub
+    #@client  = YouTubeIt::AuthSubClient.new(:token => "1/vqYlJytmn4eWRjJnORHT94mENNfZzZsLutMOrvvygB4" , :dev_key => ACCOUNT[:dev_key])
+  end
+
+  def test_should_respond_to_a_basic_query
+    response = @client.videos_by(:query => "penguin")
+  
+    assert_equal "tag:youtube.com,2008:videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 25, response.videos.length
+    assert_equal 1, response.offset
+    assert(response.total_result_count > 100)
+    assert_instance_of Time, response.updated_at
+  
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+    def test_should_respond_to_a_basic_query_with_offset_and_max_results
+    response = @client.videos_by(:query => "penguin", :offset => 15, :max_results => 30)
+  
+    assert_equal "tag:youtube.com,2008:videos", response.feed_id
+    assert_equal 30, response.max_result_count
+    assert_equal 30, response.videos.length
+    assert_equal 15, response.offset
+    assert(response.total_result_count > 100)
+    assert_instance_of Time, response.updated_at
+  
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_respond_to_a_basic_query_with_paging
+    response = @client.videos_by(:query => "penguin")
+    assert_equal "tag:youtube.com,2008:videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 1, response.offset
+  
+      response = @client.videos_by(:query => "penguin", :page => 2)
+    assert_equal "tag:youtube.com,2008:videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 26, response.offset
+  
+    response2 = @client.videos_by(:query => "penguin", :page => 3)
+    assert_equal "tag:youtube.com,2008:videos", response2.feed_id
+    assert_equal 25, response2.max_result_count
+    assert_equal 51, response2.offset
+  end
+  
+  def test_should_get_videos_for_multiword_metasearch_query
+    response = @client.videos_by(:query => 'christina ricci')
+  
+    assert_equal "tag:youtube.com,2008:videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 25, response.videos.length
+    assert_equal 1, response.offset
+    assert(response.total_result_count > 100)
+    assert_instance_of Time, response.updated_at
+  
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_handle_video_not_yet_viewed
+    response = @client.videos_by(:query => "CE62FSEoY28")
+  
+    assert_equal 1, response.videos.length
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_one_tag
+    response = @client.videos_by(:tags => ['panther'])
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_multiple_tags
+    response = @client.videos_by(:tags => ['tiger', 'leopard'])
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_one_category
+    response = @client.videos_by(:categories => [:news])
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_multiple_categories
+    response = @client.videos_by(:categories => [:news, :sports])
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  # TODO: Need to do more specific checking in these tests
+  # Currently, if a URL is valid, and videos are found, the test passes regardless of search criteria
+  def test_should_get_videos_for_categories_and_tags
+    response = @client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football'])
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_most_viewed_videos
+    response = @client.videos_by(:most_viewed)
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_top_rated_videos_for_today
+    response = @client.videos_by(:top_rated, :time => :today)
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_categories_and_tags_with_category_boolean_operators
+    response = @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
+                                 :tags => { :include => ['football'], :exclude => ['soccer'] })
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_categories_and_tags_with_tag_boolean_operators
+    response = @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
+                                 :tags => { :either => ['football', 'soccer', 'polo'] })
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_by_user
+    response = @client.videos_by(:user => 'liz')
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_by_user_with_pagination_and_ordering
+    response = @client.videos_by(:user => 'liz', :page => 2, :per_page => '2', :order_by => 'published')
+    response.videos.each { |v| assert_valid_video v }
+    assert_equal 3, response.offset
+    assert_equal 2, response.max_result_count
+  end
+  
+  
+  def test_should_get_favorite_videos_by_user
+    response = @client.videos_by(:favorites, :user => 'drnicwilliams')
+    assert_equal "tag:youtube.com,2008:user:drnicwilliams:favorites", response.feed_id
+    assert_valid_video response.videos.first
+  end
+  
+  def test_should_get_videos_for_query_search_with_categories_excluded
+    video = @client.video_by("EkF4JD2rO3Q")
+    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    assert_valid_video video
+  end
+  
+  def test_should_get_video_from_user
+    video = @client.video_by_user("chebyte","FQK1URcxmb4")
+    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    assert_valid_video video
+  end
+  
+  def test_should_always_return_a_logger
+    @client = YouTubeIt::Client.new
+    assert_not_nil @client.logger
+  end
+  
+  def test_should_not_bail_if_debug_is_true
+    assert_nothing_raised { YouTubeIt::Client.new(:debug => true) }
+  end
+  
+  def test_should_determine_if_embeddable_video_is_embeddable
+    response = @client.videos_by(:query => "strongbad")
+  
+    video = response.videos.first
+    assert video.embeddable?
+  end
+  
+  def test_should_retrieve_video_by_id
+    video = @client.video_by("http://gdata.youtube.com/feeds/videos/EkF4JD2rO3Q")
+    assert_valid_video video
+  
+    video = @client.video_by("EkF4JD2rO3Q")
+    assert_valid_video video
+  end
+  
+  def test_return_upload_info_for_upload_from_browser
+    response = @client.upload_token(OPTIONS)
+    assert response.kind_of?(Hash)
+    assert_equal response.size, 2
+    response.each do |k,v|
+      assert v
+    end
+  end
+  
+  def test_should_upload_a_video
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+    assert_valid_video video
+    @client.video_delete(video.unique_id)
+  end
+  
+  def test_should_update_a_video
+    OPTIONS[:title] = "title changed"
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+    updated_video  = @client.video_update(video.unique_id, OPTIONS)
+    assert updated_video.title == "title changed"
+    @client.video_delete(video.unique_id)
+  end
+  
+  def test_should_delete_video
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+    assert_valid_video video
+    assert @client.video_delete(video.unique_id)
+  end
+  
+  def test_should_denied_comments
+    video     = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:comment => "denied"))
+    assert_valid_video video
+    doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video.unique_id}"))
+    doc.css('.comments-disabled-message').each{|tag| assert (tag.content.strip == "Adding comments has been disabled for this video.")}
+    @client.video_delete(video.unique_id)
+  end
+  
+  def test_should_denied_rate
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:rate => "denied"))
+    assert_valid_video video
+    doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video.unique_id}"))
+    doc.css('#watch-like').each{|tag|; assert (tag.attributes["title"].to_s == "Ratings have been disabled for this video.")}
+    @client.video_delete(video.unique_id)
+  end
+  
+  def test_should_denied_embed
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:embed => "denied"))
+    assert    video.noembed
+    @client.video_delete(video.unique_id)
+  end
+  
+
+  def test_should_add_new_comment
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+    @client.add_comment(video.unique_id, "test comment")
+    comment = @client.comments(video.unique_id).first.content
+    assert comment.match(/test comment/)
+    @client.video_delete(video.unique_id)
+  end
+    
+  def test_should_add_and_delete_video_from_playlist
+    playlist = @client.add_playlist(:title => "youtube_it test!", :description => "test playlist")
+    video = @client.add_video_to_playlist(playlist.playlist_id,"iKqJ8z1DPrQ")
+    assert_equal video[:code].to_i, 201
+    assert @client.delete_video_from_playlist(playlist.playlist_id, video[:playlist_entry_id])
+    assert @client.delete_playlist(playlist.playlist_id)
+  end
+  
+  def test_should_add_and_delete_new_playlist
+    result = @client.add_playlist(:title => "youtube_it test4!", :description => "test playlist")
+    assert result.title, "youtube_it test!"
+    sleep 4
+    assert @client.delete_playlist(result.playlist_id)
+  end
+  
+  def test_should_update_playlist
+    playlist = @client.add_playlist(:title => "youtube_it test!", :description => "test playlist")
+    playlist_updated = @client.update_playlist(playlist.playlist_id, :title => "title changed")
+    assert_equal playlist_updated.title, "title changed"
+    assert @client.delete_playlist(playlist.playlist_id)
+  end
+    
+  def test_should_list_playlist_for_user
+    result = @client.playlists('chebyte')
+    assert result.last.title, "rock"
+  end
+    
+  def test_should_determine_if_widescreen_video_is_widescreen
+   widescreen_id = 'QqQVll-MP3I'
+
+   video = @client.video_by(widescreen_id)
+   assert video.widescreen?
+  end
+
+  def test_get_current_user
+   assert_equal @client.current_user, 'tubeit20101'
+  end
+
+  def test_should_get_my_videos
+   video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+   assert_valid_video video
+   result = @client.my_videos
+   assert_equal result.videos.first.unique_id, video.unique_id
+   @client.video_delete(video.unique_id)
+  end
+
+  def test_should_get_my_video
+   video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+   assert_valid_video video
+   result = @client.my_video(video.unique_id)
+   assert_equal result.unique_id, video.unique_id
+   @client.video_delete(video.unique_id)
+  end
+
+  def test_should_add_like_to_video
+   r = @client.like_video("CE62FSEoY28")
+   assert_equal r[:code], 201
+   @client.dislike_video("CE62FSEoY28")
+  end
+
+  def test_should_dislike_to_video
+   @client.like_video("CE62FSEoY28")
+   r = @client.dislike_video("CE62FSEoY28")
+   assert_equal r[:code], 201
+  end
+
+
+  def test_should_subscribe_to_channel
+   r = @client.subscribe_channel("TheWoWArthas")
+   assert_equal r[:code], 201
+   assert_equal @client.subscriptions.first.title, "Videos published by : TheWoWArthas"
+   @client.unsubscribe_channel(@client.subscriptions.first.id)
+  end
+
+  def test_should_unsubscribe_to_channel
+   @client.subscribe_channel("TheWoWArthas")
+   r = @client.unsubscribe_channel(@client.subscriptions.first.id)
+   assert_equal r[:code], 200
+  end
+
+  def test_should_list_subscriptions
+   @client.subscribe_channel("TheWoWArthas")
+   assert @client.subscriptions.count == 1
+   assert_equal @client.subscriptions.first.title, "Videos published by : TheWoWArthas"
+   @client.unsubscribe_channel(@client.subscriptions.first.id)
+  end
+     
+  def test_should_get_profile
+    profile = @client.profile
+    assert_equal profile.username, "tubeit20101" 
+  end
+
+  def test_should_add_and_delete_video_to_favorite
+    video_id ="j5raG94IGCc"
+    result = @client.add_favorite(video_id)
+    assert_equal result[:code], 201
+    sleep 4
+    assert @client.delete_favorite(video_id)
+  end
+
+  private
+  
+    def assert_valid_video (video)
+      # check general attributes
+      assert_instance_of YouTubeIt::Model::Video, video
+      assert_instance_of Fixnum, video.duration
+      assert_instance_of String, video.html_content if video.html_content
+  
+      # validate media content records
+      video.media_content.each do |media_content|
+        assert_valid_url media_content.url
+        assert_instance_of YouTubeIt::Model::Video::Format, media_content.format
+        assert_instance_of String, media_content.mime_type
+        assert_match(/^[^\/]+\/[^\/]+$/, media_content.mime_type)
+      end
+  
+      default_content = video.default_media_content
+      if default_content
+        assert_instance_of YouTubeIt::Model::Content, default_content
+        assert default_content.is_default?
+      end
+  
+      # validate keywords
+      video.keywords.each { |kw| assert_instance_of(String, kw) }
+  
+      # http://www.youtube.com/watch?v=IHVaXG1thXM
+      assert_valid_url video.player_url
+      assert_instance_of Time, video.published_at
+  
+      # validate optionally-present rating
+      if video.rating
+        assert_instance_of YouTubeIt::Model::Rating, video.rating
+        assert_instance_of Float, video.rating.average
+        assert_instance_of Fixnum, video.rating.max
+        assert_instance_of Fixnum, video.rating.min
+        assert_instance_of Fixnum, video.rating.rater_count
+      end
+  
+      # validate thumbnails
+      assert(video.thumbnails.size > 0)
+  
+      assert_not_nil video.title
+      assert_instance_of String, video.title
+      assert(video.title.length > 0)
+  
+      assert_instance_of Time, video.updated_at
+      # http://gdata.youtube.com/feeds/videos/IHVaXG1thXM
+      assert_valid_url video.unique_id
+      assert_instance_of Fixnum, video.view_count
+      assert_instance_of Fixnum, video.favorite_count
+  
+      # validate author
+      assert_instance_of YouTubeIt::Model::Author, video.author
+      assert_instance_of String, video.author.name
+      assert(video.author.name.length > 0)
+      assert_valid_url video.author.uri
+  
+      # validate categories
+      video.categories.each do |cat|
+        assert_instance_of YouTubeIt::Model::Category, cat
+        assert_instance_of String, cat.label
+        assert_instance_of String, cat.term
+      end
+    end
+  
+    def assert_valid_url (url)
+      URI::parse(url)
+      return true
+    rescue
+      return false
+    end
+end
+

data/test/test_field_search.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class YouTubeIt
+  module Request
+    class TestSearch < BaseSearch
+      include FieldSearch
+
+      def initialize(params={})
+        @url = fields_to_params(params.delete(:fields))
+      end 
+    end
+  end
+end
+
+class TestFieldSearch < Test::Unit::TestCase
+  include YouTubeIt::Request
+
+  def default_fields
+    "id,updated,openSearch:totalResults,openSearch:startIndex,openSearch:itemsPerPage"
+  end
+
+  def test_should_search_for_range_of_recoreded_on_dates
+    starts_at = Date.today - 4
+    ends_at = Date.today
+    request = TestSearch.new(:fields => {:recorded => (starts_at..ends_at)})
+    assert_equal URI.escape("&fields=#{default_fields},entry[xs:date(yt:recorded) > xs:date('#{starts_at.strftime('%Y-%m-%d')}') and xs:date(yt:recorded) < xs:date('#{ends_at.strftime('%Y-%m-%d')}')]"), request.url
+  end
+
+ def test_should_search_for_recoreded_on_date
+    recorded_at = Date.today
+    request = TestSearch.new(:fields => {:recorded => recorded_at})
+    assert_equal URI.escape("&fields=#{default_fields},entry[xs:date(yt:recorded) = xs:date('#{recorded_at.strftime('%Y-%m-%d')}')]"), request.url
+  end
+
+  def test_should_search_for_range_of_published_on_dates
+    starts_at = Date.today - 4
+    ends_at = Date.today
+    request = TestSearch.new(:fields => {:published => (starts_at..ends_at)})
+    assert_equal URI.escape("&fields=#{default_fields},entry[xs:dateTime(published) > xs:dateTime('#{starts_at.strftime('%Y-%m-%d')}T00:00:00') and xs:dateTime(published) < xs:dateTime('#{ends_at.strftime('%Y-%m-%d')}T00:00:00')]"), request.url
+  end
+
+ def test_search_for_published_on_date
+    published_at = Date.today
+    request = TestSearch.new(:fields => {:published => published_at})
+    assert_equal URI.escape("&fields=#{default_fields},entry[xs:date(published) = xs:date('#{published_at.strftime('%Y-%m-%d')}')]"), request.url
+ end
+end
+

data/test/test_video.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class TestVideo < Test::Unit::TestCase
+  def test_should_extract_unique_id_from_video_id
+    video = YouTubeIt::Model::Video.new(:video_id => "tag:youtube.com,2008:video:ZTUVgYoeN_o")
+    assert_equal "ZTUVgYoeN_o", video.unique_id
+  end
+
+  def test_should_extract_unique_id_with_hypen_from_video_id
+    video = YouTubeIt::Model::Video.new(:video_id => "tag:youtube.com,2008:video:BDqs-OZWw9o")
+    assert_equal "BDqs-OZWw9o", video.unique_id
+  end
+
+  def test_should_have_related_videos
+    video = YouTubeIt::Model::Video.new(:video_id => "tag:youtube.com,2008:video:BDqs-OZWw9o")
+    response = video.related
+
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/BDqs-OZWw9o/related", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 25, response.videos.length
+    assert_equal 1, response.offset
+    assert(response.total_result_count > 0)
+    assert_instance_of Time, response.updated_at
+  end
+
+  def test_should_have_response_videos
+    video = YouTubeIt::Model::Video.new(:video_id => "tag:youtube.com,2008:video:BDqs-OZWw9o")
+    response = video.responses
+
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/BDqs-OZWw9o/responses", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 25, response.videos.length
+    assert_equal 1, response.offset
+    assert(response.total_result_count > 0)
+    assert_instance_of Time, response.updated_at
+  end
+
+  def test_should_scale_video_embed
+    video = YouTubeIt::Model::Video.new(:video_id => "tag:youtube.com,2008:video:EkF4JD2rO3Q", :player_url=>"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player", :widescreen => true)
+    assert_equal "<object width=\"1280\" height=\"745\">\n<param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\"></param>\n<param name=\"wmode\" value=\"transparent\"></param>\n<embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\nwmode=\"transparent\" width=\"1280\" height=\"745\"></embed>\n</object>\n", video.embed_html_with_width(1280)
+  end
+end
+