sidekick-client 0.2.1 → 0.2.2

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

@@ -1,218 +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 TestHeaderAndContentProtocol < Test::Unit::TestCase
-
-  TestHost = "127.0.0.1"
-  TestPort = 8905
-
-  class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
-    attr_reader :first_header, :my_headers, :request
-
-    def receive_first_header_line hdr
-      @first_header ||= []
-      @first_header << hdr
-    end
-    def receive_headers hdrs
-      @my_headers ||= []
-      @my_headers << hdrs
-    end
-    def receive_request hdrs, content
-      @request ||= []
-      @request << [hdrs, content]
-    end
-  end
-
-  def test_no_content
-    the_connection = nil
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-        the_connection = conn
-      end
-      EventMachine.add_timer(4) {raise "test timed out"}
-
-      client = Module.new do
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
-
-        def post_init
-          send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
-          close_connection_after_writing
-        end
-      end
-
-      EventMachine.connect( TestHost, TestPort, client )
-    }
-    assert_equal( ["aaa"], the_connection.first_header )
-    assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
-    assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
-  end
-
-  def test_content
-    the_connection = nil
-    content = "A" * 50
-    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-        the_connection = conn
-      end
-      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
-
-        def post_init
-          headers.each { |h| send_data "#{h}\r\n" }
-          send_data "\n"
-          send_data content
-          close_connection_after_writing
-        end
-      end
-
-      EventMachine.connect( TestHost, TestPort, client )
-
-    }
-    assert_equal( ["aaa"], the_connection.first_header )
-    assert_equal( [headers], the_connection.my_headers )
-    assert_equal( [[headers, content]], the_connection.request )
-  end
-
-  def test_several_requests
-    the_connection = nil
-    content = "A" * 50
-    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-        the_connection = conn
-      end
-      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
-
-        def post_init
-          5.times do
-            headers.each { |h| send_data "#{h}\r\n" }
-            send_data "\n"
-            send_data content
-          end
-          close_connection_after_writing
-        end
-      end
-
-      EventMachine.connect( TestHost, TestPort, client )
-    }
-    assert_equal( ["aaa"] * 5, the_connection.first_header )
-    assert_equal( [headers] * 5, the_connection.my_headers )
-    assert_equal( [[headers, content]] * 5, the_connection.request )
-  end
-
-
-  # def x_test_multiple_content_length_headers
-  #   # This is supposed to throw a RuntimeError but it throws a C++ exception instead.
-  #   the_connection = nil
-  #   content = "A" * 50
-  #   headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
-  #   EventMachine.run {
-  #     EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-  #       the_connection = conn
-  #     end
-  #     EventMachine.add_timer(4) {raise "test timed out"}
-  #     test_proc = proc {
-  #       t = TCPSocket.new TestHost, TestPort
-  #       headers.each {|h| t.write "#{h}\r\n" }
-  #       t.write "\n"
-  #       t.write content
-  #       t.close
-  #     }
-  #     EventMachine.defer test_proc, proc {
-  #       EventMachine.stop
-  #     }
-  #   }
-  # end
-
-  def test_interpret_headers
-    the_connection = nil
-    content = "A" * 50
-    headers = [
-      "GET / HTTP/1.0",
-      "Accept: aaa",
-      "User-Agent: bbb",
-      "Host: ccc",
-      "x-tempest-header:ddd"
-    ]
-
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-        the_connection = conn
-      end
-      EventMachine.add_timer(4) {raise "test timed out"}
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
-
-        def post_init
-          headers.each { |h| send_data "#{h}\r\n" }
-          send_data "\n"
-          send_data content
-          close_connection_after_writing
-        end
-      end
-
-      EventMachine.connect( TestHost, TestPort, client )
-    }
-
-    hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
-    expect = {
-      :accept => "aaa",
-      :user_agent => "bbb",
-      :host => "ccc",
-      :x_tempest_header => "ddd"
-    }
-    assert_equal(expect, hsh)
-  end
-
-end

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

@@ -1,218 +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 TestHttpClient < Test::Unit::TestCase
-
-    Localhost = "127.0.0.1"
-    Localport = 9801
-
-  def setup
-  end
-
-  def teardown
-  end
-
-  #-------------------------------------
-
-  def test_http_client
-    ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
-      c.callback {
-        ok = true
-        EventMachine.stop
-      }
-      c.errback {EventMachine.stop} # necessary, otherwise a failure blocks the test suite forever.
-    }
-    assert ok
-  end
-
-  #-------------------------------------
-
-  def test_http_client_1
-    ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
-      c.callback {ok = true; EventMachine.stop}
-      c.errback {EventMachine.stop}
-    }
-    assert ok
-  end
-
-  #-------------------------------------
-
-  def test_http_client_2
-    ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
-      c.callback {|result|
-        ok = true;
-        EventMachine.stop
-      }
-      c.errback {EventMachine.stop}
-    }
-    assert ok
-  end
-
-
-  #-----------------------------------------
-
-  # Test a server that returns a page with a zero content-length.
-  # This caused an early version of the HTTP client not to generate a response,
-  # causing this test to hang. Observe, there was no problem with responses
-  # lacking a content-length, just when the content-length was zero.
-  #
-  class EmptyContent < EventMachine::Connection
-      def initialize *args
-        super
-      end
-      def receive_data data
-        send_data "HTTP/1.0 404 ...\r\nContent-length: 0\r\n\r\n"
-        close_connection_after_writing
-      end
-  end
-
-  def test_http_empty_content
-      ok = false
-      EventMachine.run {
-        EventMachine.start_server "127.0.0.1", 9701, EmptyContent
-        c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
-        c.callback {|result|
-          ok = true
-          EventMachine.stop
-        }
-      }
-      assert ok
-  end
-
-
-  #---------------------------------------
-
-  class PostContent < EventMachine::Protocols::LineAndTextProtocol
-      def initialize *args
-        super
-        @lines = []
-      end
-      def receive_line line
-        if line.length > 0
-          @lines << line
-        else
-          process_headers
-        end
-      end
-      def receive_binary_data data
-        @post_content = data
-        send_response
-      end
-      def process_headers
-        if @lines.first =~ /\APOST ([^\s]+) HTTP\/1.1\Z/
-          @uri = $1.dup
-        else
-          raise "bad request"
-        end
-
-        @lines.each {|line|
-          if line =~ /\AContent-length:\s*(\d+)\Z/i
-            @content_length = $1.dup.to_i
-          elsif line =~ /\AContent-type:\s*(\d+)\Z/i
-            @content_type = $1.dup
-          end
-        }
-
-        raise "invalid content length" unless @content_length
-        set_binary_mode @content_length
-      end
-      def send_response
-        send_data "HTTP/1.1 200 ...\r\nConnection: close\r\nContent-length: 10\r\nContent-type: text/html\r\n\r\n0123456789"
-        close_connection_after_writing
-      end
-  end
-
-  # TODO, this is WRONG. The handler is asserting an HTTP 1.1 request, but the client
-  # is sending a 1.0 request. Gotta fix the client
-  def test_post
-      response = nil
-      EventMachine.run {
-        EventMachine.start_server Localhost, Localport, PostContent
-        EventMachine.add_timer(2) {raise "timed out"}
-        c = EventMachine::Protocols::HttpClient.request(
-          :host=>Localhost,
-          :port=>Localport,
-          :method=>:post,
-          :request=>"/aaa",
-          :content=>"XYZ",
-          :content_type=>"text/plain"
-        )
-        c.callback {|r|
-          response = r
-          EventMachine.stop
-        }
-      }
-
-      assert_equal( 200, response[:status] )
-      assert_equal( "0123456789", response[:content] )
-  end
-
-
-  # TODO, need a more intelligent cookie tester.
-  # In fact, this whole test-harness needs a beefier server implementation.
-  def test_cookie
-    ok = false
-    EM.run {
-      c = EM::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80, :cookie=>"aaa=bbb"
-      c.callback {|result|
-        ok = true;
-        EventMachine.stop
-      }
-      c.errback {EventMachine.stop}
-    }
-    assert ok
-  end
-
-  # We can tell the client to send an HTTP/1.0 request (default is 1.1).
-  # This is useful for suppressing chunked responses until those are working.
-  def test_version_1_0
-    ok = false
-    EM.run {
-      c = EM::P::HttpClient.request(
-        :host => "www.bayshorenetworks.com",
-        :port => 80,
-        :version => "1.0"
-      )
-      c.callback {|result|
-        ok = true;
-        EventMachine.stop
-      }
-      c.errback {EventMachine.stop}
-    }
-    assert ok
-  end
-
-end

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

@@ -1,153 +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 TestHttpClient2 < Test::Unit::TestCase
-  Localhost = "127.0.0.1"
-  Localport = 9801
-
-  def setup
-  end
-
-  def teardown
-  end
-
-
-  class TestServer < EM::Connection
-  end
-
-  # #connect returns an object which has made a connection to an HTTP server
-  # and exposes methods for making HTTP requests on that connection.
-  # #connect can take either a pair of parameters (a host and a port),
-  # or a single parameter which is a Hash.
-  #
-  def test_connect
-    EM.run {
-      EM.start_server Localhost, Localport, TestServer
-      http1 = EM::P::HttpClient2.connect Localhost, Localport
-      http2 = EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
-      EM.stop
-    }
-  end
-
-
-  def test_bad_port
-    EM.run {
-      EM.start_server Localhost, Localport, TestServer
-      assert_raises( ArgumentError ) {
-        EM::P::HttpClient2.connect Localhost, "xxx"
-      }
-      EM.stop
-    }
-  end
-
-  def test_bad_server
-    err = nil
-    EM.run {
-      http = EM::P::HttpClient2.connect Localhost, 9999
-      d = http.get "/"
-      d.errback { err = true; d.internal_error; EM.stop }
-    }
-    assert(err)
-  end
-
-  def test_get
-    content = nil
-    EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
-      d = http.get "/"
-      d.callback {
-        content = d.content
-        EM.stop
-      }
-    }
-    assert(content)
-  end
-
-  # Not a pipelined request because we wait for one response before we request the next.
-  # XXX this test is broken because it sends the second request to the first connection
-  # XXX right before the connection closes
-  def _test_get_multiple
-    content = nil
-    EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
-      d = http.get "/"
-      d.callback {
-        e = http.get "/"
-        e.callback {
-          content = e.content
-          EM.stop
-        }
-      }
-    }
-    assert(content)
-  end
-
-  def test_get_pipeline
-    headers, headers2 = nil, nil
-    EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
-      d = http.get("/")
-      d.callback {
-        headers = d.headers
-      }
-      e = http.get("/")
-      e.callback {
-        headers2 = e.headers
-      }
-      EM::Timer.new(1) {EM.stop}
-    }
-    assert(headers)
-    assert(headers2)
-  end
-
-
-  def test_authheader
-    EM.run {
-      EM.start_server Localhost, Localport, TestServer
-      http = EM::P::HttpClient2.connect Localhost, 18842
-      d = http.get :url=>"/", :authorization=>"Basic xxx"
-      d.callback {EM.stop}
-      d.errback {EM.stop}
-    }
-  end
-
-  def test_https_get
-    d = nil
-    EM.run {
-      http = EM::P::HttpClient2.connect :host => 'www.amazon.com', :port => 443, :ssl => true
-      d = http.get "/"
-      d.callback {
-        EM.stop
-      }
-    }
-    assert_equal(200, d.status)
-  end if EM.ssl?
-
-end

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

@@ -1,50 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestInactivityTimeout < Test::Unit::TestCase
-
-  def test_default
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      $timeout = c.comm_inactivity_timeout
-      EM.stop
-    }
-
-    assert_equal(0.0, $timeout)
-  end
-
-  def test_set_and_get
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      c.comm_inactivity_timeout = 2.5
-      $timeout = c.comm_inactivity_timeout
-      EM.stop
-    }
-
-    assert_equal(2.5, $timeout)
-  end
-
-  module TimeoutHandler
-    def unbind
-      EM.stop
-    end
-  end
-
-  def test_for_real
-    EM.run {
-      EM.heartbeat_interval = 0.1
-      EM.start_server("127.0.0.1", 12345)
-      EM.add_timer(0.2) {
-        $start = Time.now
-        c = EM.connect("127.0.0.1", 12345, TimeoutHandler)
-        c.comm_inactivity_timeout = 2.5
-      }
-    }
-
-    assert_in_delta(2.5, (Time.now - $start), 0.3)
-  end
-
-end

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

@@ -1,60 +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 TestKeyboardEvents < Test::Unit::TestCase
-
-  def setup
-  end
-
-  def teardown
-  end
-
-  module KbHandler
-    include EM::Protocols::LineText2
-    def receive_line d
-      EM::stop if d == "STOP"
-    end
-  end
-
-  # This test doesn't actually do anything useful but is here to
-  # illustrate the usage. If you removed the timer and ran this test
-  # by itself on a console, and then typed into the console, it would
-  # work.
-  # I don't know how to get the test harness to simulate actual keystrokes.
-  # When someone figures that out, then we can make this a real test.
-  #
-  def test_kb
-    EM.run {
-      EM.open_keyboard KbHandler
-      EM::Timer.new(1) { EM.stop }
-    } if $stdout.tty? # don't run the test unless it stands a chance of validity.
-  end
-
-end