mt-libuv 4.1.0

data/spec/spawn_spec.rb

@@ -0,0 +1,119 @@
+require 'mt-libuv'
+
+describe MTLibuv::Spawn do
+    describe 'basic spawn of external process' do
+        it "should accept arguments and return an termination signal code" do
+            @reactor = MTLibuv::Reactor.new
+            @log = []
+            @reactor.run { |reactor|
+                begin
+                    p = MTLibuv::Spawn.new(reactor, './spec/test.sh', args: ['arg1', 'arg2'], env: ['SOME_VAR=123'])
+                    p.stdout.progress do |data|
+                        @log << data
+                    end
+                    p.stdout.start_read
+                    @log << p.value
+                rescue => e
+                    @log << e
+                    @reactor.stop
+                end
+            }
+
+            term_signal = @log.pop
+            expect(term_signal).to be(0)
+
+            expect(@log[0]).to eq("123\narg1\narg2\n")
+        end
+
+        it "should return termination signal if exit code was 0" do
+            @reactor = MTLibuv::Reactor.new
+            @log = []
+            @reactor.run { |reactor|
+                begin
+                    p = MTLibuv::Spawn.new(reactor, './spec/test.sh', args: ['arg1', 'arg2'], env: ['SOME_VAR=123'])
+                    p.kill
+                    p.stdout.progress do |data|
+                        @log << data
+                    end
+                    p.stdout.start_read
+                    @log << p.value
+                rescue => e
+                    @log << e
+                    @reactor.stop
+                end
+            }
+
+            term_signal = @log.pop
+            expect(term_signal).to be(2)
+            expect(@log[0]).to be(nil)
+        end
+
+        it "should fail if exit code was not 0 and read output from stderr" do
+            @reactor = MTLibuv::Reactor.new
+            @log = []
+            @reactor.run { |reactor|
+                begin
+                    p = MTLibuv::Spawn.new(reactor, './spec/test_fail.sh')
+                    p.stderr.progress do |data|
+                        @log << data
+                    end
+                    p.stderr.start_read
+                    @log << p.value
+                rescue => e
+                    @log << e
+                    @reactor.stop
+                end
+            }
+
+            stderr = @log[0]
+            e = @log[1]
+            expect(e.class).to be(::MTLibuv::Error::ProcessExitCode)
+            expect(e.exit_status).to be(1)
+            expect(e.term_signal).to be(0)
+            expect(stderr.length).to be > 0
+        end
+
+        it "should be interactive" do
+            @reactor = MTLibuv::Reactor.new
+            @log = []
+            @reactor.run { |reactor|
+                begin
+                    p = MTLibuv::Spawn.new(reactor, './spec/test_read.sh')
+                    p.stdout.progress do |data|
+                        @log << data
+                    end
+                    p.stdout.start_read
+                    p.stdin.write("2017\n")
+                    @log << p.value
+                rescue => e
+                    @log << e
+                    @reactor.stop
+                end
+            }
+
+            term_signal = @log.pop
+            expect(term_signal).to be(0)
+
+            expect(@log[0]).to eq("you entered 2017 - sweet\n")
+        end
+
+        it "should support inheriting parent processes streams" do
+            @reactor = MTLibuv::Reactor.new
+            @log = []
+            @reactor.run { |reactor|
+                begin
+                    p = MTLibuv::Spawn.new(reactor, './spec/test.sh', args: ['arg1', 'arg2'], env: ['SOME_VAR=123'], mode: :inherit)
+                    @log << p.stdout
+                    @log << p.value
+                rescue => e
+                    @log << e
+                    @reactor.stop
+                end
+            }
+
+            term_signal = @log.pop
+            expect(term_signal).to be(0)
+            expect(@log[0]).to be(nil)
+        end
+    end
+end

data/spec/tcp_spec.rb

@@ -0,0 +1,272 @@
+require 'mt-libuv'
+require 'thread'
+
+
+describe MTLibuv::TCP do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.new
+		@server = @reactor.tcp
+		@client = @reactor.tcp
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@reactor2.stop if @reactor2
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@reactor.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+		end
+
+
+		@pipefile = "/tmp/test-pipe.pipe"
+		@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 => e
+				@general_failure << "error in logger #{e.inspect}"
+			end
+		end
+
+		begin
+			File.unlink(@pipefile)
+		rescue
+		end
+	end
+	
+	describe 'basic client server' do
+		it "should send a ping and return a pong", :network => true do
+			@reactor.run { |reactor|
+				@server.bind('127.0.0.1', 34567) do |client|
+					client.progress do |data|
+						@log << data
+
+						client.write('pong')
+					end
+					client.start_read
+				end
+
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# start listening
+				@server.listen(1024)
+
+
+
+				# connect client to server
+				@client.connect('127.0.0.1', 34567) do |client|
+					client.progress do |data|
+						@log << data
+
+						@client.shutdown
+					end
+
+					@client.start_read
+					@client.write('ping')
+				end
+
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# close the handle
+				@client.finally do
+					@server.close
+					@reactor.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong'])
+		end
+
+		it "should work with coroutines", :network => true do
+			@reactor.run { |reactor|
+				@server.bind('127.0.0.1', 34567) do |client|
+					client.progress do |data|
+						@log << data
+
+						client.write('pong')
+					end
+					client.start_read
+				end
+
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# start listening
+				@server.listen(1024)
+
+				# connect client to server
+				@client.progress do |data|
+					@log << data
+
+					addrinfo = @reactor.lookup('127.0.0.1')
+					@log << addrinfo[0][0]
+
+					@client.shutdown
+				end
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# close the handle
+				@client.finally do
+					@server.close
+					@reactor.stop
+				end
+				@client.connect('127.0.0.1', 34567)
+				@client.start_read
+				@client.write('ping')
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong', '127.0.0.1'])
+		end
+
+		it "should quack a bit like an IO object", :network => true do
+			@reactor.run { |reactor|
+				@server.bind('127.0.0.1', 34567) do |client|
+					@log << client.read(4)
+					client.write('pong')
+				end
+
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# start listening
+				@server.listen(1024)
+
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# close the handle
+				@client.finally do
+					@server.close
+					@reactor.stop
+				end
+				@client.connect('127.0.0.1', 34567)
+				@client.write('ping')
+				@log << @client.read(4)
+				addrinfo = @reactor.lookup('127.0.0.1')
+				@log << addrinfo[0][0]
+				@client.shutdown
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong', '127.0.0.1'])
+		end
+	end
+
+	it "should handle requests on different threads", :network => true do
+		@sync = Mutex.new
+
+		@reactor.run { |reactor|
+			@remote = nil
+			@server.bind('127.0.0.1', 45678) do |client|
+				@remote.write2(client)
+			end
+
+			# catch errors
+			@server.catch do |reason|
+				@general_failure << reason.inspect
+			end
+
+
+			@pipeserve = @reactor.pipe(true)
+			@pipeserve.bind(@pipefile) do |client|
+				@remote = client
+
+				# start listening on TCP server
+				@server.listen(1024)
+
+				# connect client to server
+				@client.connect('127.0.0.1', 45678) do |client|
+					client.progress do |data|
+						@sync.synchronize {
+							@log << data
+						}
+						@client.shutdown
+					end
+
+					@client.start_read
+					@client.write('ping')
+				end
+
+				@pipeserve.getsockname
+			end
+
+			# start listening
+			@pipeserve.listen(1024)
+
+
+
+			# catch errors
+			@client.catch do |reason|
+				@general_failure << reason.inspect
+			end
+
+			# close the handle
+			@client.finally do
+				@server.close
+				@pipeserve.close
+			end
+			
+
+
+			Thread.new do
+				@reactor2 = MTLibuv::Reactor.new
+				@reactor2.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
+				@pipeclient = @reactor2.pipe(true)
+
+
+				@reactor2.run do  |reactor|
+					# connect client to server
+					@pipeclient.connect(@pipefile) do |client|
+						@pipeclient.progress do |data|
+							connection = @pipeclient.check_pending
+
+							connection.progress do |data|
+								@sync.synchronize {
+									@log << data
+								}
+								connection.write('pong')
+							end
+							connection.start_read
+							connection.finally do
+								@pipeclient.close
+								@reactor2.stop
+								@reactor.stop
+							end
+						end
+
+						@pipeclient.start_read
+					end
+				end
+			end
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@log).to eq(['ping', 'pong'])
+	end
+end

data/spec/test.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+echo $SOME_VAR
+echo $1
+echo $2

data/spec/test_fail.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+ech $SOME_VAR
+exit 1

data/spec/test_read.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+read year
+echo "you entered $year - sweet"

data/spec/timer_spec.rb

@@ -0,0 +1,14 @@
+require 'mt-libuv'
+
+describe MTLibuv::Timer do
+	describe 'setting properties' do
+		it "should allow repeat to be set" do
+      @reactor = MTLibuv::Reactor.new
+			@reactor.run { |logger|
+        @timer = @reactor.timer
+        @timer.repeat = 5
+        expect(@timer.repeat).to eq(5)
+      }
+    end
+  end
+end

data/spec/udp_spec.rb

@@ -0,0 +1,73 @@
+require 'mt-libuv'
+require 'thread'
+
+
+describe MTLibuv::UDP do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.new
+		@server = @reactor.udp
+		@client = @reactor.udp
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@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 => e
+				@general_failure << "error in logger #{e.inspect}"
+			end
+		end
+
+		@reactor.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+		end
+	end
+	
+	describe 'basic client server' do
+		it "should send a ping and return a pong", :network => true do
+			@reactor.run { |reactor|
+				@server.bind('127.0.0.1', 34567)
+				@server.progress do |data, ip, port, server|
+					@log << data
+					server.send(ip, port, 'pong')
+				end
+				@server.start_read
+
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+
+				# connect client to server
+				@client.bind('127.0.0.1', 34568)
+				@client.progress do |data, ip, port, client|
+					@log << data
+					client.close
+				end
+				@client.start_read
+				@client.send('127.0.0.1', 34567, 'ping')
+
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# close the handle
+				@client.finally do
+					@server.close
+					@reactor.stop
+				end
+			}
+
+			expect(@log).to eq(['ping', 'pong'])
+			expect(@general_failure).to eq([])
+		end
+	end
+end

data/spec/zen_spec.rb

@@ -0,0 +1,34 @@
+require 'mt-libuv'
+
+
+describe MTLibuv::Listener do
+	it "should ensure there are no remaining object references in callbacks", network: true do
+		require 'objspace'
+
+		checked = []
+
+		# These are created by loop objects and are never cleaned up
+		# This is OK as the loops are expected to execute for the life of the application
+		except = [::MTLibuv::Async, ::MTLibuv::Timer, ::MTLibuv::Prepare, ::MTLibuv::Signal]
+
+		ObjectSpace.each_object(Class) do |cls|
+			next unless cls.ancestors.include? ::MTLibuv::Handle
+			next if checked.include? cls
+			checked << cls
+
+			values = cls.callback_lookup.values
+			values.select! {|val| except.include?(val.class) ? false : val.class }
+
+			if values.length > 0
+				puts "\nMemory Leak in #{cls} with #{values.length} left over objects"
+				puts "Checked #{checked.length} classes, objects are:"
+				values.each do |val|
+					puts "\n#{val}\n"
+				end
+				raise 'Free the machines!'
+			end
+		end
+
+		expect(checked.length).to be > 3
+	end
+end