uv-rays 0.0.1

data/spec/buffered_tokenizer_spec.rb

@@ -0,0 +1,253 @@
+require 'uv-rays'
+
+describe UvRays::BufferedTokenizer do
+    describe 'delimiter' do
+
+        before :each do
+            @buffer = UvRays::BufferedTokenizer.new({
+                delimiter: "\n\r"
+            })
+        end
+
+
+        it "should not return anything when a complete message is not available" do
+            msg1 = "test"
+
+            result = @buffer.extract(msg1)
+            result.should == []
+        end
+
+        it "should tokenize messages where the data is a complete message" do
+            msg1 = "test\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test']
+        end
+
+        it "should return multiple complete messages" do
+            msg1 = "test\n\rwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test', 'whoa']
+        end
+        
+        it "should tokenize messages where the delimiter is split" do
+            msg1 = "test\n"
+            msg2 = "\rwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == []
+            result = @buffer.extract(msg2)
+            result.should == ['test', 'whoa']
+
+
+            msg3 = "test\n"
+            msg4 = "\rwhoa\n"
+            msg5 = "\r"
+
+            result = @buffer.extract(msg3)
+            result.should == []
+            result = @buffer.extract(msg4)
+            result.should == ['test']        
+
+            result = @buffer.extract(msg5)
+            result.should == ['whoa']
+        end
+    end
+
+    describe 'delimiter' do
+
+        before :each do
+            @buffer = UvRays::BufferedTokenizer.new({
+                delimiter: "\n\r"
+            })
+        end
+
+
+        it "should not return anything when a complete message is not available" do
+            msg1 = "test"
+
+            result = @buffer.extract(msg1)
+            result.should == []
+        end
+
+        it "should not return anything when the messages is empty" do
+            msg1 = ""
+
+            result = @buffer.extract(msg1)
+            result.should == []
+        end
+
+        it "should tokenize messages where the data is a complete message" do
+            msg1 = "test\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test']
+        end
+
+        it "should return multiple complete messages" do
+            msg1 = "test\n\rwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test', 'whoa']
+        end
+        
+        it "should tokenize messages where the delimiter is split" do
+            msg1 = "test\n"
+            msg2 = "\rwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == []
+            result = @buffer.extract(msg2)
+            result.should == ['test', 'whoa']
+
+
+            msg3 = "test\n"
+            msg4 = "\rwhoa\n"
+            msg5 = "\r"
+
+            result = @buffer.extract(msg3)
+            result.should == []
+            result = @buffer.extract(msg4)
+            result.should == ['test']        
+
+            result = @buffer.extract(msg5)
+            result.should == ['whoa']
+        end
+    end
+
+
+
+    describe 'indicator with delimiter' do
+
+        before :each do
+            @buffer = UvRays::BufferedTokenizer.new({
+                delimiter: "\n\r",
+                indicator: "GO"
+            })
+        end
+
+
+        it "should not return anything when a complete message is not available" do
+            msg1 = "GO-somedata"
+
+            result = @buffer.extract(msg1)
+            result.should == []
+        end
+
+        it "should not return anything when the messages is empty" do
+            msg1 = ""
+
+            result = @buffer.extract(msg1)
+            result.should == []
+        end
+
+        it "should tokenize messages where the data is a complete message" do
+            msg1 = "GOtest\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test']
+        end
+
+        it "should discard data that is not relevant" do
+            msg1 = "1234-GOtest\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test']
+        end
+
+        it "should return multiple complete messages" do
+            msg1 = "GOtest\n\rGOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test', 'whoa']
+        end
+
+        it "should discard data between multiple complete messages" do
+            msg1 = "1234-GOtest\n\r12345-GOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test', 'whoa']
+        end
+        
+        it "should tokenize messages where the delimiter is split" do
+            msg1 = "GOtest\n"
+            msg2 = "\rGOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == []
+            result = @buffer.extract(msg2)
+            result.should == ['test', 'whoa']
+
+
+            msg3 = "GOtest\n"
+            msg4 = "\rGOwhoa\n"
+            msg5 = "\r"
+
+            result = @buffer.extract(msg3)
+            result.should == []
+            result = @buffer.extract(msg4)
+            result.should == ['test']        
+
+            result = @buffer.extract(msg5)
+            result.should == ['whoa']
+        end
+
+        it "should tokenize messages where the indicator is split" do
+            msg1 = "GOtest\n\rG"
+            msg2 = "Owhoa\n"
+            msg3 = "\rGOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test']
+            result = @buffer.extract(msg2)
+            result.should == []
+            result = @buffer.extract(msg3)
+            result.should == ['whoa', 'whoa']
+        end
+
+        it "should tokenize messages where the indicator is split and there is discard data" do
+            msg1 = "GOtest\n\r1234G"
+            msg2 = "Owhoa\n"
+            msg3 = "\r1234GOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            result.should == ['test']
+            result = @buffer.extract(msg2)
+            result.should == []
+            result = @buffer.extract(msg3)
+            result.should == ['whoa', 'whoa']
+        end
+    end
+
+    describe 'buffer size limit with indicator' do
+        before :each do
+            @buffer = UvRays::BufferedTokenizer.new({
+                delimiter: "\n\r",
+                indicator: "Start",
+                size_limit: 10
+            })
+        end
+
+        it "should empty the buffer if the limit is exceeded" do
+            result = @buffer.extract('1234567890G')
+            result.should == []
+            @buffer.flush.should == '890G'
+        end
+    end
+
+    describe 'buffer size limit without indicator' do
+        before :each do
+            @buffer = UvRays::BufferedTokenizer.new({
+                delimiter: "\n\r",
+                size_limit: 10
+            })
+        end
+
+        it "should empty the buffer if the limit is exceeded" do
+            result = @buffer.extract('1234567890G')
+            result.should == []
+            @buffer.flush.should == ''
+        end
+    end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,137 @@
+require 'uv-rays'
+
+
+module TestConnect
+	def post_init
+
+	end
+
+	def on_connect(connection)
+		@connected = true
+	end
+
+	def on_close
+		@disconnected = true
+		@loop.stop
+	end
+
+	def on_read(data, connection, port = nil)
+		@received = data
+		close_connection(:after_writing)
+	end
+
+	def check
+		return [@connected, @disconnected, @received]
+	end
+end
+
+module TestServer
+	def post_init *args
+		if args[0] == :use_tls
+			use_tls
+		end
+	end
+
+	def on_connect(conection)
+		write('hello')
+	end
+
+	def on_read(*args) #data, ip, port, conection)
+		#p "was sent #{data} from port #{port}"
+		#send_datagram(data, ip, port)
+		@loop.stop
+	end
+end
+
+
+describe UvRays::Connection do
+	before :each do
+		@loop = Libuv::Loop.new
+		@general_failure = []
+		@timeout = @loop.timer do
+			@loop.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+	end
+
+	after :each do
+		module TestConnect
+			remove_const :UR_CONNECTION_CLASS
+		end
+		module TestServer
+			remove_const :UR_CONNECTION_CLASS
+		end
+	end
+	
+	describe 'basic tcp client server' do
+		it "should send some data and shutdown the socket", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				UV.start_server '127.0.0.1', 3210, TestServer
+				@klass = UV.connect '127.0.0.1', 3210, TestConnect
+			}
+
+			@general_failure.should == []
+			res = @klass.check
+			res[0].should == true
+			res[1].should == true
+			res[2].should == 'hello'
+		end
+	end
+
+	describe 'basic tcp client server with tls' do
+		it "should send some data and shutdown the socket", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				UV.start_server '127.0.0.1', 3212, TestServer, :use_tls
+				@klass = UV.connect '127.0.0.1', 3212, TestConnect
+				@klass.use_tls
+			}
+
+			@general_failure.should == []
+			res = @klass.check
+			res[0].should == true
+			res[1].should == true
+			res[2].should == 'hello'
+		end
+	end
+
+	describe 'basic udp client server' do
+		it "should send some data and close the socket", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				UV.open_datagram_socket TestServer, '127.0.0.1', 3210
+				@klass = UV.open_datagram_socket TestConnect, '127.0.0.1', 3211
+				@klass.send_datagram('hello', '127.0.0.1', 3210)
+			}
+
+			@general_failure.should == []
+			res = @klass.check
+			res[0].should == nil
+			res[1].should == nil
+			res[2].should == nil #'hello' (libuv receive bug?)
+		end
+	end
+end

data/spec/http_endpoint_spec.rb

@@ -0,0 +1,279 @@
+require 'uv-rays'
+
+
+module HttpServer
+	def post_init
+		@parser = ::HttpParser::Parser.new(self)
+        @state = ::HttpParser::Parser.new_instance
+        @state.type = :request
+	end
+
+	def on_message_complete(parser)
+		write("HTTP/1.1 200 OK\r\nContent-type: text/html\r\nContent-length: 0\r\n\r\n")
+	end
+
+	def on_read(data, connection)
+		if @parser.parse(@state, data)
+            p 'parse error'
+            p @state.error
+        end
+	end
+end
+
+module OldServer
+	def post_init
+		@parser = ::HttpParser::Parser.new(self)
+        @state = ::HttpParser::Parser.new_instance
+        @state.type = :request
+	end
+
+	def on_message_complete(parser)
+		write("HTTP/1.0 200 OK\r\nContent-type: text/html\r\nContent-length: 0\r\n\r\n")
+	end
+
+	def on_read(data, connection)
+		if @parser.parse(@state, data)
+            p 'parse error'
+            p @state.error
+        end
+	end
+end
+
+
+describe UvRays::HttpEndpoint do
+	before :each do
+		@loop = Libuv::Loop.new
+		@general_failure = []
+		@timeout = @loop.timer do
+			@loop.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@request_failure = proc { |err|
+			@general_failure << err
+			@loop.stop
+		}
+	end
+	
+	describe 'basic http request' do
+		it "should send a request then receive a response", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, HttpServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			@general_failure.should == []
+			@response[:headers][:"Content-type"].should == 'text/html'
+			@response[:headers].http_version.should == '1.1'
+			@response[:headers].status.should == 200
+			@response[:headers].cookies.should == {}
+			@response[:headers].keep_alive.should == true
+		end
+
+		it "should send multiple requests on the same connection", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, HttpServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					#@loop.stop
+				}, @request_failure)
+				
+				request2 = server.get(:path => '/')
+				request2.then(proc { |response|
+					@response2 = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			@general_failure.should == []
+			@response[:headers][:"Content-type"].should == 'text/html'
+			@response[:headers].http_version.should == '1.1'
+			@response[:headers].status.should == 200
+			@response[:headers].cookies.should == {}
+			@response[:headers].keep_alive.should == true
+
+			@response2[:headers][:"Content-type"].should == 'text/html'
+			@response2[:headers].http_version.should == '1.1'
+			@response2[:headers].status.should == 200
+			@response2[:headers].cookies.should == {}
+			@response2[:headers].keep_alive.should == true
+		end
+
+		it "should send pipelined requests on the same connection", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, HttpServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/', :pipeline => true)
+				request.then(proc { |response|
+					@response = response
+					#@loop.stop
+				}, @request_failure)
+				
+				request2 = server.get(:path => '/', :pipeline => true)
+				request2.then(proc { |response|
+					@response2 = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			@general_failure.should == []
+			@response[:headers][:"Content-type"].should == 'text/html'
+			@response[:headers].http_version.should == '1.1'
+			@response[:headers].status.should == 200
+			@response[:headers].cookies.should == {}
+			@response[:headers].keep_alive.should == true
+
+			@response2[:headers][:"Content-type"].should == 'text/html'
+			@response2[:headers].http_version.should == '1.1'
+			@response2[:headers].status.should == 200
+			@response2[:headers].cookies.should == {}
+			@response2[:headers].keep_alive.should == true
+		end
+	end
+
+	describe 'old http request' do
+		it "should send a request then receive a response", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, OldServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			@general_failure.should == []
+			@response[:headers][:"Content-type"].should == 'text/html'
+			@response[:headers].http_version.should == '1.0'
+			@response[:headers].status.should == 200
+			@response[:headers].cookies.should == {}
+			@response[:headers].keep_alive.should == false
+		end
+
+		it "should send multiple requests", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, OldServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					#@loop.stop
+				}, @request_failure)
+				
+				request2 = server.get(:path => '/')
+				request2.then(proc { |response|
+					@response2 = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			@general_failure.should == []
+			@response[:headers][:"Content-type"].should == 'text/html'
+			@response[:headers].http_version.should == '1.0'
+			@response[:headers].status.should == 200
+			@response[:headers].cookies.should == {}
+			@response[:headers].keep_alive.should == false
+
+			@response2[:headers][:"Content-type"].should == 'text/html'
+			@response2[:headers].http_version.should == '1.0'
+			@response2[:headers].status.should == 200
+			@response2[:headers].cookies.should == {}
+			@response2[:headers].keep_alive.should == false
+		end
+
+		it "should fail to send pipelined requests", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, OldServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/', :pipeline => true)
+				request.then(proc { |response|
+					@response = response
+					#@loop.stop
+				}, @request_failure)
+				
+				request2 = server.get(:path => '/', :pipeline => true)
+				request2.then(proc { |response|
+					@response2 = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			@general_failure.should == [:disconnected]
+			@response[:headers][:"Content-type"].should == 'text/html'
+			@response[:headers].http_version.should == '1.0'
+			@response[:headers].status.should == 200
+			@response[:headers].cookies.should == {}
+			@response[:headers].keep_alive.should == false
+			# Response 2 was the general failure
+		end
+	end
+end