fargo 0.2.0 → 0.3.0

data/spec/fargo/protocol/peer_download_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Fargo::Protocol::PeerDownload do
+  let(:conn) {
+    helper_object(Fargo::Protocol::Peer).tap do |conn|
+      conn.client     = Fargo::Client.new
+      conn.instance_variable_set '@other_nick', 'foobar'
+    end
+  }
+
+  shared_examples_for 'a downloader' do |command, data|
+    it "downloads a file correctly after receiving: #{command}" do
+      conn.stub(:send_message)
+
+      conn.begin_download!
+      conn.receive_data command
+      conn.receive_data data
+
+      file = conn.client.config.download_dir + '/foobar/file'
+      file.should have_contents('0123456789')
+    end
+  end
+
+  before :each do
+    conn.stub :set_comm_inactivity_timeout
+    conn.post_init
+    conn.download = Fargo::Download.new 'foobar', 'path/to/file', 'tth', 100, 0
+  end
+
+  describe 'the standard DC protocol for downloading' do
+    before :each do
+      conn.instance_variable_set '@client_extensions', []
+    end
+
+    it "requests a download via the $Get command" do
+      conn.should_receive(:send_message).with('Get', "path/to/file$1")
+
+      conn.begin_download!
+    end
+
+    it "requests the file to be sent after the $FileLength command" do
+      conn.stub(:send_message).with('Get', "path/to/file$1")
+      conn.should_receive(:send_message).with('Send')
+
+      conn.begin_download!
+      conn.receive_data '$FileLength 10|'
+    end
+
+    it_should_behave_like 'a downloader', '$FileLength 10|', '0123456789'
+  end
+
+  describe 'the ADC protocol for downloading' do
+    before :each do
+      conn.instance_variable_set '@client_extensions', ['ADCGet']
+    end
+
+    context "with zlib compression" do
+      before :each do
+        conn.instance_variable_get('@client_extensions') << 'ZLIG'
+      end
+
+      it "requests a download via the $ADCGET command with ZL1" do
+        conn.should_receive(:send_message).with('ADCGET',
+          'file path/to/file 0 100 ZL1')
+
+        conn.begin_download!
+      end
+
+      it_should_behave_like 'a downloader',
+        '$ADCSND file path/to/file 0 10 ZL1|',
+        Zlib::Deflate.deflate('0123456789')
+
+      it_should_behave_like 'a downloader',
+        '$ADCSND file path/to/file 0 10|', '0123456789'
+    end
+
+    context "without zlib compression" do
+      it "requests a download via the $ADCGET command with ZL1" do
+        conn.should_receive(:send_message).with('ADCGET',
+          'file path/to/file 0 100')
+
+        conn.begin_download!
+      end
+
+      it_should_behave_like 'a downloader',
+        '$ADCSND file path/to/file 0 10|', '0123456789'
+    end
+
+    context "with TTHF enabled" do
+      before :each do
+        conn.instance_variable_get('@client_extensions') << 'TTHF'
+      end
+
+      it "requests a download via $ADCGET with the tth of the file" do
+        conn.should_receive(:send_message).with('ADCGET', 'file TTH/tth 0 100')
+
+        conn.begin_download!
+      end
+
+      it_should_behave_like 'a downloader',
+        '$ADCSND file TTH/tth 0 10|', '0123456789'
+    end
+  end
+end

data/spec/fargo/protocol/peer_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Fargo::Protocol::Peer do
+
+  let(:client) { Fargo::Client.new }
+
+  let(:conn) {
+    helper_object(described_class).tap do |conn|
+      conn.stub(:generate_lock).and_return ['lock', 'pk']
+      conn.stub :set_comm_inactivity_timeout
+      conn.post_init
+      conn.client = client
+    end
+  }
+
+  include Fargo::Utils
+
+  describe "the client to client handshake" do
+    before :each do
+      client.config.nick = 'fargo'
+    end
+
+    it "responds with all the correct info when the remote nick is received" do
+      conn.should_receive(:send_data).with('$MyNick fargo|').ordered
+      conn.should_receive(:send_data).with(/^\$Lock \w+ Pk=\w+\|$/).ordered
+      conn.should_receive(:send_data).with(/^\$Supports (\w+ ?)+\|$/).ordered
+      conn.should_receive(:send_data).with(
+        /^\$Direction (Download|Upload) \d+\|$/).ordered
+      conn.should_receive(:send_data).with(
+        "$Key #{generate_key('lock')}|").ordered
+
+      conn.receive_data '$MyNick foobar|$Lock lock Pk=pk|'
+    end
+
+    it "responds correctly when the nick is sent first" do
+      conn.should_receive(:send_data).with('$MyNick fargo|').ordered
+      conn.should_receive(:send_data).with('$Lock lock Pk=pk|').ordered
+
+      conn.send_lock
+
+      conn.should_receive(:send_data).with(/^\$Supports (\w+ ?)+\|$/).ordered
+      conn.should_receive(:send_data).with(
+        /^\$Direction (Download|Upload) \d+\|$/).ordered
+      conn.should_receive(:send_data).with(
+        "$Key #{generate_key('lock')}|").ordered
+
+      conn.receive_data '$MyNick foobar|$Lock lock Pk=pk|$Supports a|' +
+        "$Direction Download 100|$Key #{generate_key('lock')}|"
+    end
+  end
+
+  it "disconnects with an appropriate message" do
+    client.channel.should_receive(:<<).with(
+      [:peer_disconnected, instance_of(Hash)])
+
+    conn.unbind
+  end
+end

data/spec/fargo/protocol/peer_upload_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Fargo::Protocol::PeerUpload do
+  let(:conn) {
+    helper_object(Fargo::Protocol::Peer).tap do |conn|
+      conn.client     = Fargo::Client.new
+    end
+  }
+  let(:file) { Fargo.config.download_dir + '/file' }
+
+  before :each do
+    File.open(file, 'w'){ |f| f << '0123456789' }
+    conn.client.share_directory Fargo.config.download_dir
+    conn.stub(:set_comm_inactivity_timeout)
+    conn.stub(:get_outbound_data_size).and_return 0
+    conn.post_init
+    conn.instance_variable_set '@handshake_step', 5
+  end
+
+  describe "the standard DC protocol using $Get" do
+    it "sends the $FileLength command with the length of the file requested" do
+      conn.should_receive(:send_message).with('FileLength', 10)
+
+      conn.receive_data '$Get tmp/file$1|'
+    end
+
+    it "sends the $FileLength discounting the offset" do
+      conn.should_receive(:send_message).with('FileLength', 10)
+
+      conn.receive_data '$Get tmp/file$5|'
+    end
+
+    it "uploads the file after receiving $Send" do
+      conn.stub(:send_message)
+      conn.receive_data '$Get tmp/file$1|'
+      conn.should_receive(:send_data).with('0123456789')
+      conn.receive_data '$Send|'
+    end
+  end
+
+  describe "uploading via the ADC protocol" do
+    it "sends the $ADCSND command with ZL1 if requested" do
+      conn.should_receive(:send_message).with('ADCSND',
+        'file tmp/file 0 10 ZL1')
+      conn.stub(:begin_streaming)
+
+      conn.receive_data '$ADCGET file tmp/file 0 -1 ZL1|'
+    end
+
+    it "sends the $ADCSND command without ZL1 when not requested" do
+      conn.should_receive(:send_message).with('ADCSND', 'file tmp/file 0 10')
+      conn.stub(:begin_streaming)
+
+      conn.receive_data '$ADCGET file tmp/file 0 -1|'
+    end
+
+    it "immediately begins uploading the file" do
+      conn.stub(:send_message)
+      conn.should_receive(:send_data).with '0123'
+
+      conn.receive_data '$ADCGET file tmp/file 0 4|'
+    end
+
+    it "compresses the sent data with zlib if requested" do
+      conn.stub(:send_message)
+      conn.should_receive(:send_data).with Zlib::Deflate.deflate('0123')
+
+      conn.receive_data '$ADCGET file tmp/file 0 4 ZL1|'
+    end
+  end
+
+  describe "huge files" do
+    let(:size) { 16 * 1024 * 2 + 100 }
+
+    before :each do
+      File.open(file + '2', 'w'){ |f| f << ('a' * size) }
+      conn.client.share_directory Fargo.config.download_dir
+    end
+
+    it "are uploaded efficiently" do
+      conn.stub(:send_message)
+      conn.should_receive(:send_data).with('a' * 16 * 1024).twice.ordered
+      conn.should_receive(:send_data).with('a' * 100).ordered
+
+      conn.receive_data '$ADCGET file tmp/file2 0 -1|'
+    end
+
+    it "compresses successfully" do
+      sent_data = ''
+      conn.stub(:send_message)
+      conn.stub(:send_data){ |d| sent_data << d }
+
+      conn.receive_data '$ADCGET file tmp/file2 0 -1 ZL1|'
+      sent_data.should == Zlib::Deflate.deflate('a' * size)
+    end
+  end
+
+  it "sends $MaxedOut when the client has no slots" do
+    conn.client.take_slot! while conn.client.open_upload_slots > 0
+
+    conn.should_receive(:send_message).with('MaxedOut')
+
+    conn.receive_data '$Get tmp/file$1|'
+  end
+
+  it "doesn't sent $MaxedOut if the requested file is the file list" do
+    conn.client.take_slot! while conn.client.open_upload_slots > 0
+
+    conn.stub(:send_message)
+    conn.should_receive(:send_message).with('MaxedOut').never
+    conn.stub(:begin_streaming)
+
+    conn.receive_data '$Get files.xml.bz2$1|'
+  end
+
+  it "closes the connection when a file list is finished uploading" do
+    conn.stub(:send_data)
+    conn.should_receive(:close_connection_after_writing)
+
+    conn.receive_data '$ADCGET file files.xml.bz2 0 -1|'
+  end
+
+  it "sends $Error when the requested file does not exist" do
+    conn.should_receive(:send_message).with('Error', 'File Not Available')
+
+    conn.receive_data '$Get tmp/nonexistent$1|'
+  end
+end

data/spec/fargo/search_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec::Matchers.define :match_hash do |hash|
+  match do |search|
+    search.matches? hash
+  end
+
+  failure_message_for_should do |search|
+    "#{search.to_s} should have matched the hash: #{hash.inspect}"
+  end
+end
+
+RSpec::Matchers.define :match_file do |file|
+  match do |search|
+    search.matches? :file => file
+  end
+
+  failure_message_for_should do |search|
+    "#{search.to_s} should have matched the file: #{file}"
+  end
+end
+
+describe Fargo::Search do
+  it "matches based on file names" do
+    subject.query = 'foo bar'
+
+    subject.should match_file('foobar.mkv')
+    subject.should match_file('foo/bar.avi')
+    subject.should_not match_file('foo.avi')
+    subject.should_not match_file('bar.jpg')
+  end
+
+  it "filters based off of the maximum size of the file" do
+    subject.query           = 'foo'
+    subject.size            = 100
+    subject.size_restricted = true
+
+    subject.should match_hash(:file => 'foo', :size => 50)
+    subject.should_not match_hash(:file => 'foo', :size => 101)
+  end
+
+  it "filters based off of the minimum size of the file" do
+    subject.query           = 'foo'
+    subject.size            = 100
+    subject.size_restricted = true
+    subject.is_minimum_size = true
+
+    subject.should_not match_hash(:file => 'foo', :size => 50)
+    subject.should match_hash(:file => 'foo', :size => 101)
+  end
+
+  it "matches based on TTH values" do
+    subject.query = 'TTH:foobar'
+    subject.filetype = Fargo::Search::TTH
+
+    subject.should match_hash(:tth => 'foobar')
+  end
+
+  it "doesn't match on tth if not specified" do
+    subject.query = 'TTH:foobar'
+
+    subject.should_not match_hash(:tth => 'foobar')
+  end
+
+  it "only matches anything with a filetype of ANY" do
+    subject.query = 'foo bar baz'
+    subject.filetype = Fargo::Search::ANY
+
+    subject.should match_file('foo/bar.baz')
+    subject.should match_file('foo/bar/baz')
+    subject.should match_file('foo/a/barb/bazc')
+    subject.should match_file('foo.bar.baz')
+
+    subject.should_not match_file('foo.bar')
+    subject.should_not match_file('foo.babaz')
+    subject.should_not match_file('bar/baz')
+  end
+
+  it "only matches audio with a filetype of AUDIO" do
+    subject.query = 'foo'
+    subject.filetype = Fargo::Search::AUDIO
+
+    subject.should match_file('foo.mp3')
+    subject.should match_file('foo.wav')
+    subject.should match_file('foo.flac')
+    subject.should match_file('foo.m4a')
+
+    subject.should_not match_file('foo.avi')
+    subject.should_not match_file('foo.jpg')
+    subject.should_not match_file('foo.mov')
+  end
+
+  it "only matches videos with a filetype of VIDEOS" do
+    subject.query = 'foo'
+    subject.filetype = Fargo::Search::VIDEO
+
+    subject.should match_file('foobar.mkv')
+    subject.should match_file('foo/bar.avi')
+    subject.should match_file('foobar.mov')
+    subject.should match_file('foobar.mpeg')
+    subject.should match_file('foobar.mpg')
+
+    subject.should_not match_file('foobar')
+    subject.should_not match_file('foobar.jpg')
+    subject.should_not match_file('foo.bar')
+  end
+end

data/spec/fargo/supports/chat_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Fargo::Supports::Chat, :type => :em do
+  let(:client) { Fargo::Client.new }
+
+  it "keeps a log of all messages sent" do
+    client.channel << [:chat, 'this is a chat!']
+    client.messages.should == ['this is a chat!']
+
+    client.channel << [:chat, 'another chat']
+    client.messages.should == ['this is a chat!', 'another chat']
+  end
+
+  it "keeps a log of all private messages sent" do
+    client.channel << [:privmsg, {:from => 'foo', :msg => 'this is a chat!'}]
+    client.channel << [:privmsg, {:from => 'foo', :msg => 'another'}]
+
+    client.messages_with('foo').should == [
+      {:from => 'foo', :msg => 'this is a chat!'},
+      {:from => 'foo', :msg => 'another'}
+    ]
+  end
+
+  it "clears all the messages once the hub disconnects" do
+    client.channel << [:chat, 'this is a chat!']
+    client.channel << [:privmsg, {:from => 'foo', :msg => 'this is a chat!'}]
+
+    client.channel << [:hub_disconnected, 'foobar!']
+
+    client.messages.should == []
+    client.messages_with('foo').should == []
+  end
+end

data/spec/fargo/supports/local_file_list_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Fargo::Supports::LocalFileList do
+
+  before :each do
+    @root = Fargo.config.download_dir + '/shared'
+    FileUtils.mkdir_p @root
+    File.open(@root + '/a', 'w'){ |f| f << 'a' }
+    File.open(@root + '/b', 'w'){ |f| f << 'c' }
+    FileUtils.mkdir @root + '/c'
+    File.open(@root + '/c/d', 'w'){ |f| f << 'd' }
+
+    @client = Fargo::Client.new
+    @client.config.override_share_size = nil
+  end
+
+  it "maintains a list of local files, recursively searching folders" do
+    @client.share_directory @root
+
+    hash = @client.local_file_list
+    hash['shared'].should be_a(Hash)
+    hash['shared']['a'].should be_a(Fargo::Listing)
+    hash['shared']['b'].should be_a(Fargo::Listing)
+    hash['shared']['c'].should be_a(Hash)
+    hash['shared']['c']['d'].should be_a(Fargo::Listing)
+
+    hash['shared']['a'].name.should == 'shared/a'
+    hash['shared']['b'].name.should == 'shared/b'
+    hash['shared']['c']['d'].name.should == 'shared/c/d'
+  end
+
+  it "caches the size of each file shared" do
+    @client.share_directory @root
+
+    @client.share_size.should == 3 # 3 bytes, one in each file
+  end
+
+  it "allows overwriting the published share size just for fun" do
+    @client.config.override_share_size = 100
+
+    @client.share_size.should == 100
+  end
+
+  it "correctly creates an array of listings that it's sharing" do
+    @client.share_directory @root
+
+    listings = @client.local_listings
+
+    listings.size.should == 3
+
+    listings.shift.name.should == 'shared/a'
+    listings.shift.name.should == 'shared/b'
+    listings.shift.name.should == 'shared/c/d'
+  end
+
+  it "finds listings correctly when given their name" do
+    @client.share_directory @root
+
+    ret_val = @client.listing_for 'shared/a'
+    ret_val.should be_a(Fargo::Listing)
+    ret_val.name.should == 'shared/a'
+  end
+
+  it "also finds listings based on their TTH value" do
+    @client.share_directory @root
+    listing = @client.local_listings[0]
+
+    @client.listing_for('TTH/' + listing.tth).should == listing
+  end
+end

data/spec/fargo/supports/nick_list_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Fargo::Supports::NickList, :type => :em do
+
+  before :each do
+    @client = Fargo::Client.new
+  end
+
+  it 'gets the most up to date information about the nick' do
+    @client.should_receive(:info).with('nick').twice
+    @client.nick_has_slot? 'nick' # Triggers info the first time
+    @client.nick_has_slot? 'nick' # Make sure we didn't cache the results
+  end
+
+  it "uses results from search queries for open slot information" do
+    @client.channel << [:search_result, {:nick => 'nick', :open_slots => 0}]
+    @client.nick_has_slot?('nick').should be_false
+
+    @client.channel << [:search_result, {:nick => 'nick', :open_slots => 1}]
+    @client.nick_has_slot?('nick').should be_true
+
+    t = Time.now + 20.minutes
+    Time.stub(:now).and_return t
+    @client.stub(:info).with('nick').and_return nil
+    @client.nick_has_slot?('nick').should be_false
+  end
+
+  it "gets the nick list from the subscribed channel" do
+    @client.nicks.should == []
+
+    @client.channel << [:nick_list, {:nicks => ['a', 'b']}]
+
+    @client.nicks.should == ['a', 'b']
+  end
+end

data/spec/fargo/utils_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Fargo::Utils do
+
+  let(:helper) {
+    o = Object.new
+    o.send(:class_eval) do
+      include Fargo::Utils
+    end
+    o
+  }
+
+  it "generates a correct key" do
+    helper.generate_key('FOO').should == "4\220/%DCN000%/"
+  end
+
+  it "generates a correct lock and pk" do
+    # there's not a whole lot of documentation about this online...
+    20.times do
+      lock, pk = helper.generate_lock
+      pk.size.should   >= 0
+      lock.size.should >= 0
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec/core'
+require 'fargo'
+
+download_dir = File.expand_path '../tmp', __FILE__
+
+Fargo.logger.level = ActiveSupport::BufferedLogger::WARN
+
+RSpec.configure do |c|
+  c.color_enabled = true
+
+  c.before :each do
+    Fargo.configure do |config|
+      config.download_dir        = download_dir
+      config.config_dir          = download_dir + '/config'
+      config.nick                = 'fargo'
+      config.override_share_size = nil
+      config.upload_slots        = 4
+    end
+  end
+
+  c.around :each do |example|
+    FileUtils.mkdir_p download_dir
+    example.run
+    FileUtils.rm_rf download_dir
+  end
+
+  c.around :each, :type => :em do |example|
+    EventMachine.run {
+      example.run
+
+      EventMachine.stop_event_loop
+    }
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/support/*.rb'].each { |f| load f }
+
+def helper_object mod
+  o = Object.new
+  o.send(:class_eval) do
+    include mod
+  end
+  o
+end

data/spec/support/matchers.rb

@@ -0,0 +1,17 @@
+RSpec::Matchers.define :have_contents do |contents|
+  match do |file|
+    File.file?(file) && File.read(file).chomp.should == contents.chomp
+  end
+
+  failure_message do |file|
+    msg = "Expected #{file} to contain:\n\t#{contents.gsub("\n", "\n\t")}\nWhen"
+
+    if File.file?(file)
+      msg += " it contained:\n#{File.read(file)}".gsub("\n", "\n\t")
+    else
+      msg += ' it did not exist.'
+    end
+
+    msg
+  end
+end