torrents 1.0.0

data/spec/shared_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Container::Shared do
+  before(:each) do
+    @shared = Container::Shared.new
+  end
+  context "the download method" do
+    it "should return an empty string when trying to download an empty or non valid URL" do
+      @shared.download("non_working_url").should be_empty
+      @shared.download(nil).should be_empty
+    end
+
+    it "should return the content of the site if called with the right url" do
+      RestClient.should_receive(:get).with("http://example.com", {:timeout => 10, :cookies => nil}).exactly(1).times.and_return("123")
+      @shared.download("http://example.com").should eq("123")
+    end
+  end
+  
+  context "the error method" do
+    it "should have a error method" do
+      lambda {
+        @shared.error("some message")
+        @shared.error("some message", "other")
+      }.should_not raise_error(Exception)
+    end
+  end
+  
+  context "the inner_call" do
+    before(:each) do
+      @load = mock(Object)
+    end
+    
+    it "should call an example method with no arguments" do
+      @shared.should_receive(:load).and_return(@load)
+      @load.should_receive(:example).with.and_return("value") # No arguments
+      @shared.inner_call(:example).should eq("value")
+    end
+    
+    it "should call an example method with arguments" do
+      @shared.should_receive(:load).and_return(@load)
+      @load.should_receive(:example).with("abc").and_return("value") # No arguments
+      @shared.inner_call(:example, "abc").should eq("value")
+    end
+    
+    it "should call an example and rescue an exception" do
+      @shared.should_receive(:load).and_return(lambda{
+        raise NoMethodError.new
+      })
+      
+      @shared.should_receive(:error)
+      @shared.should_receive(:default_values).with(:call).and_return("error")
+      @shared.inner_call(:call).should eq("error")
+    end
+    
+    it "should only catch NoMethodError exception" do
+      lambda {
+        @shared.should_receive(:load).and_return(lambda{
+          raise Exception.new
+        })
+
+        @shared.inner_call(:call).should eq("error")
+      }.should raise_error(Exception)
+    end
+  end
+  
+  context "the default_values method" do
+    it "should return the right value" do
+      {torrent: "", torrents: [], seeders: 1, title: "", details: ""}.each do |method, value|
+        @shared.default_values(method).should eq(value)
+      end
+    end
+    
+    it "should return an empty string if the value isn't in the hash" do
+      @shared.default_values(:random).should eq("")
+    end
+  end
+  
+  context "the load method" do
+    before(:all) do
+      class Test < Container::Shared
+        def initialize
+          @tracker = "the_pirate_bay"
+        end
+      end
+    end
+    it "should create a new instance of any string" do
+      Test.new.load.should be_instance_of(Trackers::ThePirateBay)
+    end
+  end
+  
+  context "the url_cleaner method" do
+    # Read more about the cleaner here
+    # http://stackoverflow.com/questions/4999322/escape-and-download-url-using-ruby
+    it "should be able to clean urls" do
+      list = {}
+      ["{", "}", "|", "\\", "^", "[", "]", "`", " a"].each do |c|
+        list.merge!("http://google.com/#{c}" => "http://google.com/#{CGI::escape(c)}")
+      end
+      
+      list.each do |url, clean|
+        lambda {
+          URI.parse(url)
+        }.should raise_error(URI::InvalidURIError)
+        
+        lambda {
+          URI.parse(@shared.url_cleaner(url)).to_s.should eq(clean)
+        }.should_not raise_error(URI::InvalidURIError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'torrents'
+require 'torrents/container'
+require 'uri'
+require 'yaml'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/torrent_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Container::Torrent do
+  def create_torrent(args = {details: "http://thepiratebay.org/torrent/6173093/", torrent: "http://torrents.thepiratebay.org/6173093/value.torrent", title: "The title", tracker: "the_pirate_bay"})
+    Container::Torrent.new(args)
+  end
+  
+  def valid_url?(url)
+    !! url.match(/(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/i)
+  end
+  
+  def create_torrents(n)
+    torrents = []
+    n.times do |n|
+      torrents << create_torrent({
+        details: "http://thepiratebay.org/torrent/617#{n}093/", 
+        torrent: "http://torrents.thepiratebay.org/617093/value.torrent", 
+        title: "The title", 
+        tracker: "the_pirate_bay"
+      })
+    end
+    
+    torrents
+  end
+  
+  def rest_client
+    RestClient.should_receive(:get).with("http://thepiratebay.org/torrent/6173093/", {:timeout => 10, :cookies => nil}).at_least(1).times.and_return(File.read('spec/data/the_pirate_bay/details.html'))
+  end
+  
+  before(:all) do
+    @torrent = create_torrent
+    @methods = {:details => String, :torrent => String, :title => String, :seeders => Fixnum, :dead? => [TrueClass, FalseClass]}
+  end
+  
+  it "should contain the right accessors" do
+    @methods.each do |method, _|
+      @torrent.methods.should include(method)
+    end
+  end
+  
+  it "should have the right return type" do
+    rest_client
+    @methods.each do |method, type|
+      type.class == Array ? (type.should include(@torrent.send(method).class)) : (@torrent.send(method).should be_instance_of(type))
+    end
+  end
+  
+  it "should have a working valid? method" do
+    [["a", "a", ""], ["a", "a", nil], ["a", "a", "<tag>"], ["a", "a", " a"], ["a", "http://google.com", "a"], ["a", "http://google.com.torrent", "a"], ["a", "http://google.com", "a.torrent"]].each do |option|
+      option.permutation.to_a.uniq.each do |invalid|
+        create_torrent({details: invalid[0], torrent: invalid[1], title: invalid[2], tracker: 'the_pirate_bay'}).should_not be_valid
+      end
+    end
+     
+    create_torrent({details: "http://google.com/123/", torrent: "http://google.com.torrent", title: "a", tracker: "the_pirate_bay"}).should be_valid
+    create_torrent({details: "http://google.com/random/", torrent: "http://google.com.torrent", title: "a", tracker: "the_pirate_bay"}).id.should eq(0)
+  end
+  
+  it "should be dead" do
+    torrent = create_torrent({details: "a", torrent: "a", title: "a", tracker: "a"})
+    torrent.should_receive(:seeders).and_return(0)
+    torrent.should be_dead
+  end
+  
+  it "should not be dead" do
+    torrent = create_torrent
+    torrent.should_receive(:seeders).and_return(1)
+    torrent.should_not be_dead
+  end
+  
+  it "should return the right amount of seeders if it's nil" do
+    torrent = create_torrent
+    torrent.should_receive(:valid_option?).and_return(false)
+    torrent.seeders.should eq(1)
+  end
+  
+  it "should return the right amount of seeders if it's set" do
+    torrent = create_torrent
+    torrent.should_receive(:inner_call).and_return(50)
+    torrent.seeders.should eq(50)
+  end
+  
+  it "should be able to cache requests" do
+    torrent = create_torrent
+    torrent.should_receive(:download).exactly(1).times.and_return("")
+    10.times { torrent.seeders }
+  end
+  
+  it "should have a id method" do
+    torrent = create_torrent
+    torrent.id.should eq(6173093)
+  end
+  
+  it "should have an id 0 if the details url is invalid" do
+    torrent = create_torrent({
+      details: "http://thepiratebay.org/torrent/random/", 
+      torrent: "http://torrents.thepiratebay.org/6173093/value.torrent", 
+      title: "The title", 
+      tracker: "the_pirate_bay"
+    })
+    
+    torrent.id.should eq(0)
+  end
+  
+  it "should have a unique tid (torrent id)" do
+    torrents = create_torrents(100)
+    
+    torrents.map!(&:tid)
+    lambda do
+      torrents.uniq!
+    end.should_not change(torrents, :count)
+  end
+  
+  it "should have a torrent id method that equals the tid method" do
+    create_torrents(100).each do |torrent|
+      torrent.torrent_id.should eq(torrent.tid)
+    end
+  end
+  
+  it "should have a working imdb method" do
+    rest_client
+    
+    valid_url?(create_torrent.imdb).should be_true
+    create_torrent.imdb.should eq("http://www.imdb.com/title/tt0990407")
+  end
+  
+  it "should have a working imdb_id method" do
+    rest_client
+    
+    create_torrent.imdb_id.should eq("tt0990407")
+  end
+  
+  it "should call the find_movie_by_id if a movie if found" do
+    rest_client
+    MovieSearcher.should_receive(:find_movie_by_id).with("tt0990407").and_return("123")
+    
+    create_torrent.movie.should eq("123")
+  end
+  
+  it "should call the find_by_release_name if no movie was found" do
+    torrent = create_torrent
+    torrent.should_receive(:imdb_id).and_return(nil)
+    torrent.should_receive(:title).and_return("my title")
+    MovieSearcher.should_receive(:find_by_release_name).with("my title", :options => {:details => true}).and_return("456")
+    
+    torrent.movie.should eq("456")
+  end
+  
+  context "the subtitle method" do
+    it "should have a working subtitle method, when a imdb id exists" do
+      torrent = create_torrent
+      torrent.should_receive(:imdb_id).at_least(1).times.and_return("tt0990407")
+      torrent.should_receive(:title).and_return("a subtitle")
+      Undertexter.should_receive(:find).with("tt0990407", language: :english).and_return([Struct.new(:title).new("a subtitle")])
+  
+      torrent.subtitle.title.should eq("a subtitle")
+    end
+  
+    it "should also work when the imdb_id is nil" do
+      torrent = create_torrent
+      torrent.should_receive(:imdb_id).at_least(1).times.and_return(nil)
+      torrent.subtitle.should be_nil
+    end
+    
+    it "should be possible to pass arguments to subtitle" do
+      torrent = create_torrent
+      torrent.should_receive(:imdb_id).at_least(1).times.and_return("tt0990407")
+      torrent.should_receive(:title).and_return("a subtitle")
+      Undertexter.should_receive(:find).with("tt0990407", language: :swedish).and_return([Struct.new(:title).new("a subtitle")])
+  
+      torrent.subtitle(:swedish).title.should eq("a subtitle")
+    end
+  end
+
+  
+  it "should have a working title, even when the title is empty from the beginning" do
+    torrent = create_torrent
+    torrent.title.should eq("The title")
+  end
+  
+  it "should have a working torrent method, even when the torrent is empty from the beginning " do
+    torrent = create_torrent
+    valid_url?(torrent.torrent).should be_true
+    torrent.torrent.match(/\.torrent$/)
+  end
+end

data/spec/torrents_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe Torrents do
+  def rest_client(url, type)
+    RestClient.should_receive(:get).with(url, {:timeout => 10, :cookies => nil}).any_number_of_times.and_return(File.read("spec/data/the_pirate_bay/#{type}.html"))
+  end
+   
+  before(:each) do
+    @torrents = Torrents.the_pirate_bay
+  end
+  
+  context "the exists? method" do
+    it "should know if a tracker exists or not" do
+      @torrents.exists?("the_pirate_bay").should be_true
+      @torrents.exists?("random").should be_false
+    end
+  end
+  
+  context "the content method" do
+    it "should return a nokogiri object" do
+      @torrents.should_receive(:url).and_return("data")
+      @torrents.should_receive(:download).with("data").and_return("more data")
+      @torrents.content.should be_instance_of(Nokogiri::HTML::Document)
+    end
+  end
+  
+  context "the inner_page method" do
+    it "should not care about the order of the page, high" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(10)
+      @torrents.page(1)
+      @torrents.inner_page.should eq("10")
+    end
+    
+    it "should return the pre defined value" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(99)
+      @torrents.inner_page.should eq("99")
+    end
+    
+    it "should not care about the order of the page, low" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(0)
+      @torrents.page(1)
+      @torrents.inner_page.should eq("0")
+    end
+    
+    it "should not care about the order of the page, low again" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(1)
+      @torrents.page(1)
+      @torrents.inner_page.should eq("1")
+    end
+    
+    it "should not care about the order of the page, if the page isn't specified, one" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(1)
+      @torrents.inner_page.should eq("1")
+    end
+    
+    it "should not care about the order of the page, if the page isn't specified, high" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(10)
+      @torrents.inner_page.should eq("10")
+    end
+    
+    it "should not care about the order of the page, if the page isn't specified, zero" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(0)
+      @torrents.inner_page.should eq("0")
+    end
+    
+    it "should raise an exception if the page number is lower then 0" do
+      @torrents.should_receive(:inner_start_page_index).any_number_of_times.and_return(0)
+      lambda {
+        @torrents.page(0)
+      }.should raise_error(ArgumentError, "To low page value, remember that the first page has the value 1")
+    end
+  end
+  
+  context "the url method" do
+    it "should return the correct url when the searching" do
+      @torrents.should_receive(:inner_page).and_return("3")
+      @torrents.search("search")
+      @torrents.should_receive(:send).and_return("before_<SEARCH>_middle_<PAGE>_after")
+      @torrents.url.should eq("before_search_middle_3_after")
+    end
+    
+    it "should work when not searching" do
+      @torrents.should_receive(:inner_page).and_return("3")
+      @torrents.should_receive(:send).and_return("before_middle_<PAGE>_after")
+      @torrents.url.should eq("before_middle_3_after")
+    end
+    
+    it "should be possible to list torrents based on a category" do
+      @torrents.category(:movies).page(100).url.should eq("http://thepiratebay.org/browse/201/99/3")
+    end
+    
+    it "should raise an exception if trying to fetch a non existing category" do
+      lambda {
+        @torrents.category(:random).page(100).url
+      }.should raise_error(NotImplementedError)
+    end
+  end
+  
+  context "the add, page, debugger, search method" do
+    it "add" do
+      @torrents.add("random").should be_instance_of(Torrents)
+    end
+    
+    it "page" do
+      @torrents.page(10).should be_instance_of(Torrents)
+    end
+    
+    it "debugger" do
+      @torrents.debugger(true).should be_instance_of(Torrents)
+    end
+    
+    it "search" do
+      @torrents.search("value").should be_instance_of(Torrents)
+    end
+  end
+  
+  context "the method_missing missing" do
+    before(:each) do
+      @torrent = mock(Object)
+    end
+    
+    it "should call inner_call when calling method_missing" do
+      @torrents.should_receive(:inner_call).with(:example, "a").and_return("b")
+      @torrents.method_missing(:inner_example, "a").should eq("b")
+    end
+    
+    it "should raise an exception" do
+      lambda {
+        @torrents.method_missing(:example, "a")
+      }.should raise_error(NoMethodError)
+    end
+    
+    it "should also work with the static method" do
+      Torrents.should_receive(:new).and_return(@torrent)
+      @torrent.should_receive(:exists?).and_return(true)
+      @torrent.should_receive(:add).and_return("some")
+      Torrents.a_random_method.should eq("some")
+    end
+    
+    it "should also raise an exception" do
+      Torrents.should_receive(:new).and_return(@torrent)
+      @torrent.should_receive(:exists?).and_return(false)
+      lambda {
+        Torrents.a_random_method
+      }.should raise_error(Exception)
+    end
+  end
+  
+  context "the results method" do
+    def inner_torrents(times)
+      list = []
+      times.times {list << 1}
+      @torrents.should_receive(:inner_torrents).exactly(1).times.and_return(list)
+    end
+    
+    def prepare
+      torrent = mock(Object)
+      inner_torrents(50)
+      Container::Torrent.should_receive(:new).any_number_of_times.and_return(torrent)
+      torrent.should_receive(:valid?).any_number_of_times.and_return(true)
+    end
+    
+    before(:each) do
+      @torrents.should_receive(:content).and_return("")
+    end
+    
+    it "should return an empty list" do
+      inner_torrents(0)
+      @torrents.results.should be_empty
+    end
+    
+    it "should return a list with items" do
+      prepare
+      @torrents.should have(50).results
+    end
+    
+    it "should be able to cache torrents" do
+      prepare
+      5.times { @torrents.should have(50).results }
+    end
+  end
+  
+  context "the cookies method" do
+    it "should be possible to pass some cookies" do
+      RestClient.should_receive(:get).with("http://thepiratebay.org/recent/0", {:timeout => 10, :cookies => {:session_id => "1234"}}).exactly(1).times.and_return("")
+      @torrents.cookies(:session_id => "1234").content
+    end
+  end
+  
+  context "the find_by_details method" do
+    it "should be possible to add a details link and get appropriate data" do
+      rest_client("http://thepiratebay.org/torrent/6173093/", "details")
+      torrent = Torrents.the_pirate_bay.find_by_details("http://thepiratebay.org/torrent/6173093/")
+      
+      # Makes sure that all methods returnes something
+      [:seeders, :title, :dead?, :imdb, :imdb_id, :domain, :id].each do |method|
+        torrent.send(method).to_s.should_not be_empty
+      end
+      
+      torrent.should_not be_dead
+      torrent.seeders.should eq(9383)
+      torrent.tid.should_not be_empty
+      torrent.domain.should eq("thepiratebay.org")
+    end
+  end
+  
+  context "the errors method" do
+    before(:each) do
+      rest_client("http://thepiratebay.org/recent/0", "recent")
+    end
+    
+    it "should return the right error messages" do
+      errors = @torrents.errors
+      
+      [
+        "An error occurred in the the_pirate_bay class at the details method.\n#<NoMethodError: undefined method `attr' for nil:NilClass>", 
+        "An error occurred in the the_pirate_bay class at the title method.\n#<NoMethodError: undefined method `content' for nil:NilClass>", 
+        "32 torrents where found, 2 where not valid"
+      ].each do |error|
+        errors.should include(error)
+      end
+    end
+    
+    it "should not return any duplicates" do
+      errors = @torrents.errors
+      lambda do
+        errors.uniq!
+      end.should_not change(errors, :count)
+    end
+  end
+end