youtube_it 2.1.4 → 2.1.5

data/test/test_field_search.rb

@@ -1,48 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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 "tag:youtube.com,2008:video:BDqs-OZWw9o:related", response.feed_id
-    assert_equal 25, response.max_result_count
-    assert_equal 20, 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 "tag:youtube.com,2008:video: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
-  
-  def test_should_have_iframe_close_tag
-    video = YouTubeIt::Model::Video.new(:video_id => "tag:youtube.com,2008:video:EkF4JD2rO3Q")
-    assert_equal "<iframe class=\"\" id=\"\" type=\"text/html\" width=\"425\" height=\"350\" src=\"http://www.youtube.com/embed/EkF4JD2rO3Q\" frameborder=\"0\"></iframe>\n", video.embed_html5
-  end
-end
-

data/test/test_video_feed_parser.rb

@@ -1,271 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestVideoFeedParser < Test::Unit::TestCase
-
-  def test_should_raise_bad_request_exception_when_id_not_found
-    bad_url = "http://gdata.youtube.com/feeds/api/videos/abc?v=2"
-  
-    assert_raise(OpenURI::HTTPError) do
-      parser = YouTubeIt::Parser::VideoFeedParser.new bad_url
-    end
-  end
-
-  # VIDEO ATTRIBUTES AFFECTED BY PARSING
-
-  def test_should_display_unique_id_correctly_after_parsing
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "AbC123DeFgH", video.unique_id
-    end
-  end
-
-  # PARSED VIDEO ATTRIBUTES
-  def test_should_parse_duration_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 356, video.duration
-    end
-  end
-
-  def test_should_parse_widescreen_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal true, video.widescreen?
-    end
-  end
-
-  def test_should_parse_noembed_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal false, video.noembed
-    end
-  end
-
-  def test_should_parse_racy_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal false, video.racy
-    end
-  end
-
-  def test_should_parse_video_id_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "tag:youtube.com,2008:video:AbC123DeFgH", video.video_id
-    end
-  end
-
-  def test_should_parse_published_at_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal Time.parse("Wed Dec 29 13:57:49 UTC 2010"), video.published_at
-    end
-  end
-
-  def test_should_parse_updated_at_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal Time.parse("Wed Feb 23 13:54:16 UTC 2011"), video.updated_at
-    end
-  end
-  
-  def test_should_parse_categories_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "Test", video.categories.first.label
-      assert_equal "Test", video.categories.first.term
-    end
-  end
-
-  def test_should_parse_keywords_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal ["test"], video.keywords
-    end
-  end
-
-  def test_should_parse_description_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "Youtube Test Video", video.description
-    end
-  end
-
-  def test_should_parse_title_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "YouTube Test Video", video.title
-    end
-  end
-
-  def test_should_parse_html_content_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal nil, video.html_content
-    end
-  end
-
-  def test_should_parse_thumbnails_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      thumbnail = video.thumbnails.first
-      assert_equal 90, thumbnail.height
-      assert_equal "00:02:58", thumbnail.time
-      assert_equal "http://i.ytimg.com/vi/AbC123DeFgH/default.jpg", thumbnail.url
-      assert_equal 120, thumbnail.width
-    end
-  end
-
-  def test_should_parse_player_url_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "http://www.youtube.com/watch?v=AbC123DeFgH&feature=youtube_gdata_player", video.player_url
-    end
-  end
-
-  def test_should_parse_view_count_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 240000, video.view_count
-    end
-  end
-
-  def test_should_parse_favorite_count_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 200, video.favorite_count
-    end
-  end
-
-  # RATING
-
-  def test_should_parse_average_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 4.305027, video.rating.average
-    end
-  end
-
-  def test_should_parse_max_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 5, video.rating.max
-    end
-  end
-
-  def test_should_parse_min_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 1, video.rating.min
-    end
-  end
-
-  def test_should_parse_rater_count_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 2049, video.rating.rater_count
-    end
-  end
-
-  def test_should_parse_likes_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 1700, video.rating.likes
-    end
-  end
-
-  def test_should_parse_dislikes_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal 350, video.rating.dislikes
-    end
-  end
-  
-  # TOD: GEODATA
-
-  def test_should_parse_where_geodata_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal nil, video.where
-    end
-  end
-  
-  def test_should_parse_position_geodata_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal nil, video.position
-    end
-  end
-  
-  def test_should_parse_latitude_geodata_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal nil, video.latitude
-    end
-  end
-  
-  def test_should_parse_longitude_geodata_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal nil, video.longitude
-    end
-  end
-
-  # AUTHOR
-
-  def test_should_parse_author_name_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "Test user", video.author.name
-    end
-  end
-
-  def test_should_parse_author_uri_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      assert_equal "http://gdata.youtube.com/feeds/api/users/test_user", video.author.uri
-    end
-  end
-
-  # MEDIA CONTENT
-
-  def test_should_parse_if_media_content_is_default_content_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      content = video.media_content.first
-      assert_equal true, content.default
-    end
-  end
-
-  def test_should_parse_duration_of_media_contents_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      content = video.media_content.first
-      assert_equal 356, content.duration
-    end
-  end
-  
-  def test_should_parse_mime_type_of_media_content_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      content = video.media_content.first
-      assert_equal "application/x-shockwave-flash", content.mime_type
-    end
-  end
-
-  def test_should_parse_url_of_media_content_correctly
-    with_video_response do |parser|
-      video = parser.parse
-      content = video.media_content.first
-      assert_equal "http://www.youtube.com/v/AbC123DeFgH?f=videos&app=youtube_gdata", content.url
-    end
-  end
-
-  def with_video_response &block
-    File.open(File.dirname(__FILE__) + '/files/youtube_video_response.xml') do |xml|
-      parser = YouTubeIt::Parser::VideoFeedParser.new xml.read
-      yield parser
-    end
-  end
-    
-end

data/test/test_video_search.rb

@@ -1,147 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestVideoSearch < Test::Unit::TestCase
-
-  def test_should_build_basic_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:query => "penguin")
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?q=penguin&v=2", request.url
-  end
-
-  def test_should_build_multiword_metasearch_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:query => 'christina ricci')
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?q=christina+ricci&v=2", request.url
-  end
-
-  def test_should_build_video_id_url
-    request = YouTubeIt::Request::VideoSearch.new(:video_id => 'T7YazwP8GtY')
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/T7YazwP8GtY?v=2", request.url
-  end
-
-  def test_should_build_one_tag_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:tags => ['panther'])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/panther/?v=2", request.url
-  end
-
-  def test_should_build_multiple_tags_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:tags => ['tiger', 'leopard'])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/tiger/leopard/?v=2", request.url
-  end
-
-  def test_should_build_one_category_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:categories => [:news])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/?v=2", request.url
-  end
-
-  def test_should_build_multiple_categories_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:categories => [:news, :sports])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/?v=2", request.url
-  end
-
-  def test_should_build_categories_and_tags_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:categories => [:news, :sports], :tags => ['soccer', 'football'])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/soccer/football/?v=2", request.url
-  end
-
-  def test_should_build_categories_and_tags_url_with_max_results
-    request = YouTubeIt::Request::VideoSearch.new(:categories => [:music], :tags => ['classic', 'rock'], :max_results => 2)
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/Music/classic/rock/?max-results=2&v=2", request.url
-  end
-
-  def test_should_build_author_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:author => "davidguetta")
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?author=davidguetta&v=2", request.url
-  end
-
-  def test_should_build_language_query_url
-    request = YouTubeIt::Request::VideoSearch.new(:query => 'christina ricci', :lang => 'pt')
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?lr=pt&q=christina+ricci&v=2", request.url
-  end
-
-  # -- Standard Feeds --------------------------------------------------------------------------------
-
-  def test_should_build_url_for_most_viewed
-    request = YouTubeIt::Request::StandardSearch.new(:most_viewed)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed?v=2", request.url
-  end
-
-  def test_should_build_url_for_top_rated_for_today
-    request = YouTubeIt::Request::StandardSearch.new(:top_rated, :time => :today)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today&v=2", request.url
-  end
-
-  def test_should_build_url_for_most_viewed_offset_and_max_results_without_time
-    request = YouTubeIt::Request::StandardSearch.new(:top_rated, :offset => 5, :max_results => 10)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5&v=2", request.url
-  end
-
-  def test_should_build_url_for_most_viewed_offset_and_max_results_with_time
-    request = YouTubeIt::Request::StandardSearch.new(:top_rated, :offset => 5, :max_results => 10, :time => :today)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5&time=today&v=2", request.url
-  end
-
-  def test_should_raise_exception_for_invalid_type
-    assert_raise RuntimeError do
-      request = YouTubeIt::Request::StandardSearch.new(:most_viewed_yo)
-    end
-  end
-
-  # -- Complex Video Queries -------------------------------------------------------------------------
-
-  def test_should_build_url_for_boolean_or_case_for_categories
-    request = YouTubeIt::Request::VideoSearch.new(:categories => { :either => [:news, :sports] })
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/?v=2", request.url
-  end
-
-  def test_should_build_url_for_boolean_or_and_exclude_case_for_categories
-    request = YouTubeIt::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] })
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/?v=2", request.url
-  end
-
-  def test_should_build_url_for_exclude_case_for_tags
-    request = YouTubeIt::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
-                                                 :tags => { :include => ['football'], :exclude => ['soccer'] })
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/football/-soccer/?v=2", request.url
-  end
-
-  def test_should_build_url_for_either_case_for_tags
-    request = YouTubeIt::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
-                                                 :tags => { :either => ['soccer', 'football', 'donkey'] })
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/soccer%7Cfootball%7Cdonkey/?v=2", request.url
-  end
-
-  def test_should_build_url_for_query_search_with_categories_excluded
-    request = YouTubeIt::Request::VideoSearch.new(:query => 'bench press',
-                                                 :categories => { :exclude => [:comedy, :entertainment] },
-                                                 :max_results => 10)
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/-Comedy/-Entertainment/?max-results=10&q=bench+press&v=2", request.url
-  end
-
-  # -- User Queries ---------------------------------------------------------------------------------
-
-  def test_should_build_url_for_videos_by_user
-    request = YouTubeIt::Request::UserSearch.new(:user => 'liz')
-    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/uploads?v=2", request.url
-  end
-
-  def test_should_build_url_for_videos_by_user_paginate_and_order
-    request = YouTubeIt::Request::UserSearch.new(:user => 'liz', :offset => 20, :max_results => 10, :order_by => 'published')
-    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/uploads?max-results=10&orderby=published&start-index=20&v=2", request.url
-  end
-
-  def test_should_build_url_for_favorite_videos_by_user
-    request = YouTubeIt::Request::UserSearch.new(:favorites, :user => 'liz')
-    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/favorites?v=2", request.url
-  end
-
-  def test_should_build_url_for_favorite_videos_by_user_paginate
-    request = YouTubeIt::Request::UserSearch.new(:favorites, :user => 'liz', :offset => 20, :max_results => 10)
-    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/favorites?max-results=10&start-index=20&v=2", request.url
-  end
-  
-  # -- Queries with restrictions ---------------------------------------------------------------------------------
-  
-  def test_should_build_basic_query_url_with_restriction
-    request = YouTubeIt::Request::VideoSearch.new(:query => "penguin", :restriction => "DE")
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?q=penguin&restriction=DE&v=2", request.url
-  end
-end