mt-libuv 4.1.0

data/spec/dns_spec.rb

@@ -0,0 +1,110 @@
+require 'mt-libuv'
+
+
+describe MTLibuv::Dns do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.default
+		@reactor.notifier do |error, context|
+			begin
+				puts "Log called: #{context}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+			rescue Exception
+				puts 'error in logger'
+			end
+		end
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@reactor.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			puts "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+		end
+	end
+
+	after :each do
+		@reactor.notifier
+	end
+	
+	it "should resolve localhost using IP4", :network => true do
+		@reactor.run { |reactor|
+			@reactor.lookup('localhost', wait: false).then proc { |addrinfo|
+				@result = addrinfo[0][0]
+				@timeout.close
+				@reactor.stop
+			}, proc { |err|
+				@general_failure << err
+				@timeout.close
+				@reactor.stop
+			}
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@result).to eq('127.0.0.1')
+	end
+
+	it "should resolve localhost using IP6", :network => true do
+		@reactor.run { |reactor|
+			@reactor.lookup('localhost', :IPv6, wait: false).then proc { |addrinfo|
+				@result = addrinfo[0][0]
+				@timeout.close
+				@reactor.stop
+			}, proc { |err|
+				@general_failure << err
+				@timeout.close
+				@reactor.stop
+			}
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@result).to eq('::1')
+	end
+
+	it "should resolve reactor back" do
+		@reactor.run { |reactor|
+			@reactor.lookup('127.0.0.1', wait: false).then proc { |addrinfo|
+				@result = addrinfo[0][0]
+				@timeout.close
+				@reactor.stop
+			}, proc { |err|
+				@general_failure << err
+				@timeout.close
+				@reactor.stop
+			}
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@result).to eq('127.0.0.1')
+	end
+
+	it "should work with coroutines" do
+		@reactor.run { |reactor|
+			begin
+				addrinfo = @reactor.lookup('127.0.0.1')
+				@result = [addrinfo[0][0]]
+
+				begin
+					addrinfo = @reactor.lookup('test.fail.blah').results
+					@general_failure << "should have failed"
+					@timeout.close
+					@reactor.stop
+				rescue => err 
+					@result << err.class
+					@timeout.close
+					@reactor.stop
+				end
+			rescue => err 
+				@general_failure << err
+				@timeout.close
+				@reactor.stop
+			end
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@result).to eq(['127.0.0.1', MTLibuv::Error::EAI_NONAME])
+	end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,43 @@
+require 'mt-libuv'
+
+describe MTLibuv::Accessors do
+    describe 'basic usage' do
+        it 'should work seamlessly with the default thread' do
+            count = 0
+            reactor do |reactor|
+                reactor.timer {
+                    count += 1
+                    reactor.stop if count == 3
+                }.start(50, 10)
+            end
+
+            expect(count).to eq(3)
+        end
+
+        it 'work simply with new threads' do
+            count = 0
+            sig = ConditionVariable.new
+            mutex = Mutex.new
+            mutex.synchronize {
+
+                # This will run on a new thread
+                MTLibuv::Reactor.new do |reactor|
+                    reactor.timer {
+                        count += 1
+
+                        if count == 3
+                            reactor.stop
+                            mutex.synchronize {
+                                sig.signal
+                            }
+                        end
+                    }.start(50, 10)
+                end
+
+                sig.wait(mutex)
+            }
+
+            expect(count).to eq(3)
+        end
+    end
+end

data/spec/filesystem_spec.rb

@@ -0,0 +1,270 @@
+require 'mt-libuv'
+require 'thread'
+
+
+describe MTLibuv::Filesystem do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.default
+		@filesystem = @reactor.filesystem
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(4000)
+
+		@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
+
+		@thefile = "test-file.txt"
+
+		@reactor.all(@filesystem, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+		end
+	end
+	
+	describe 'directory navigation' do
+		it "should list the contents of a folder" do
+			@reactor.run { |reactor|
+				currentDir = Dir.pwd
+				listing = @filesystem.readdir(currentDir, wait: false)
+				listing.then do |result|
+					@log = result
+				end
+				listing.catch do |error|
+					@general_failure << error
+				end
+				listing.finally do
+					@timeout.close
+					@reactor.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect((@log.length > 0)).to eq(true)
+		end
+	end
+
+	describe 'file manipulation' do
+		it "should create and write to a file" do
+			@reactor.run { |reactor|
+				file = @reactor.file(@thefile, File::CREAT|File::WRONLY)
+				begin
+					file.write('write some data to a file')
+					file.chmod(777)
+					@timeout.close
+					@reactor.stop
+					@log = :success
+				rescue => error
+					@general_failure << error
+					@timeout.close
+					@reactor.stop
+				ensure
+					file.close
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(:success)
+		end
+
+		it "should return stats on the file" do
+			@reactor.run { |reactor|
+				file = @reactor.file(@thefile, File::RDONLY)
+				begin
+					stats = file.stat
+					@timeout.close
+					@reactor.stop
+					@log << stats[:st_mtim][:tv_sec]
+				rescue => error
+					@general_failure << error
+					@timeout.close
+					@reactor.stop
+				ensure
+					file.close
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log[0]).to be_kind_of(Integer)
+			expect(@log.length).to eql(1)
+		end
+
+		it "should read from a file" do
+			@reactor.run { |reactor|
+				file = @reactor.file(@thefile, File::RDONLY)
+				begin
+					result = file.read(100)
+					@timeout.close
+					@reactor.stop
+					@log = result
+				rescue => error
+					@general_failure << error
+					@timeout.close
+					file.close
+					@reactor.stop
+				ensure
+					file.close
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq('write some data to a file')
+		end
+
+		it "should delete a file" do
+			@reactor.run { |reactor|
+				op = @reactor.filesystem.unlink(@thefile, wait: false)
+				op.then do
+					@timeout.close
+					@reactor.stop
+					@log = :success
+				end
+				op.catch do |error|
+					@general_failure << error
+					@timeout.close
+					@reactor.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(:success)
+		end
+	end
+
+	describe 'file streaming' do
+		it "should send a file over a stream", :network => true do
+			@reactor.run { |reactor|
+				@server = @reactor.tcp
+				@client = @reactor.tcp
+
+				@server.bind('127.0.0.1', 34570) do |client|
+					client.progress do |data|
+						file = @reactor.file('.rspec', File::RDONLY) do
+							file.send_file(client, wait: false).then(proc {
+								file.close
+								client.close
+							}, proc { |error|
+								@general_failure << error
+							})
+						end
+						file.catch do |error|
+							@general_failure << error.inspect
+							file.close
+							client.close
+						end
+					end
+					client.start_read
+					client.finally do
+						@timeout.close
+						@server.close
+						@reactor.stop
+					end
+				end
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+					@reactor.stop
+				end
+				# start listening
+				@server.listen(5)
+
+
+				# connect client to server
+				@client.connect('127.0.0.1', 34570) do |client|
+					client.progress do |data|
+						@log << data
+					end
+
+					@client.start_read
+					@client.write('send file')
+				end
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+					@server.close
+					@reactor.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			# Windows GIT adds the carriage return
+			if FFI::Platform.windows?
+				expect(@log).to eq(["--format progress\r\n"])
+			else
+				expect(@log).to eq(["--format progress\n"])
+			end
+		end
+
+		it "should send a file as a HTTP chunked response", :network => true do
+			@reactor.run { |reactor|
+				@server = @reactor.tcp
+				@client = @reactor.tcp
+
+				@server.bind('127.0.0.1', 34568) do |client|
+					client.progress do |data|
+						file = @reactor.file('.rspec', File::RDONLY) do
+							file.send_file(client, using: :http, wait: false).then(proc {
+								file.close
+								client.close
+							}, proc { |error|
+								@general_failure << error
+							})
+						end
+						file.catch do |error|
+							@general_failure << error.inspect
+							file.close
+							client.close
+						end
+					end
+					client.start_read
+					client.finally do
+						@timeout.close
+						@server.close
+						@reactor.stop
+					end
+				end
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+					@reactor.stop
+				end
+				# start listening
+				@server.listen(5)
+
+
+				# connect client to server
+				@client.connect('127.0.0.1', 34568) do |client|
+					client.progress do |data|
+						@log << data
+					end
+
+					@client.start_read
+					@client.write('send file')
+				end
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+					@server.close
+					@reactor.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+
+			# Windows GIT adds the carriage return
+			if FFI::Platform.windows?
+				expect(@log.join('')).to eq("13\r\n--format progress\r\n\r\n0\r\n\r\n")
+			else
+				expect(@log.join('')).to eq("12\r\n--format progress\n\r\n0\r\n\r\n")
+			end
+		end
+	end
+end

data/spec/idle_spec.rb

@@ -0,0 +1,44 @@
+require 'mt-libuv'
+
+
+describe MTLibuv::Idle do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.default
+		@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
+		@timeout = @reactor.timer {
+			@reactor.stop
+			@general_failure << "test timed out"
+		}.start(5000)
+	end
+	
+	it "should increase the idle count when there is nothing to process" do
+		@reactor.run { |reactor|
+			@idle_calls = 0
+  
+			idle = @reactor.idle { |e|
+				@idle_calls += 1
+			}.start
+
+			stopper = @reactor.timer {
+				idle.stop.close
+				stopper.close
+				@timeout.close
+				@reactor.stop
+			}.start(1000)
+
+			expect(@reactor.active_handles).to be >= 4
+		}
+
+		expect(@general_failure).to eq([])
+		expect((@idle_calls > 0)).to eq(true)
+	end
+end

data/spec/pipe_spec.rb

@@ -0,0 +1,151 @@
+require 'mt-libuv'
+
+
+describe MTLibuv::Pipe do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.new
+		@server = @reactor.pipe
+		@client = @reactor.pipe
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@pipefile = "/tmp/test-pipes.pipe"
+
+		@reactor.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+		end
+
+		@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
+
+	after :each do
+		begin
+			File.unlink(@pipefile)
+		rescue
+		end
+	end
+	
+	describe 'bidirectional inter process communication' do
+
+		it "should send a ping and return a pong" do
+			@reactor.run { |reactor|
+				@server.bind(@pipefile) do |client|
+					client.progress do |data|
+						@log << data
+						client.write('pong')
+					end
+					client.start_read
+				end
+
+				# catch server errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+					@reactor.stop
+
+					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+				end
+
+				# start listening
+				@server.listen(1024)
+
+
+
+				# connect client to server
+				@client.connect(@pipefile) do |client|
+					@client.progress do |data|
+						@log << data
+
+						@client.close
+					end
+
+					@client.start_read
+					@client.write('ping')
+				end
+
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+					@reactor.stop
+
+					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+				end
+
+				# Stop the reactor once the client handle is closed
+				@client.finally do
+					@server.close
+					@reactor.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong'])
+		end
+	end
+
+	# This test won't pass on windows as pipes don't work like this on windows
+	describe 'unidirectional pipeline', :unix_only => true do
+		before :each do
+			system "/usr/bin/mkfifo", @pipefile
+		end
+
+		it "should send work to a consumer" do
+			@reactor.run { |reactor|
+				heartbeat = @reactor.timer
+				@file1 = @reactor.file(@pipefile, File::RDWR|File::NONBLOCK) do
+					@server.open(@file1.fileno) do |server|
+						heartbeat.progress  do
+							@server.write('workload').catch do |err|
+								@general_failure << err
+							end
+						end
+						heartbeat.start(0, 200)
+					end
+				end
+				@file1.catch do |e|
+					@general_failure << "Log called: #{e.inspect} - #{e.message}\n"
+				end
+
+				@file2 = @reactor.file(@pipefile, File::RDWR|File::NONBLOCK) do
+					# connect client to server
+					@client.open(@file2.fileno) do |consumer|
+						consumer.progress do |data|
+							@log = data
+						end
+
+						consumer.start_read
+					end
+				end
+
+
+				timeout = @reactor.timer do
+					@server.close
+					@client.close
+					timeout.close
+					heartbeat.close
+					@reactor.stop
+				end
+				timeout.start(1000)
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq('workload')
+		end
+	end
+end