root/trunk/tests/test_hc.rb

Revision 721, 6.3 kB (checked in by francis, 1 year ago)

removed defer calls for java, which doesn't seem to like them

  • Property svn:keywords set to Id
Line 
1 # $Id$
2 #
3 # Author:: Francis Cianfrocca (gmail: blackhedd)
4 # Homepage::  http://rubyeventmachine.com
5 # Date:: 8 April 2006
6 #
7 # See EventMachine and EventMachine::Connection for documentation and
8 # usage examples.
9 #
10 #----------------------------------------------------------------------------
11 #
12 # Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
13 # Gmail: blackhedd
14 #
15 # This program is free software; you can redistribute it and/or modify
16 # it under the terms of either: 1) the GNU General Public License
17 # as published by the Free Software Foundation; either version 2 of the
18 # License, or (at your option) any later version; or 2) Ruby's License.
19 #
20 # See the file COPYING for complete licensing information.
21 #
22 #---------------------------------------------------------------------------
23 #
24 #
25 #
26
27 $:.unshift "../lib"
28 require 'eventmachine'
29 require 'socket'
30 require 'test/unit'
31
32 # This doesn't completely work under Ruby 1.9.
33 # Part of it is thread race conditions. I added some sleeps to make these
34 # tests work. Native threads do strange things when you do I/O on them.
35 #
36 # And it's even worse in Java, where I/O on native threads doesn't seem
37 # to be reliable at all.
38 #
39
40
41 class TestHeaderAndContentProtocol < Test::Unit::TestCase
42
43         TestHost = "127.0.0.1"
44         TestPort = 8905
45
46
47         #--------------------------------------------------------------------
48
49         class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
50                 attr_reader :first_header, :my_headers, :request
51
52                 def receive_first_header_line hdr
53                         @first_header ||= []
54                         @first_header << hdr
55                 end
56                 def receive_headers hdrs
57                         @my_headers ||= []
58                         @my_headers << hdrs
59                 end
60                 def receive_request hdrs, content
61                         @request ||= []
62                         @request << [hdrs, content]
63                 end
64         end
65
66
67         def test_no_content
68                 Thread.abort_on_exception = true
69                 the_connection = nil
70                 EventMachine.run {
71                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
72                                 the_connection = conn
73                         end
74                         EventMachine.add_timer(4) {raise "test timed out"}
75
76                         pr = proc {
77                                 t = TCPSocket.new TestHost, TestPort
78                                 t.write [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
79                                 t.close
80                         }
81
82                         if RUBY_PLATFORM =~ /java/i
83                                 pr.call
84                                 EM.add_timer(0.5) {EM.stop}
85                         else
86                                 EventMachine.defer proc {
87                                         pr.call
88                                         if RUBY_VERSION =~ /\A1\.9\./
89                                                 sleep 0.1
90                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
91                                         end
92                                 }, proc {
93                                         EventMachine.stop
94                                 }
95                         end
96                 }
97                 assert_equal( ["aaa"], the_connection.first_header )
98                 assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
99                 assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
100         end
101
102
103
104
105         def test_content
106                 Thread.abort_on_exception = true
107                 the_connection = nil
108                 content = "A" * 50
109                 headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
110                 EventMachine.run {
111                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
112                                 the_connection = conn
113                         end
114                         EventMachine.add_timer(4) {raise "test timed out"}
115
116                         pr = proc {
117                                 t = TCPSocket.new TestHost, TestPort
118                                 headers.each {|h| t.write "#{h}\r\n" }
119                                 t.write "\n"
120                                 t.write content
121                                 t.close
122                         }
123
124                         if RUBY_PLATFORM =~ /java/i
125                                 # I/O on threads seems completely unreliable in Java.
126                                 pr.call
127                                 EM.add_timer(0.5) {EM.stop}
128                         else
129                                 EventMachine.defer proc {
130                                         pr.call
131                                         if RUBY_VERSION =~ /\A1\.9\./
132                                                 sleep 0.1
133                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
134                                         end
135                                 }, proc {
136                                         EM.stop
137                                 }
138                         end
139                 }
140                 assert_equal( ["aaa"], the_connection.first_header )
141                 assert_equal( [headers], the_connection.my_headers )
142                 assert_equal( [[headers, content]], the_connection.request )
143         end
144
145
146
147         def test_several_requests
148                 Thread.abort_on_exception = true
149                 the_connection = nil
150                 content = "A" * 50
151                 headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
152                 EventMachine.run {
153                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
154                                 the_connection = conn
155                         end
156                         EventMachine.add_timer(4) {raise "test timed out"}
157
158                         pr = proc {
159                                 t = TCPSocket.new TestHost, TestPort
160                                 5.times {
161                                         headers.each {|h| t.write "#{h}\r\n" }
162                                         t.write "\n"
163                                         t.write content
164                                 }
165                                 t.close
166                         }
167
168                         if RUBY_PLATFORM =~ /java/i
169                                 pr.call
170                                 EM.add_timer(1) {EM.stop}
171                         else
172                                 EventMachine.defer proc {
173                                         pr.call
174                                         if RUBY_VERSION =~ /\A1\.9\./
175                                                 sleep 0.1
176                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
177                                         end
178                                 }, proc {
179                                         EventMachine.stop
180                                 }
181                         end
182                 }
183                 assert_equal( ["aaa"] * 5, the_connection.first_header )
184                 assert_equal( [headers] * 5, the_connection.my_headers )
185                 assert_equal( [[headers, content]] * 5, the_connection.request )
186         end
187
188
189     def x_test_multiple_content_length_headers
190         # This is supposed to throw a RuntimeError but it throws a C++ exception instead.
191         Thread.abort_on_exception = true
192         the_connection = nil
193         content = "A" * 50
194         headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
195         EventMachine.run {
196             EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
197                 the_connection = conn
198             end
199             EventMachine.add_timer(4) {raise "test timed out"}
200             EventMachine.defer proc {
201                 t = TCPSocket.new TestHost, TestPort
202                 headers.each {|h| t.write "#{h}\r\n" }
203                 t.write "\n"
204                 t.write content
205                 t.close
206             }, proc {
207                 EventMachine.stop
208             }
209         }
210     end
211
212         def test_interpret_headers
213                 Thread.abort_on_exception = true
214                 the_connection = nil
215                 content = "A" * 50
216                 headers = [
217                         "GET / HTTP/1.0",
218                         "Accept: aaa",
219                         "User-Agent: bbb",
220                         "Host:      ccc",
221                         "x-tempest-header:ddd"
222                 ]
223
224                 EventMachine.run {
225                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
226                                 the_connection = conn
227                         end
228                         EventMachine.add_timer(4) {raise "test timed out"}
229
230                         pr = proc {
231                                 t = TCPSocket.new TestHost, TestPort
232                                 headers.each {|h| t.write "#{h}\r\n" }
233                                 t.write "\n"
234                                 t.write content
235                                 t.close
236                         }
237
238                         if RUBY_PLATFORM =~ /java/i
239                                 pr.call
240                                 EM.add_timer(0.5) {EM.stop}
241                         else
242                                 EventMachine.defer proc {
243                                         pr.call
244                                         if RUBY_VERSION =~ /\A1\.9\./
245                                                 sleep 0.1
246                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
247                                         end
248                                 }, proc {
249                                         EventMachine.stop
250                                 }
251                         end
252                 }
253
254                 hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
255                 assert_equal(
256                         {
257                                 :accept => "aaa",
258                                 :user_agent => "bbb",
259                                 :host => "ccc",
260                                 :x_tempest_header => "ddd"
261                         },
262                         hsh
263                 )
264         end
265
266
267 end
268
269
Note: See TracBrowser for help on using the browser.