mt-uv-rays 2.4.7

data/spec/buffered_tokenizer_spec.rb

@@ -0,0 +1,277 @@
+require 'mt-uv-rays'
+
+describe MTUV::BufferedTokenizer do
+    describe 'delimiter' do
+
+        before :each do
+            @buffer = MTUV::BufferedTokenizer.new({
+                delimiter: "\n\r",
+                encoding: "ASCII-8BIT"
+            })
+        end
+
+        it "should not return empty messages" do
+            msg1 = "\n\rtest\n\r\n\rwhoa\n\r\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test', 'whoa'])
+        end
+
+        it "should not return anything when a complete message is not available" do
+            msg1 = "test"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+        end
+
+        it "should not return anything when the messages is empty" do
+            msg1 = ""
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+        end
+
+        it "should tokenize messages where the data is a complete message" do
+            msg1 = "test\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test'])
+        end
+
+        it "should return multiple complete messages" do
+            msg1 = "test\n\rwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test', 'whoa'])
+        end
+        
+        it "should tokenize messages where the delimiter is split" do
+            msg1 = "test\n"
+            msg2 = "\rwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+            result = @buffer.extract(msg2)
+            expect(result).to eq(['test', 'whoa'])
+
+
+            msg3 = "test\n"
+            msg4 = "\rwhoa\n"
+            msg5 = "\r"
+
+            result = @buffer.extract(msg3)
+            expect(result).to eq([])
+            result = @buffer.extract(msg4)
+            expect(result).to eq(['test']        )
+
+            result = @buffer.extract(msg5)
+            expect(result).to eq(['whoa'])
+        end
+    end
+
+
+
+    describe 'indicator with delimiter' do
+
+        before :each do
+            @buffer = MTUV::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)
+            expect(result).to eq([])
+        end
+
+        it "should not return anything when the messages is empty" do
+            msg1 = ""
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+        end
+
+        it "should tokenize messages where the data is a complete message" do
+            msg1 = "GOtest\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test'])
+        end
+
+        it "should discard data that is not relevant" do
+            msg1 = "1234-GOtest\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test'])
+        end
+
+        it "should return multiple complete messages" do
+            msg1 = "GOtest\n\rGOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test', 'whoa'])
+        end
+
+        it "should discard data between multiple complete messages" do
+            msg1 = "1234-GOtest\n\r12345-GOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test', 'whoa'])
+        end
+        
+        it "should tokenize messages where the delimiter is split" do
+            msg1 = "GOtest\n"
+            msg2 = "\rGOwhoa\n\r"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+            result = @buffer.extract(msg2)
+            expect(result).to eq(['test', 'whoa'])
+
+
+            msg3 = "GOtest\n"
+            msg4 = "\rGOwhoa\n"
+            msg5 = "\r"
+
+            result = @buffer.extract(msg3)
+            expect(result).to eq([])
+            result = @buffer.extract(msg4)
+            expect(result).to eq(['test']        )
+
+            result = @buffer.extract(msg5)
+            expect(result).to eq(['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)
+            expect(result).to eq(['test'])
+            result = @buffer.extract(msg2)
+            expect(result).to eq([])
+            result = @buffer.extract(msg3)
+            expect(result).to eq(['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)
+            expect(result).to eq(['test'])
+            result = @buffer.extract(msg2)
+            expect(result).to eq([])
+            result = @buffer.extract(msg3)
+            expect(result).to eq(['whoa', 'whoa'])
+        end
+    end
+
+    describe 'indicator with length' do
+        before :each do
+            @buffer = MTUV::BufferedTokenizer.new({
+                indicator: "GO",
+                msg_length: 4 # length without the indicator
+            })
+        end
+
+        it "should not return anything when a complete message is not available" do
+            msg1 = "GO123"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+        end
+
+        it "should not return anything when the messages is empty" do
+            msg1 = ""
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq([])
+        end
+
+        it "should tokenize messages where the data is a complete message" do
+            msg1 = "GO1234"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['1234'])
+        end
+
+        it "should discard data that is not relevant" do
+            msg1 = "1234-GO1234"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['1234'])
+        end
+
+        it "should return multiple complete messages" do
+            msg1 = "GO1234GOhome"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['1234', 'home'])
+        end
+
+        it "should discard data between multiple complete messages" do
+            msg1 = "1234-GO123412345-GOhome"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['1234', 'home'])
+        end
+
+        it "should tokenize messages where the indicator is split" do
+            msg1 = "GOtestG"
+            msg2 = "Owhoa"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test'])
+            result = @buffer.extract(msg2)
+            expect(result).to eq(['whoa'])
+        end
+
+        it "should tokenize messages where the indicator is split and there is discard data" do
+            msg1 = "GOtest\n\r1234G"
+            msg2 = "Owhoa\n"
+
+            result = @buffer.extract(msg1)
+            expect(result).to eq(['test'])
+            result = @buffer.extract(msg2)
+            expect(result).to eq(['whoa'])
+        end
+    end
+
+    describe 'buffer size limit with indicator' do
+        before :each do
+            @buffer = MTUV::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')
+            expect(result).to eq([])
+            expect(@buffer.flush).to eq('890G')
+        end
+    end
+
+    describe 'buffer size limit without indicator' do
+        before :each do
+            @buffer = MTUV::BufferedTokenizer.new({
+                delimiter: "\n\r",
+                size_limit: 10
+            })
+        end
+
+        it "should empty the buffer if the limit is exceeded" do
+            result = @buffer.extract('1234567890G')
+            expect(result).to eq([])
+            expect(@buffer.flush).to eq('')
+        end
+    end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,124 @@
+require 'mt-uv-rays'
+
+
+module TestConnect
+	def post_init
+
+	end
+
+	def on_connect(connection)
+		@connected = true
+	end
+
+	def on_close
+		@disconnected = true
+		@reactor.stop
+	end
+
+	def on_read(data, connection, port = nil, udp_test = nil)
+		@received = data
+		close_connection(:after_writing)
+		@reactor.stop if udp_test 	# misc is set when test connect is a UDP connection
+	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(data, ip, port, conection)
+		# ephemeral port is used for sending on windows and linux?
+		# Bound port seems to be used on OSX...
+		# TODO:: Needs investigation, might be a MTLibuv bug
+		send_datagram(data, ip, 3211)
+	end
+end
+
+
+describe MTUV::Connection do
+	before :each do
+		@reactor = MTLibuv::Reactor.new
+		@reactor.notifier do |error, context|
+			begin
+				@general_failure << "Log called: #{context}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
+			rescue Exception
+				@general_failure << "error in logger #{e.inspect}"
+			end
+		end
+		@general_failure = []
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+	end
+
+	after :each do
+		module TestConnect
+			begin
+				remove_const :UR_CONNECTION_CLASS
+			rescue
+			end
+		end
+		module TestServer
+			begin
+				remove_const :UR_CONNECTION_CLASS
+			rescue
+			end
+		end
+	end
+	
+	describe 'basic tcp client server' do
+		it "should send some data and shutdown the socket" do
+			@reactor.run { |reactor|
+				MTUV.start_server '127.0.0.1', 3210, TestServer
+				@klass = MTUV.connect '127.0.0.1', 3210, TestConnect
+			}
+
+			expect(@general_failure).to eq([])
+			res = @klass.check
+			expect(res[0]).to eq(true)
+			expect(res[1]).to eq(true)
+			expect(res[2]).to eq('hello')
+		end
+
+		it "should not call connect on connection failure" do
+			@reactor.run { |reactor|
+				@klass = MTUV.connect '127.0.0.1', 8123, TestConnect
+			}
+
+			expect(@general_failure).to eq([])
+			res = @klass.check
+			expect(res[0]).to eq(nil)
+			expect(res[1]).to eq(true)	# Disconnect
+			expect(res[2]).to eq(nil)
+		end
+	end
+
+	describe 'basic udp client server' do
+		it "should send some data and close the socket" do
+			@reactor.run { |reactor|
+				MTUV.open_datagram_socket TestServer, '127.0.0.1', 3210
+				@klass = MTUV.open_datagram_socket TestConnect, '127.0.0.1', 3211
+				@klass.send_datagram('hello', '127.0.0.1', 3210)
+			}
+
+			expect(@general_failure).to eq([])
+			res = @klass.check
+			expect(res[0]).to eq(nil)
+			expect(res[1]).to eq(nil)
+			expect(res[2]).to eq('hello')
+		end
+	end
+end