sidekick-client 0.2.1 → 0.2.2

data/lib/ext/eventmachine-0.12.10/tests/test_pause.rb

@@ -1,70 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-require 'eventmachine'
-require 'socket'
-require 'test/unit'
-
-class TestPause < Test::Unit::TestCase
-  TestHost = "127.0.0.1"
-  TestPort = 9070
-
-  def setup
-    assert(!EM.reactor_running?)
-  end
-
-  def teardown
-    assert(!EM.reactor_running?)
-  end
-
-  #-------------------------------------
-
-  def test_pause_resume
-    test = self
-    server = nil
-
-    s_rx = c_rx = 0
-
-    EM.run do
-      EM.start_server TestHost, TestPort, Module.new {
-        define_method :post_init do
-          server = self
-        end
-
-        define_method :receive_data do |data|
-          s_rx += 1
-
-          EM.add_periodic_timer(0.01) { send_data 'hi' }
-          send_data 'hi'
-
-          # pause server, now no outgoing data will actually
-          # be sent and no more incoming data will be received
-          pause
-        end
-      }
-
-      c = EM.connect TestHost, TestPort, Module.new {
-        define_method :receive_data do |data|
-          c_rx += 1
-        end
-      }
-      EM.add_periodic_timer(0.01) { c.send_data 'hi' }
-
-      EM.add_timer(1) do
-        test.assert_equal 1, s_rx
-        test.assert_equal 0, c_rx
-        test.assert server.paused?
-
-        # resume server, queued outgoing and incoming data will be flushed
-        server.resume
-
-        test.assert ! server.paused?
-
-        EM.add_timer(1) do
-          test.assert server.paused?
-          test.assert s_rx >= 2
-          test.assert c_rx >= 1
-          EM.stop_event_loop
-        end
-      end
-    end
-  end
-end

data/lib/ext/eventmachine-0.12.10/tests/test_pending_connect_timeout.rb

@@ -1,48 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestPendingConnectTimeout < Test::Unit::TestCase
-
-  def test_default
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      $timeout = c.pending_connect_timeout
-      EM.stop
-    }
-
-    assert_equal(20.0, $timeout)
-  end
-
-  def test_set_and_get
-    $timeout = nil
-    EM.run {
-      c = EM.connect("1.2.3.4", 54321)
-      c.pending_connect_timeout = 2.5
-      $timeout = c.pending_connect_timeout
-      EM.stop
-    }
-
-    assert_equal(2.5, $timeout)
-  end
-
-  module TimeoutHandler
-    def unbind
-      EM.stop
-    end
-  end
-
-  def test_for_real
-    $timeout = nil
-    EM.run {
-      EM.heartbeat_interval = 0.1
-      $start = Time.now
-      c = EM.connect("1.2.3.4", 54321, TimeoutHandler)
-      c.pending_connect_timeout = 5
-    }
-
-    assert_in_delta(5, (Time.now - $start), 0.3)
-  end
-
-end

data/lib/ext/eventmachine-0.12.10/tests/test_process_watch.rb

@@ -1,48 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestProcessWatch < Test::Unit::TestCase
-  module ParentProcessWatcher
-    def process_forked
-      $forked = true
-    end
-  end
-
-  module ChildProcessWatcher
-    def process_exited
-      $exited = true
-    end
-    def unbind
-      $unbind = true
-      EM.stop
-    end
-  end
-
-  def setup
-    EM.kqueue = true if EM.kqueue?
-  end
-
-  def teardown
-    EM.kqueue = false if EM.kqueue?
-  end
-
-  def test_events
-    EM.run{
-      # watch ourselves for a fork notification
-      EM.watch_process(Process.pid, ParentProcessWatcher)
-      $fork_pid = fork{ sleep }
-      child = EM.watch_process($fork_pid, ChildProcessWatcher)
-      $pid = child.pid
-
-      EM.add_timer(0.5){
-        Process.kill('TERM', $fork_pid)
-      }
-    }
-
-    assert_equal($pid, $fork_pid)
-    assert($forked)
-    assert($exited)
-    assert($unbind)
-  end
-end

data/lib/ext/eventmachine-0.12.10/tests/test_processes.rb

@@ -1,128 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestProcesses < Test::Unit::TestCase
-
-  # EM::DeferrableChildProcess is a sugaring of a common use-case
-  # involving EM::popen.
-  # Call the #open method on EM::DeferrableChildProcess, passing
-  # a command-string. #open immediately returns an EM::Deferrable
-  # object. It also schedules the forking of a child process, which
-  # will execute the command passed to #open.
-  # When the forked child terminates, the Deferrable will be signalled
-  # and execute its callbacks, passing the data that the child process
-  # wrote to stdout.
-  #
-  def test_deferrable_child_process
-    ls = ""
-    EM.run {
-      d = EM::DeferrableChildProcess.open( "ls -ltr" )
-      d.callback {|data_from_child|
-        ls = data_from_child
-        EM.stop
-      }
-    }
-    assert( ls.length > 0)
-  end
-
-  def setup
-    $out = nil
-    $status = nil
-  end
-
-  def test_em_system
-    EM.run{
-      EM.system('ls'){ |out,status| $out, $status = out, status; EM.stop }
-    }
-
-    assert( $out.length > 0 )
-    assert_equal($status.exitstatus, 0)
-    assert_equal($status.class, Process::Status)
-  end
-
-  def test_em_system_pid
-    $pids = []
-
-    EM.run{
-      $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
-    }
-
-    assert_equal $pids[0], $pids[1]
-  end
-
-  def test_em_system_with_proc
-    EM.run{
-      EM.system('ls', proc{ |out,status| $out, $status = out, status; EM.stop })
-    }
-
-    assert( $out.length > 0 )
-    assert_equal($status.exitstatus, 0)
-    assert_equal($status.class, Process::Status)
-  end
-
-  def test_em_system_with_two_procs
-    EM.run{
-      EM.system('sh', proc{ |process|
-        process.send_data("echo hello\n")
-        process.send_data("exit\n")
-      }, proc{ |out,status|
-        $out = out
-        $status = status
-        EM.stop
-      })
-    }
-
-    assert_equal("hello\n", $out)
-  end
-
-  def test_em_system_cmd_arguments
-    EM.run{
-      EM.system('sh', '--version', proc{ |process|
-      }, proc{ |out,status|
-        $out = out
-        $status = status
-        EM.stop
-      })
-    }
-
-    assert_match(/version/i, $out)
-  end
-
-  def test_em_system_spaced_arguments
-    EM.run{
-      EM.system('ruby', '-e', 'puts "hello"', proc{ |out,status|
-        $out = out
-        EM.stop
-      })
-    }
-
-    assert_equal("hello\n", $out)
-  end
-end

data/lib/ext/eventmachine-0.12.10/tests/test_proxy_connection.rb

@@ -1,92 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestProxyConnection < Test::Unit::TestCase
-
-  module ProxyConnection
-    def initialize(client, request)
-      @client, @request = client, request
-    end
-
-    def post_init
-      EM::enable_proxy(self, @client)
-    end
-
-    def connection_completed
-      EM.next_tick {
-        send_data @request
-      }
-    end
-
-    def proxy_target_unbound
-      $unbound_early = true
-      EM.stop
-    end
-
-    def unbind
-      @client.close_connection_after_writing
-    end
-  end
-
-  module Client
-    def connection_completed
-      send_data "EventMachine rocks!"
-    end
-
-    def receive_data(data)
-      $client_data = data
-    end
-
-    def unbind
-      EM.stop
-    end
-  end
-
-  module Client2
-    include Client
-    def unbind; end
-  end
-
-  module Server
-    def receive_data(data)
-      send_data "I know!" if data == "EventMachine rocks!"
-      close_connection_after_writing
-    end
-  end
-
-  module ProxyServer
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
-    end
-  end
-
-  module EarlyClosingProxy
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
-      close_connection
-    end
-  end
-
-  def test_proxy_connection
-    EM.run {
-      EM.start_server("127.0.0.1", 54321, Server)
-      EM.start_server("127.0.0.1", 12345, ProxyServer)
-      EM.connect("127.0.0.1", 12345, Client)
-    }
-
-    assert_equal("I know!", $client_data)
-  end
-
-  def test_early_close
-    $client_data = nil
-    EM.run {
-      EM.start_server("127.0.0.1", 54321, Server)
-      EM.start_server("127.0.0.1", 12345, EarlyClosingProxy)
-      EM.connect("127.0.0.1", 12345, Client2)
-    }
-
-    assert($unbound_early)
-  end
-
-end

data/lib/ext/eventmachine-0.12.10/tests/test_pure.rb

@@ -1,125 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-# 
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestPure < Test::Unit::TestCase
-
-
-  Host,Port = "0.0.0.0", 9060
-
-
-  # These tests are intended to exercise problems that come up in the
-  # pure-Ruby implementation. However, we DON'T constrain them such that
-  # they only run in pure-Ruby. These tests need to work identically in
-  # any implementation.
-
-  def setup
-  end
-
-  def teardown
-  end
-
-  #-------------------------------------
-
-  # The EM reactor needs to run down open connections and release other resources
-  # when it stops running. Make sure this happens even if user code throws a Ruby
-  # exception.
-  # One way to see this is to run identical tests that open a TCP server and throw
-  # an exception. (We do this twice because an exception aborts a test. We make the
-  # two tests identical except for the method name because we can't predict the order
-  # in which the test harness will run them.)
-  # If exception handling is incorrect, the second test will fail with a no-bind error
-  # because the TCP server opened in the first test will not have been closed.
-  #
-  def run_exception
-      EM.run {
-        EM.start_server Host, Port
-        raise "an exception"
-      }
-  end
-  def test_exception_1
-    assert_raises( RuntimeError ) { run_exception }
-  end
-  def test_exception_2
-    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
-    assert_raises( ex_class ) { run_exception }
-  end
-
-
-  # Under some circumstances, the pure Ruby library would emit an Errno::ECONNREFUSED
-  # exception on certain kinds of TCP connect-errors.
-  # It's always been something of an open question whether EM should throw an exception
-  # in these cases but the defined answer has always been to catch it the unbind method.
-  # With a connect failure, the latter will always fire, but connection_completed will
-  # never fire. So even though the point is arguable, it's incorrect for the pure Ruby
-  # version to throw an exception.
-  module TestConnrefused
-    def unbind
-      EM.stop
-    end
-    def connection_completed
-      raise "should never get here"
-    end
-  end
-  def test_connrefused
-    EM.run {
-      EM.connect "0.0.0.0", 60001, TestConnrefused
-    }
-  end
-
-
-  # Make sure connection_completed gets called as expected with TCP clients. This is the
-  # opposite of test_connrefused.
-  # If the test fails, it will hang because EM.stop never gets called.
-  #
-  module TestConnaccepted
-    def connection_completed
-      EM.stop
-    end
-  end
-  def test_connaccepted
-    timeout = false
-    EM.run {
-      EM.start_server "0.0.0.0", 60002
-      EM.connect "0.0.0.0", 60002, TestConnaccepted
-      EM::Timer.new(1) {timeout = true; EM.stop}
-    }
-    assert_equal( false, timeout )
-  end
-
-  def test_reactor_running
-    a = false
-    EM.run {
-      a = EM.reactor_running?
-      EM.next_tick {EM.stop}
-    }
-    assert a
-  end
-
-end

data/lib/ext/eventmachine-0.12.10/tests/test_queue.rb

@@ -1,44 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestEventMachineQueue < Test::Unit::TestCase
-  def test_queue_push
-    s = 0
-    EM.run do
-      q = EM::Queue.new
-      q.push(1)
-      EM.next_tick { s = q.size; EM.stop }
-    end
-    assert_equal 1, s
-  end
-
-  def test_queue_pop
-    x,y,z = nil
-    EM.run do
-      q = EM::Queue.new
-      q.push(1,2,3)
-      q.pop { |v| x = v }
-      q.pop { |v| y = v }
-      q.pop { |v| z = v; EM.stop }
-    end
-    assert_equal 1, x
-    assert_equal 2, y
-    assert_equal 3, z
-  end
-
-  def test_queue_reactor_thread
-    q = EM::Queue.new
-
-    Thread.new { q.push(1,2,3) }.join
-    assert q.empty?
-    EM.run { EM.next_tick { EM.stop } }
-    assert_equal 3, q.size
-
-    x = nil
-    Thread.new { q.pop { |v| x = v } }.join
-    assert_equal nil, x
-    EM.run { EM.next_tick { EM.stop } }
-    assert_equal 1, x
-  end
-end

data/lib/ext/eventmachine-0.12.10/tests/test_running.rb

@@ -1,42 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-# 
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestRunning < Test::Unit::TestCase
-  def test_running
-    assert_equal( false, EM::reactor_running? )
-    r = false
-    EM.run {
-      r = EM::reactor_running?
-      EM.stop
-    }
-    assert_equal( true, r )
-  end
-end
-

data/lib/ext/eventmachine-0.12.10/tests/test_sasl.rb

@@ -1,72 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-# 
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-
-class TestSASL < Test::Unit::TestCase
-
-  # SASL authentication is usually done with UNIX-domain sockets, but
-  # we'll use TCP so this test will work on Windows. As far as the
-  # protocol handlers are concerned, there's no difference.
-
-  Host,Port = "127.0.0.1",9560
-  TestUser,TestPsw = "someone", "password"
-
-  class SaslServer < EM::Connection
-    include EM::Protocols::SASLauth
-    def validate usr, psw, sys, realm
-      usr == TestUser and psw == TestPsw
-    end
-  end
-
-  class SaslClient < EM::Connection
-    include EM::Protocols::SASLauthclient
-  end
-
-  def test_sasl
-    resp = nil
-    EM.run {
-      EM.start_server( Host, Port, SaslServer )
-
-      c = EM.connect( Host, Port, SaslClient )
-      d = c.validate?( TestUser, TestPsw )
-      d.timeout 2
-      d.callback {
-        resp = true
-        EM.stop
-      }
-      d.errback {
-        resp = false
-        EM.stop
-      }
-    }
-    assert_equal( true, resp )
-  end
-
-end