msp-youtube-g 0.4.6 → 0.4.7

data/History.txt

@@ -1,5 +1,7 @@
 == trunk
-
+* Move network dependent tests to integration-test [msp]
+* Create a parser and a model for upload errors  [msp]
+* Stub driven tests for VideoFeedParser, VideosFeedParser, UploadErrorParser [msp]
 * Add error-handling for video upload errors. [FiXato]
 * Add error-handling for authentication errors from YouTube during video upload. [FiXato]
 * Add support for making videos private upon video upload. [FiXato]

data/Manifest.txt

@@ -15,11 +15,16 @@ lib/youtube_g/model/rating.rb
 lib/youtube_g/model/thumbnail.rb
 lib/youtube_g/model/user.rb
 lib/youtube_g/model/video.rb
+lib/youtube_g/model/upload_error.rb
 lib/youtube_g/parser.rb
 lib/youtube_g/record.rb
 lib/youtube_g/request/video_search.rb
 lib/youtube_g/request/video_upload.rb
 lib/youtube_g/response/video_search.rb
-test/test_client.rb
-test/test_video.rb
-test/test_video_search.rb
+integration-test/test_client.rb
+integration-test/test_video.rb
+integration-test/test_video_search.rb
+test/test_parser.rb
+test/test_upload.rb
+test/search.xml
+test/upload.xml

data/TODO.txt

@@ -1,10 +1,10 @@
-[ ] stub out http request/response cycle for tests
+[ ] stub out http request/response cycle for tests (partially done in test_parser, need to do the same for pre-existing tests [msp])
 [ ] consider defaulting the client to no-logger, rather than outputting to STDOUT.
 [ ] allow specifying values as single items where you don't need to wrap in a list, e.g. :tags => :chickens instead of :tags => [ 'chickens' ]
 [ ] make sure symbols will work as well as tags everywhere (again, :tags => :chickens is same as :tags => 'chickens')
 [ ] figure out better structure for class/file (either rename request/video_search.rb or split into one class per file again)
 [ ] restore spaces after method def names
-[ ] use a proxy for testing with static sample result xml so we have repeatable tests
+[ ] use a proxy for testing with static sample result xml so we have repeatable tests (see above [msp])
 [ ] Clean up tests using Shoulda to define contexts
 [ ] Consolidate requires
 [ ] Allow :category and :categories for query DSL
@@ -15,4 +15,4 @@
 [ ] Profile feed parsing
 [ ] Playlist feeds
 [ ] User subscriptions
-[ ] Video comments
+[ ] Video comments

data/lib/youtube_g.rb

@@ -9,11 +9,12 @@ require File.dirname(__FILE__) + '/youtube_g/model/playlist'
 require File.dirname(__FILE__) + '/youtube_g/model/rating'
 require File.dirname(__FILE__) + '/youtube_g/model/thumbnail'
 require File.dirname(__FILE__) + '/youtube_g/model/user'
-require File.dirname(__FILE__) + '/youtube_g/model/video'
+require File.dirname(__FILE__) + '/youtube_g/model/video' 
+require File.dirname(__FILE__) + '/youtube_g/model/upload_error' 
 require File.dirname(__FILE__) + '/youtube_g/request/video_upload'
 require File.dirname(__FILE__) + '/youtube_g/request/video_search'
 require File.dirname(__FILE__) + '/youtube_g/response/video_search'
 
 class YouTubeG
-  VERSION = '0.4.5'
+  VERSION = '0.4.7'
 end

data/lib/youtube_g/model/video.rb

@@ -34,14 +34,23 @@ class YouTubeG
         SWF = YouTubeG::Model::Video::Format.new(5, :swf)
         
         THREE_GPP = YouTubeG::Model::Video::Format.new(6, :three_gpp)
+      end 
+       
+      
+      # Used in video uploads only to check the state of the upload
+      class AppControl < YouTubeG::Record
+         attr_reader :draft
+         attr_reader :state
       end
-
+            
       attr_reader :duration
       attr_reader :noembed
       attr_reader :position
       attr_reader :racy
       attr_reader :statistics
       
+      attr_reader :app_control
+      
       attr_reader :video_id
       attr_reader :published_at
       attr_reader :updated_at

data/lib/youtube_g/parser.rb

@@ -3,17 +3,55 @@ require 'open-uri'
 require 'rexml/document'
 
 class YouTubeG
-  module Parser
-    class FeedParser
-      def initialize(url)
-        @url = url
+  module Parser      
+    class FeedParserError < Exception; end
+      
+    class FeedParser    
+      attr_reader :url_based
+      alias :url_based? :url_based
+
+      def initialize(arg)                    
+        @url_based = assert_valid_url(arg)
+        @content = arg
       end
       
+      def parse                
+        if @url_based
+          parse_content open(@content).read 
+        else
+          parse_content @content  
+        end
+      end  
+      
+      private
+      def assert_valid_url (url)
+        URI::parse(url)
+        return true
+      rescue
+        return false
+      end          
+    end
+     
+    class UploadErrorParser   
+      def initialize(xml)
+        raise YouTubeG::Parser::FeedParserError.new("You must pass some xml") if xml == ''
+        @doc = REXML::Document.new(xml)         
+      end 
+      
       def parse
-        parse_content open(@url).read
-      end      
+        upload_errors = []
+                         
+        @doc.elements.each("//error") do |error|
+          location = error.elements["location"].text   #[/media:group\/media:(.*)\/text\(\)/,1]
+          code = error.elements["code"].text                   
+          domain = error.elements["domain"].text            
+          upload_errors << YouTubeG::Model::UploadError.new(:location => location, :code => code, :domain => domain)
+        end                                    
+        
+        return upload_errors
+      end   
     end
-
+    
     class VideoFeedParser < FeedParser
       
       def parse_content(content)
@@ -27,7 +65,15 @@ class YouTubeG
       def parse_entry(entry)
         video_id = entry.elements["id"].text
         published_at = Time.parse(entry.elements["published"].text)
-        updated_at = Time.parse(entry.elements["updated"].text)
+        updated_at = Time.parse(entry.elements["updated"].text)           
+                              
+        app_control_element = entry.elements["app:control"]     
+        app_contrlol = nil
+        if app_control_element
+          app_control = YouTubeG::Model::Video::AppControl.new(
+                     :draft => app_control_element.elements["app:draft"].text,
+                     :state => app_control_element.elements["yt:state"].attributes["name"])
+        end        
 
         # parse the category and keyword lists
         categories = []
@@ -61,14 +107,14 @@ class YouTubeG
       
         media_group = entry.elements["media:group"]
         description = media_group.elements["media:description"].text
-        duration = media_group.elements["yt:duration"].attributes["seconds"].to_i
+        duration = media_group.elements["yt:duration"].attributes["seconds"].to_i if media_group.elements["yt:duration"]
 
         media_content = []
         media_group.elements.each("media:content") do |mce|
           media_content << parse_media_content(mce)
         end
 
-        player_url = media_group.elements["media:player"].attributes["url"]
+        player_url = media_group.elements["media:player"].attributes["url"] if media_group.elements["media:player"]
 
         # parse thumbnails
         thumbnails = []
@@ -99,7 +145,8 @@ class YouTubeG
         YouTubeG::Model::Video.new(
           :video_id => video_id,
           :published_at => published_at,
-          :updated_at => updated_at,
+          :updated_at => updated_at, 
+          :app_control => app_control,
           :categories => categories,
           :keywords => keywords,
           :title => title,
@@ -131,7 +178,7 @@ class YouTubeG
           :mime_type => mime_type,
           :default => default)
       end      
-    end
+    end   
 
     class VideosFeedParser < VideoFeedParser
 
@@ -160,6 +207,6 @@ class YouTubeG
           :videos => videos)
       end
     end
-    
+      
   end 
 end

data/lib/youtube_g/request/video_upload.rb

@@ -20,6 +20,7 @@ class YouTubeG
     class VideoUpload
       
       attr_accessor :auth_token
+
       def initialize user, pass, dev_key, client_id = 'youtube_g', auth_token = nil
         @user, @pass, @dev_key, @client_id, @auth_token = user, pass, dev_key, client_id, auth_token
       end         
@@ -30,7 +31,7 @@ class YouTubeG
            Logger.new(STDOUT)
         else
            eval(get_rails_default_logger_name)
-        end
+        end                                                                                                             
       end  
       
       def get_rails_default_logger_name
@@ -81,22 +82,18 @@ class YouTubeG
 
         Net::HTTP.start(base_url) do |upload|
           response = upload.post(direct_upload_url, upload_body, upload_header)
-          if response.code.to_i == 403
+          # todo parse this out also
+          if response.code.to_i == 403                      
             raise AuthenticationError, response.body[/<TITLE>(.+)<\/TITLE>/, 1]
-          elsif response.code.to_i != 201
-            upload_error = ''
-            xml = REXML::Document.new(response.body)
-            errors = xml.elements["//errors"]
-            errors.each do |error|
-              location = error.elements["location"].text[/media:group\/media:(.*)\/text\(\)/,1]
-              code = error.elements["code"].text
-              upload_error << sprintf("%s: %s\r\n", location, code)
-            end
-            raise UploadError, upload_error
-          end
+          elsif response.code.to_i != 201    
+            upload_errors = YouTubeG::Parser::UploadErrorParser.new(response.body).parse
+            raise UploadError, upload_errors.inspect
+          end 
+          return YouTubeG::Parser::VideoFeedParser.new(response.body).parse
         end
 
-      end
+      end   
+      
 
       private
 
@@ -115,7 +112,7 @@ class YouTubeG
           body = "Email=#{CGI::escape @user}&Passwd=#{CGI::escape @pass}&service=youtube&source=#{CGI::escape @client_id}"
           logger.debug("auth body [#{body}]")
           response = http.post("/youtube/accounts/ClientLogin", body, "Content-Type" => "application/x-www-form-urlencoded")
-          raise UploadError, ""+response.body[/Error=(.+)/,1] if response.code.to_i != 200
+          raise UploadError, response.body[/Error=(.+)/,1] if response.code.to_i != 200
           logger.debug("response.body [#{response.body}]")
           @auth_token = response.body[/Auth=(.+)/, 1]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: msp-youtube-g
 version: !ruby/object:Gem::Version 
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors: 
 - Shane Vitarana

data/test/test_client.rb

@@ -1,226 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-
-require 'youtube_g'
-
-class TestClient < Test::Unit::TestCase
-  def setup
-    @client = YouTubeG::Client.new
-  end
-
-  def test_should_respond_to_a_basic_query
-    response = @client.videos_by(:query => "penguin")
-  
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?start-index=1&max-results=25&vq=penguin", 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_get_videos_for_multiword_metasearch_query
-    response = @client.videos_by(:query => 'christina ricci')
-  
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?start-index=1&max-results=25&vq=christina+ricci", 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 => "YnqHZDh_t2Q")
-
-    assert_equal 1, response.videos.length
-    response.videos.each { |v| assert_valid_video v }
-  end
-
-  # TODO: this doesn't work because the returned feed is in an unknown format
-  # def test_should_get_video_for_search_by_video_id
-  #   response = @client.videos_by(:video_id => "T7YazwP8GtY")
-  #   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
-
-  # HTTP 403 Error
-  # def test_should_get_favorite_videos_by_user
-  #   response = @client.videos_by(:favorites, :user => 'liz')
-  #   response.videos.each { |v| assert_valid_video v }
-  # end
-  
-  def test_should_get_videos_for_query_search_with_categories_excluded
-    response = @client.videos_by(:query => 'bench press', :categories => { :exclude => [:comedy, :entertainment] },
-                                 :max_results => 10)
-    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/BlDWdfTAx8o\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/BlDWdfTAx8o\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", response.videos.first.embed_html
-    response.videos.each { |v| assert_valid_video v }
-  end
-  
-  def test_should_be_able_to_pass_in_logger
-    @client = YouTubeG::Client.new(Logger.new(STDOUT))
-    assert_not_nil @client.logger
-  end
-
-  def test_should_create_logger_if_not_passed_in
-    @client = YouTubeG::Client.new
-    assert_not_nil @client.logger
-  end
-  
-  def test_should_determine_if_nonembeddable_video_is_embeddable
-    response = @client.videos_by(:query => "avril lavigne girlfriend")
-  
-    video = response.videos.first
-    assert !video.can_embed?
-  end
-
-  def test_should_determine_if_embeddable_video_is_embeddable
-    response = @client.videos_by(:query => "strongbad")
-  
-    video = response.videos.first
-    assert video.can_embed?
-  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
-  
-  private
-
-    def assert_valid_video (video)
-      # pp video
-
-      # check general attributes
-      assert_instance_of YouTubeG::Model::Video, video
-      assert_instance_of Fixnum, video.duration
-      assert(video.duration > 0)
-      #assert_match(/^<div style=.*?<\/div>/m, video.html_content)
-      assert_instance_of String, video.html_content
-
-      # validate media content records
-      video.media_content.each do |media_content|
-        # http://www.youtube.com/v/IHVaXG1thXM
-        assert_valid_url media_content.url
-        assert(media_content.duration > 0)
-        assert_instance_of YouTubeG::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 YouTubeG::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 YouTubeG::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.video_id
-      assert_instance_of Fixnum, video.view_count
-
-      # validate author
-      assert_instance_of YouTubeG::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 YouTubeG::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_video.rb

@@ -1,30 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-
-require 'youtube_g'
-
-class TestVideo < Test::Unit::TestCase
-  def test_should_extract_unique_id_from_video_id
-    video = YouTubeG::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/ZTUVgYoeN_o")
-    assert_equal "ZTUVgYoeN_o", video.unique_id
-  end
-
-  def test_should_extract_unique_id_with_hypen_from_video_id
-    video = YouTubeG::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/BDqs-OZWw9o")
-    assert_equal "BDqs-OZWw9o", video.unique_id
-  end
-
-  def test_should_have_related_videos
-    video = YouTubeG::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/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
-    puts response.total_result_count
-    assert(response.total_result_count > 0)
-    assert_instance_of Time, response.updated_at
-  end
-end

data/test/test_video_search.rb

@@ -1,118 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-
-require 'youtube_g'
-
-class TestVideoSearch < Test::Unit::TestCase
-
-  def test_should_build_basic_query_url
-    request = YouTubeG::Request::VideoSearch.new(:query => "penguin")
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?vq=penguin", request.url
-  end
-  
-  def test_should_build_multiword_metasearch_query_url
-    request = YouTubeG::Request::VideoSearch.new(:query => 'christina ricci')
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?vq=christina+ricci", request.url
-  end
-  
-  def test_should_build_video_id_url
-    request = YouTubeG::Request::VideoSearch.new(:video_id => 'T7YazwP8GtY')
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/T7YazwP8GtY", request.url
-  end
-
-  def test_should_build_one_tag_querl_url
-    request = YouTubeG::Request::VideoSearch.new(:tags => ['panther'])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/panther/", request.url
-  end
-  
-  def test_should_build_multiple_tags_query_url
-    request = YouTubeG::Request::VideoSearch.new(:tags => ['tiger', 'leopard'])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/tiger/leopard/", request.url
-  end
-  
-  def test_should_build_one_category_query_url
-    request = YouTubeG::Request::VideoSearch.new(:categories => [:news])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/", request.url
-  end
-  
-  def test_should_build_multiple_categories_query_url
-    request = YouTubeG::Request::VideoSearch.new(:categories => [:news, :sports])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/", request.url
-  end
-  
-  def test_should_build_categories_and_tags_query_url
-    request = YouTubeG::Request::VideoSearch.new(:categories => [:news, :sports], :tags => ['soccer', 'football'])
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/soccer/football/", request.url
-  end
-  
-  def test_should_build_categories_and_tags_url_with_max_results
-    request = YouTubeG::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", request.url
-  end
-  
-  def test_should_build_author_query_url
-    request = YouTubeG::Request::VideoSearch.new(:author => "davidguetta")
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?author=davidguetta", request.url
-  end
-  # -- Standard Feeds --------------------------------------------------------------------------------
-  
-  def test_should_build_url_for_most_viewed
-    request = YouTubeG::Request::StandardSearch.new(:most_viewed)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed", request.url    
-  end
-
-  def test_should_raise_exception_for_invalid_type
-    assert_raise RuntimeError do
-      request = YouTubeG::Request::StandardSearch.new(:most_viewed_yo)
-    end
-  end
-
-  def test_should_build_url_for_top_rated_for_today
-    request = YouTubeG::Request::StandardSearch.new(:top_rated, :time => :today)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today", request.url    
-  end  
-  
-  # -- Complex Video Queries -------------------------------------------------------------------------
-  
-  def test_should_build_url_for_boolean_or_case_for_categories
-    request = YouTubeG::Request::VideoSearch.new(:categories => { :either => [:news, :sports] })
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/", request.url
-  end
-
-  def test_should_build_url_for_boolean_or_and_exclude_case_for_categories
-    request = YouTubeG::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] })
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/", request.url
-  end
-
-  def test_should_build_url_for_exclude_case_for_tags
-    request = YouTubeG::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/", request.url
-  end
-
-  def test_should_build_url_for_either_case_for_tags
-    request = YouTubeG::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/", request.url
-  end
-  
-  def test_should_build_url_for_query_search_with_categories_excluded
-    request = YouTubeG::Request::VideoSearch.new(:query => 'bench press', 
-                                                 :categories => { :exclude => [:comedy, :entertainment] },
-                                                 :max_results => 10)
-    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/-Comedy/-Entertainment/?vq=bench+press&max-results=10", request.url
-  end
-  
-  # -- User Queries ---------------------------------------------------------------------------------
-  
-  def test_should_build_url_for_videos_by_user
-    request = YouTubeG::Request::UserSearch.new(:user => 'liz')
-    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/uploads", request.url
-  end
-  
-  def test_should_build_url_for_favorite_videos_by_user
-    request = YouTubeG::Request::UserSearch.new(:favorites, :user => 'liz')
-    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/favorites", request.url
-  end
-end