uv-rays 0.0.1 → 0.2.0

data/spec/buffered_tokenizer_spec.rb

@@ -1,10 +1,10 @@
 require 'uv-rays'
 
-describe UvRays::BufferedTokenizer do
+describe UV::BufferedTokenizer do
     describe 'delimiter' do
 
         before :each do
-            @buffer = UvRays::BufferedTokenizer.new({
+            @buffer = UV::BufferedTokenizer.new({
                 delimiter: "\n\r"
             })
         end
@@ -14,21 +14,21 @@ describe UvRays::BufferedTokenizer do
             msg1 = "test"
 
             result = @buffer.extract(msg1)
-            result.should == []
+            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)
-            result.should == ['test']
+            expect(result).to eq(['test'])
         end
 
         it "should return multiple complete messages" do
             msg1 = "test\n\rwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == ['test', 'whoa']
+            expect(result).to eq(['test', 'whoa'])
         end
         
         it "should tokenize messages where the delimiter is split" do
@@ -36,9 +36,9 @@ describe UvRays::BufferedTokenizer do
             msg2 = "\rwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg2)
-            result.should == ['test', 'whoa']
+            expect(result).to eq(['test', 'whoa'])
 
 
             msg3 = "test\n"
@@ -46,19 +46,19 @@ describe UvRays::BufferedTokenizer do
             msg5 = "\r"
 
             result = @buffer.extract(msg3)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg4)
-            result.should == ['test']        
+            expect(result).to eq(['test']        )
 
             result = @buffer.extract(msg5)
-            result.should == ['whoa']
+            expect(result).to eq(['whoa'])
         end
     end
 
     describe 'delimiter' do
 
         before :each do
-            @buffer = UvRays::BufferedTokenizer.new({
+            @buffer = UV::BufferedTokenizer.new({
                 delimiter: "\n\r"
             })
         end
@@ -68,28 +68,28 @@ describe UvRays::BufferedTokenizer do
             msg1 = "test"
 
             result = @buffer.extract(msg1)
-            result.should == []
+            expect(result).to eq([])
         end
 
         it "should not return anything when the messages is empty" do
             msg1 = ""
 
             result = @buffer.extract(msg1)
-            result.should == []
+            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)
-            result.should == ['test']
+            expect(result).to eq(['test'])
         end
 
         it "should return multiple complete messages" do
             msg1 = "test\n\rwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == ['test', 'whoa']
+            expect(result).to eq(['test', 'whoa'])
         end
         
         it "should tokenize messages where the delimiter is split" do
@@ -97,9 +97,9 @@ describe UvRays::BufferedTokenizer do
             msg2 = "\rwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg2)
-            result.should == ['test', 'whoa']
+            expect(result).to eq(['test', 'whoa'])
 
 
             msg3 = "test\n"
@@ -107,12 +107,12 @@ describe UvRays::BufferedTokenizer do
             msg5 = "\r"
 
             result = @buffer.extract(msg3)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg4)
-            result.should == ['test']        
+            expect(result).to eq(['test']        )
 
             result = @buffer.extract(msg5)
-            result.should == ['whoa']
+            expect(result).to eq(['whoa'])
         end
     end
 
@@ -121,7 +121,7 @@ describe UvRays::BufferedTokenizer do
     describe 'indicator with delimiter' do
 
         before :each do
-            @buffer = UvRays::BufferedTokenizer.new({
+            @buffer = UV::BufferedTokenizer.new({
                 delimiter: "\n\r",
                 indicator: "GO"
             })
@@ -132,42 +132,42 @@ describe UvRays::BufferedTokenizer do
             msg1 = "GO-somedata"
 
             result = @buffer.extract(msg1)
-            result.should == []
+            expect(result).to eq([])
         end
 
         it "should not return anything when the messages is empty" do
             msg1 = ""
 
             result = @buffer.extract(msg1)
-            result.should == []
+            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)
-            result.should == ['test']
+            expect(result).to eq(['test'])
         end
 
         it "should discard data that is not relevant" do
             msg1 = "1234-GOtest\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == ['test']
+            expect(result).to eq(['test'])
         end
 
         it "should return multiple complete messages" do
             msg1 = "GOtest\n\rGOwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == ['test', 'whoa']
+            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)
-            result.should == ['test', 'whoa']
+            expect(result).to eq(['test', 'whoa'])
         end
         
         it "should tokenize messages where the delimiter is split" do
@@ -175,9 +175,9 @@ describe UvRays::BufferedTokenizer do
             msg2 = "\rGOwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg2)
-            result.should == ['test', 'whoa']
+            expect(result).to eq(['test', 'whoa'])
 
 
             msg3 = "GOtest\n"
@@ -185,12 +185,12 @@ describe UvRays::BufferedTokenizer do
             msg5 = "\r"
 
             result = @buffer.extract(msg3)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg4)
-            result.should == ['test']        
+            expect(result).to eq(['test']        )
 
             result = @buffer.extract(msg5)
-            result.should == ['whoa']
+            expect(result).to eq(['whoa'])
         end
 
         it "should tokenize messages where the indicator is split" do
@@ -199,11 +199,11 @@ describe UvRays::BufferedTokenizer do
             msg3 = "\rGOwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == ['test']
+            expect(result).to eq(['test'])
             result = @buffer.extract(msg2)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg3)
-            result.should == ['whoa', 'whoa']
+            expect(result).to eq(['whoa', 'whoa'])
         end
 
         it "should tokenize messages where the indicator is split and there is discard data" do
@@ -212,17 +212,17 @@ describe UvRays::BufferedTokenizer do
             msg3 = "\r1234GOwhoa\n\r"
 
             result = @buffer.extract(msg1)
-            result.should == ['test']
+            expect(result).to eq(['test'])
             result = @buffer.extract(msg2)
-            result.should == []
+            expect(result).to eq([])
             result = @buffer.extract(msg3)
-            result.should == ['whoa', 'whoa']
+            expect(result).to eq(['whoa', 'whoa'])
         end
     end
 
     describe 'buffer size limit with indicator' do
         before :each do
-            @buffer = UvRays::BufferedTokenizer.new({
+            @buffer = UV::BufferedTokenizer.new({
                 delimiter: "\n\r",
                 indicator: "Start",
                 size_limit: 10
@@ -231,14 +231,14 @@ describe UvRays::BufferedTokenizer do
 
         it "should empty the buffer if the limit is exceeded" do
             result = @buffer.extract('1234567890G')
-            result.should == []
-            @buffer.flush.should == '890G'
+            expect(result).to eq([])
+            expect(@buffer.flush).to eq('890G')
         end
     end
 
     describe 'buffer size limit without indicator' do
         before :each do
-            @buffer = UvRays::BufferedTokenizer.new({
+            @buffer = UV::BufferedTokenizer.new({
                 delimiter: "\n\r",
                 size_limit: 10
             })
@@ -246,8 +246,8 @@ describe UvRays::BufferedTokenizer do
 
         it "should empty the buffer if the limit is exceeded" do
             result = @buffer.extract('1234567890G')
-            result.should == []
-            @buffer.flush.should == ''
+            expect(result).to eq([])
+            expect(@buffer.flush).to eq('')
         end
     end
 end

data/spec/connection_spec.rb

@@ -44,7 +44,7 @@ module TestServer
 end
 
 
-describe UvRays::Connection do
+describe UV::Connection do
 	before :each do
 		@loop = Libuv::Loop.new
 		@general_failure = []
@@ -57,10 +57,16 @@ describe UvRays::Connection do
 
 	after :each do
 		module TestConnect
-			remove_const :UR_CONNECTION_CLASS
+			begin
+				remove_const :UR_CONNECTION_CLASS
+			rescue
+			end
 		end
 		module TestServer
-			remove_const :UR_CONNECTION_CLASS
+			begin
+				remove_const :UR_CONNECTION_CLASS
+			rescue
+			end
 		end
 	end
 	
@@ -79,11 +85,31 @@ describe UvRays::Connection do
 				@klass = UV.connect '127.0.0.1', 3210, TestConnect
 			}
 
-			@general_failure.should == []
+			expect(@general_failure).to eq([])
 			res = @klass.check
-			res[0].should == true
-			res[1].should == true
-			res[2].should == 'hello'
+			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", :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
+
+				@klass = UV.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
 
@@ -103,11 +129,11 @@ describe UvRays::Connection do
 				@klass.use_tls
 			}
 
-			@general_failure.should == []
+			expect(@general_failure).to eq([])
 			res = @klass.check
-			res[0].should == true
-			res[1].should == true
-			res[2].should == 'hello'
+			expect(res[0]).to eq(true)
+			expect(res[1]).to eq(true)
+			expect(res[2]).to eq('hello')
 		end
 	end
 
@@ -127,11 +153,11 @@ describe UvRays::Connection do
 				@klass.send_datagram('hello', '127.0.0.1', 3210)
 			}
 
-			@general_failure.should == []
+			expect(@general_failure).to eq([])
 			res = @klass.check
-			res[0].should == nil
-			res[1].should == nil
-			res[2].should == nil #'hello' (libuv receive bug?)
+			expect(res[0]).to eq(nil)
+			expect(res[1]).to eq(nil)
+			expect(res[2]).to eq(nil) #'hello' (libuv receive bug?)
 		end
 	end
 end

data/spec/http_endpoint_spec.rb

@@ -40,7 +40,7 @@ module OldServer
 end
 
 
-describe UvRays::HttpEndpoint do
+describe UV::HttpEndpoint do
 	before :each do
 		@loop = Libuv::Loop.new
 		@general_failure = []
@@ -78,12 +78,12 @@ describe UvRays::HttpEndpoint do
 				}, @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
+			expect(@general_failure).to eq([])
+			expect(@response[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response[:headers].http_version).to eq('1.1')
+			expect(@response[:headers].status).to eq(200)
+			expect(@response[:headers].cookies).to eq({})
+			expect(@response[:headers].keep_alive).to eq(true)
 		end
 
 		it "should send multiple requests on the same connection", :network => true do
@@ -113,18 +113,18 @@ describe UvRays::HttpEndpoint do
 				}, @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
+			expect(@general_failure).to eq([])
+			expect(@response[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response[:headers].http_version).to eq('1.1')
+			expect(@response[:headers].status).to eq(200)
+			expect(@response[:headers].cookies).to eq({})
+			expect(@response[:headers].keep_alive).to eq(true)
+
+			expect(@response2[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response2[:headers].http_version).to eq('1.1')
+			expect(@response2[:headers].status).to eq(200)
+			expect(@response2[:headers].cookies).to eq({})
+			expect(@response2[:headers].keep_alive).to eq(true)
 		end
 
 		it "should send pipelined requests on the same connection", :network => true do
@@ -154,18 +154,18 @@ describe UvRays::HttpEndpoint do
 				}, @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
+			expect(@general_failure).to eq([])
+			expect(@response[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response[:headers].http_version).to eq('1.1')
+			expect(@response[:headers].status).to eq(200)
+			expect(@response[:headers].cookies).to eq({})
+			expect(@response[:headers].keep_alive).to eq(true)
+
+			expect(@response2[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response2[:headers].http_version).to eq('1.1')
+			expect(@response2[:headers].status).to eq(200)
+			expect(@response2[:headers].cookies).to eq({})
+			expect(@response2[:headers].keep_alive).to eq(true)
 		end
 	end
 
@@ -191,12 +191,12 @@ describe UvRays::HttpEndpoint do
 				}, @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
+			expect(@general_failure).to eq([])
+			expect(@response[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response[:headers].http_version).to eq('1.0')
+			expect(@response[:headers].status).to eq(200)
+			expect(@response[:headers].cookies).to eq({})
+			expect(@response[:headers].keep_alive).to eq(false)
 		end
 
 		it "should send multiple requests", :network => true do
@@ -226,18 +226,18 @@ describe UvRays::HttpEndpoint do
 				}, @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
+			expect(@general_failure).to eq([])
+			expect(@response[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response[:headers].http_version).to eq('1.0')
+			expect(@response[:headers].status).to eq(200)
+			expect(@response[:headers].cookies).to eq({})
+			expect(@response[:headers].keep_alive).to eq(false)
+
+			expect(@response2[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response2[:headers].http_version).to eq('1.0')
+			expect(@response2[:headers].status).to eq(200)
+			expect(@response2[:headers].cookies).to eq({})
+			expect(@response2[:headers].keep_alive).to eq(false)
 		end
 
 		it "should fail to send pipelined requests", :network => true do
@@ -267,12 +267,12 @@ describe UvRays::HttpEndpoint do
 				}, @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
+			expect(@general_failure).to eq([:disconnected])
+			expect(@response[:headers][:"Content-type"]).to eq('text/html')
+			expect(@response[:headers].http_version).to eq('1.0')
+			expect(@response[:headers].status).to eq(200)
+			expect(@response[:headers].cookies).to eq({})
+			expect(@response[:headers].keep_alive).to eq(false)
 			# Response 2 was the general failure
 		end
 	end