cosmos 3.2.1 → 3.3.0

data/spec/io/raw_logger_pair_spec.rb

@@ -16,58 +16,58 @@ module Cosmos
   describe RawLoggerPair do
 
     describe "initialize" do
-      it "should set the write logger and read logger" do
+      it "sets the write logger and read logger" do
         pair = RawLoggerPair.new('MYINT')
-        pair.read_logger.should_not be_nil
-        pair.write_logger.should_not be_nil
-        pair.read_logger.logging_enabled.should be_falsey
-        pair.write_logger.logging_enabled.should be_falsey
+        expect(pair.read_logger).not_to be_nil
+        expect(pair.write_logger).not_to be_nil
+        expect(pair.read_logger.logging_enabled).to be_falsey
+        expect(pair.write_logger.logging_enabled).to be_falsey
 
         pair = RawLoggerPair.new('MYINT2', ['raw_logger.rb', true, 100000, './'])
-        pair.read_logger.should_not be_nil
-        pair.write_logger.should_not be_nil
-        pair.read_logger.logging_enabled.should be_truthy
-        pair.write_logger.logging_enabled.should be_truthy
+        expect(pair.read_logger).not_to be_nil
+        expect(pair.write_logger).not_to be_nil
+        expect(pair.read_logger.logging_enabled).to be_truthy
+        expect(pair.write_logger.logging_enabled).to be_truthy
       end
     end
 
     describe "start" do
-      it "should start logging" do
+      it "starts logging" do
         pair = RawLoggerPair.new('MYINT')
         pair.start
-        pair.write_logger.logging_enabled.should be_truthy
-        pair.read_logger.logging_enabled.should be_truthy
+        expect(pair.write_logger.logging_enabled).to be_truthy
+        expect(pair.read_logger.logging_enabled).to be_truthy
       end
     end
 
     describe "stop" do
-      it "should stop logging" do
+      it "stops logging" do
         pair = RawLoggerPair.new('MYINT')
         pair.start
-        pair.write_logger.logging_enabled.should be_truthy
-        pair.read_logger.logging_enabled.should be_truthy
+        expect(pair.write_logger.logging_enabled).to be_truthy
+        expect(pair.read_logger.logging_enabled).to be_truthy
         pair.stop
-        pair.write_logger.logging_enabled.should be_falsey
-        pair.read_logger.logging_enabled.should be_falsey
+        expect(pair.write_logger.logging_enabled).to be_falsey
+        expect(pair.read_logger.logging_enabled).to be_falsey
       end
     end
 
     describe "clone" do
-      it "should clone itself including logging state" do
+      it "clones itself including logging state" do
         pair = RawLoggerPair.new('MYINT')
-        pair.write_logger.logging_enabled.should be_falsey
-        pair.read_logger.logging_enabled.should be_falsey
+        expect(pair.write_logger.logging_enabled).to be_falsey
+        expect(pair.read_logger.logging_enabled).to be_falsey
         pair_clone1 = pair.clone
         pair.start
-        pair.write_logger.logging_enabled.should be_truthy
-        pair.read_logger.logging_enabled.should be_truthy
-        pair_clone1.write_logger.logging_enabled.should be_falsey
-        pair_clone1.read_logger.logging_enabled.should be_falsey
+        expect(pair.write_logger.logging_enabled).to be_truthy
+        expect(pair.read_logger.logging_enabled).to be_truthy
+        expect(pair_clone1.write_logger.logging_enabled).to be_falsey
+        expect(pair_clone1.read_logger.logging_enabled).to be_falsey
         pair_clone2 = pair.clone
-        pair_clone1.write_logger.logging_enabled.should be_falsey
-        pair_clone1.read_logger.logging_enabled.should be_falsey
-        pair_clone2.write_logger.logging_enabled.should be_truthy
-        pair_clone2.read_logger.logging_enabled.should be_truthy
+        expect(pair_clone1.write_logger.logging_enabled).to be_falsey
+        expect(pair_clone1.read_logger.logging_enabled).to be_falsey
+        expect(pair_clone2.write_logger.logging_enabled).to be_truthy
+        expect(pair_clone2.read_logger.logging_enabled).to be_truthy
       end
     end
 

data/spec/io/raw_logger_spec.rb

@@ -23,25 +23,25 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should complain with an unknown log type" do
+      it "complains with an unknown log type" do
         expect { RawLogger.new(:BOTH) }.to raise_error
       end
 
-      it "should create a raw write log" do
+      it "creates a raw write log" do
         raw_logger = RawLogger.new('MYINT', :WRITE, true, 100000, nil)
         raw_logger.write("\x00\x01\x02\0x3")
         raw_logger.stop
         expect(Dir[File.join(@log_path,"*.bin")][-1]).to match("myint_raw_write")
       end
 
-      it "should create a raw read log" do
+      it "creates a raw read log" do
         raw_logger = RawLogger.new('MYINT', :READ, true, 100000, nil)
         raw_logger.write("\x00\x01\x02\0x3")
         raw_logger.stop
         expect(Dir[File.join(@log_path,"*.bin")][-1]).to match("myint_raw_read")
       end
 
-      it "should use the log directory" do
+      it "uses the log directory" do
         raw_logger = RawLogger.new('raw_logger_spec_', :READ, true, 100000, Cosmos::USERPATH)
         raw_logger.write("\x00\x01\x02\0x3")
         raw_logger.stop
@@ -53,7 +53,7 @@ module Cosmos
     end
 
     describe "write" do
-      it "should write synchronously to a log" do
+      it "writes synchronously to a log" do
         raw_logger = RawLogger.new('MYINT', :WRITE, true, 100000, nil)
         raw_logger.write("\x00\x01\x02\x03")
         raw_logger.stop
@@ -61,70 +61,70 @@ module Cosmos
         File.open(Dir[File.join(@log_path,"*.bin")][-1],'rb') do |file|
           data = file.read
         end
-        data.should eql "\x00\x01\x02\x03"
+        expect(data).to eql "\x00\x01\x02\x03"
       end
 
-      it "should not write data if logging is disabled" do
+      it "does not write data if logging is disabled" do
         raw_logger = RawLogger.new('MYINT', :WRITE, false, 100000, nil)
         raw_logger.write("\x00\x01\x02\x03")
-        Dir[File.join(@log_path,"*.bin")].should be_empty
+        expect(Dir[File.join(@log_path,"*.bin")]).to be_empty
       end
 
-      it "should cycle the log when it a size" do
+      it "cycles the log when it a size" do
         raw_logger = RawLogger.new('MYINT', :WRITE, true, 200000, nil)
         raw_logger.write("\x00\x01\x02\x03" * 25000) # size 100000
         raw_logger.write("\x00\x01\x02\x03" * 25000) # size 200000
-        Dir[File.join(@log_path,"*.bin")].length.should eql 1
+        expect(Dir[File.join(@log_path,"*.bin")].length).to eql 1
         sleep(2)
         raw_logger.write("\x00") # size 200001
         raw_logger.stop
         files = Dir[File.join(@log_path,"*.bin")]
-        files.length.should eql 2
+        expect(files.length).to eql 2
       end
 
-      it "should handle errors creating the log file" do
+      it "handles errors creating the log file" do
         capture_io do |stdout|
           allow(File).to receive(:new) { raise "Error" }
           raw_logger = RawLogger.new('MYINT', :WRITE, true, 200, nil)
           raw_logger.write("\x00\x01\x02\x03")
           raw_logger.stop
-          stdout.string.should match "Error opening"
+          expect(stdout.string).to match "Error opening"
         end
       end
 
-      it "should handle errors closing the log file" do
+      it "handles errors closing the log file" do
         capture_io do |stdout|
           allow(File).to receive(:chmod) { raise "Error" }
           raw_logger = RawLogger.new('MYINT', :WRITE, true, 200, nil)
           raw_logger.write("\x00\x01\x02\x03")
           raw_logger.stop
-          stdout.string.should match "Error closing"
+          expect(stdout.string).to match "Error closing"
         end
       end
 
-      it "should handle errors writing the log file" do
+      it "handles errors writing the log file" do
         capture_io do |stdout|
           raw_logger = RawLogger.new('MYINT', :WRITE, true, 200, nil)
           raw_logger.write("\x00\x01\x02\x03")
           allow(raw_logger.instance_variable_get(:@file)).to receive(:write) { raise "Error" }
           raw_logger.write("\x00\x01\x02\x03")
           raw_logger.stop
-          stdout.string.should match "Error writing"
+          expect(stdout.string).to match "Error writing"
         end
       end
     end
 
     describe "start and stop" do
-      it "should enable and disable logging" do
+      it "enables and disable logging" do
         raw_logger = RawLogger.new('MYINT', :WRITE, false, 200, nil)
-        raw_logger.logging_enabled.should be_falsey
+        expect(raw_logger.logging_enabled).to be_falsey
         raw_logger.start
-        raw_logger.logging_enabled.should be_truthy
+        expect(raw_logger.logging_enabled).to be_truthy
         raw_logger.write("\x00\x01\x02\x03")
         raw_logger.stop
-        raw_logger.logging_enabled.should be_falsey
+        expect(raw_logger.logging_enabled).to be_falsey
         file = Dir[File.join(@log_path,"*.bin")][-1]
-        File.size(file).should_not eql 0
+        expect(File.size(file)).not_to eql 0
       end
     end
 

data/spec/io/serial_driver_spec.rb

@@ -17,13 +17,13 @@ module Cosmos
   describe SerialDriver do
 
     describe "instance" do
-      it "should enforce the parity to a known value" do
+      it "enforces the parity to a known value" do
         expect { SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
       end
     end
 
     describe "close, closed?, write, read" do
-      it "should defer to the windows serial driver on windows" do
+      it "defers to the windows serial driver on windows" do
         allow(Kernel).to receive(:is_windows?).and_return(true)
         driver = double("Win32SerialDriver")
         expect(driver).to receive(:close)
@@ -38,7 +38,7 @@ module Cosmos
         driver.read
       end
 
-      it "should defer to the posix serial driver on nix" do
+      it "defers to the posix serial driver on nix" do
         class PosixSerialDriver
         end
         allow(Kernel).to receive(:is_windows?).and_return(false)

data/spec/io/stderr_spec.rb

@@ -16,13 +16,13 @@ module Cosmos
   describe Stderr do
 
     describe "instance" do
-      it "should return a single instance" do
+      it "returns a single instance" do
         expect(Stderr.instance).to eq(Stderr.instance)
       end
     end
 
     describe "puts" do
-      it "should write to STDERR" do
+      it "writes to STDERR" do
         expect($stderr).to receive(:puts).with("TEST")
         Stderr.instance.puts("TEST")
       end

data/spec/io/stdout_spec.rb

@@ -16,13 +16,13 @@ module Cosmos
   describe Stdout do
 
     describe "instance" do
-      it "should return a single instance" do
+      it "returns a single instance" do
         expect(Stdout.instance).to eq(Stdout.instance)
       end
     end
 
     describe "puts" do
-      it "should write to STDOUT" do
+      it "writes to STDOUT" do
         expect($stdout).to receive(:puts).with("TEST")
         Stdout.instance.puts("TEST")
       end

data/spec/io/tcpip_server_spec.rb

@@ -16,13 +16,13 @@ module Cosmos
   describe TcpipServer do
 
     describe "instance" do
-      it "should rescue bad stream protocol names" do
+      it "rescues bad stream protocol names" do
         expect { TcpipServer.new(8888,8889,nil,nil,'Unknown') }.to raise_error(/Unable to require/)
       end
     end
 
     describe "connect, connected?, disconnect" do
-      it "should only allow connect once" do
+      it "only allows connect once" do
         server = TcpipServer.new(nil,8889,nil,nil,'Burst')
         server.connect
         sleep 0.2
@@ -31,62 +31,62 @@ module Cosmos
         sleep(0.2)
       end
 
-      it "should create a listener thread for the read port" do
+      it "creates a listener thread for the read port" do
         server = TcpipServer.new(nil,8889,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        server.connected?.should be_truthy
+        expect(server.connected?).to be_truthy
         # 2 because the RSpec main thread plus the listener
-        Thread.list.length.should eql 2
+        expect(Thread.list.length).to eql 2
         server.disconnect
         sleep 0.2
-        server.connected?.should be_falsey
-        Thread.list.length.should eql 1
+        expect(server.connected?).to be_falsey
+        expect(Thread.list.length).to eql 1
       end
 
-      it "should create a listener thread for the write port" do
+      it "creates a listener thread for the write port" do
         server = TcpipServer.new(8888,nil,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        server.connected?.should be_truthy
+        expect(server.connected?).to be_truthy
         # 3 because the RSpec main thread plus the listener
         # plus one for the write thread
-        Thread.list.length.should eql 3
+        expect(Thread.list.length).to eql 3
         server.disconnect
         sleep 0.2
-        server.connected?.should be_falsey
-        Thread.list.length.should eql 1
+        expect(server.connected?).to be_falsey
+        expect(Thread.list.length).to eql 1
       end
 
-      it "should create a single listener thread if read = write port" do
+      it "creates a single listener thread if read = write port" do
         server = TcpipServer.new(8888,8888,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        server.connected?.should be_truthy
+        expect(server.connected?).to be_truthy
         # 3 because the RSpec main thread plus the listener
         # plus one for the write thread
-        Thread.list.length.should eql 3
+        expect(Thread.list.length).to eql 3
         server.disconnect
         sleep 0.2
-        server.connected?.should be_falsey
-        Thread.list.length.should eql 1
+        expect(server.connected?).to be_falsey
+        expect(Thread.list.length).to eql 1
       end
 
-      it "should create a two listener threads if read != write port" do
+      it "creates a two listener threads if read != write port" do
         server = TcpipServer.new(8888,8889,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        server.connected?.should be_truthy
+        expect(server.connected?).to be_truthy
         # 4 because the RSpec main thread plus the two listeners
         # plus one for the write thread
-        Thread.list.length.should eql 4
+        expect(Thread.list.length).to eql 4
         server.disconnect
         sleep 0.2
-        server.connected?.should be_falsey
-        Thread.list.length.should eql 1
+        expect(server.connected?).to be_falsey
+        expect(Thread.list.length).to eql 1
       end
 
-      it "should log an error if the listener thread dies" do
+      it "logs an error if the listener thread dies" do
         capture_io do |stdout|
           system = double("System")
           allow(system).to receive(:use_dns) { raise "Error" }
@@ -101,15 +101,15 @@ module Cosmos
           socket.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server listen thread unexpectedly died/
+          expect(stdout.string).to match /Tcpip server listen thread unexpectedly died/
         end
       end
     end
 
     describe "read" do
-      it "should return nil if there is no read port" do
+      it "returns nil if there is no read port" do
         server = TcpipServer.new(8888,nil,nil,nil,'Burst')
-        server.read.should be_nil
+        expect(server.read).to be_nil
         server.disconnect
         sleep(0.2)
       end
@@ -119,7 +119,7 @@ module Cosmos
         #~ lambda { server.read }.should raise_error
       #~ end
 
-      it "should read from the client" do
+      it "reads from the client" do
         allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
         allow(System).to receive_message_chain(:instance, :acl).and_return(false)
 
@@ -130,17 +130,17 @@ module Cosmos
         socket = TCPSocket.open("127.0.0.1",8889)
         socket.write("\x00\x01")
         sleep 0.2
-        server.num_clients.should eql 1
-        server.read_queue_size.should eql 1
-        server.read.should be_a Packet
+        expect(server.num_clients).to eql 1
+        expect(server.read_queue_size).to eql 1
+        expect(server.read).to be_a Packet
         server.disconnect
         sleep 0.2
-        server.num_clients.should eql 0
+        expect(server.num_clients).to eql 0
         socket.close
         sleep(0.2)
       end
 
-      it "should check the client against the ACL" do
+      it "checks the client against the ACL" do
         capture_io do |stdout|
           allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
           allow(System).to receive_message_chain(:instance, :acl).and_return(true)
@@ -151,18 +151,18 @@ module Cosmos
           sleep 0.2
           socket = TCPSocket.open("127.0.0.1",8889)
           sleep 0.2
-          server.num_clients.should eql 0
-          socket.eof?.should be_truthy
+          expect(server.num_clients).to eql 0
+          expect(socket.eof?).to be_truthy
           server.disconnect
           sleep 0.2
           socket.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server rejected connection/
+          expect(stdout.string).to match /Tcpip server rejected connection/
         end
       end
 
-      it "should log an error if the stream protocol can't disconnect" do
+      it "logs an error if the stream protocol can't disconnect" do
         capture_io do |stdout|
           allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
           allow(System).to receive_message_chain(:instance, :acl).and_return(false)
@@ -176,15 +176,15 @@ module Cosmos
           sleep 0.2
           server.disconnect
           sleep 0.2
-          server.num_clients.should eql 0
+          expect(server.num_clients).to eql 0
           socket.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server read thread unexpectedly died/
+          expect(stdout.string).to match /Tcpip server read thread unexpectedly died/
         end
       end
 
-      it "should log an error if the read thread dies" do
+      it "logs an error if the read thread dies" do
         capture_io do |stdout|
           allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
           allow(System).to receive_message_chain(:instance, :acl).and_return(false)
@@ -200,18 +200,18 @@ module Cosmos
           socket.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server read thread unexpectedly died/
+          expect(stdout.string).to match /Tcpip server read thread unexpectedly died/
         end
       end
     end
 
     describe "write" do
-      it "should do nothing if there is no write port" do
+      it "does nothing if there is no write port" do
         server = TcpipServer.new(nil,8889,nil,nil,'Burst')
         expect { server.write(Packet.new('TGT','PKT')) }.to_not raise_error
       end
 
-      it "should write to the client" do
+      it "writes to the client" do
         allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
         allow(System).to receive_message_chain(:instance, :acl).and_return(false)
 
@@ -221,22 +221,22 @@ module Cosmos
 
         socket = TCPSocket.open("127.0.0.1",8888)
         sleep 0.2
-        server.num_clients.should eql 1
+        expect(server.num_clients).to eql 1
         packet = Packet.new("TGT","PKT")
         packet.buffer = "\x01\x02\x03\x04"
-        server.write_queue_size.should eql 0
+        expect(server.write_queue_size).to eql 0
         server.write(packet)
         sleep 0.2
         data = socket.read_nonblock(packet.length)
-        data.length.should eql 4
+        expect(data.length).to eql 4
         server.disconnect
         sleep 0.2
-        server.num_clients.should eql 0
+        expect(server.num_clients).to eql 0
         socket.close
         sleep(0.2)
       end
 
-      it "should log an error if the write thread dies" do
+      it "logs an error if the write thread dies" do
         class MyTcpipServer3 < TcpipServer
           def write_thread_hook(packet)
             raise "Error"
@@ -251,15 +251,15 @@ module Cosmos
           sleep 0.2
           socket = TCPSocket.open("127.0.0.1",8888)
           sleep 0.2
-          server.num_clients.should eql 1
+          expect(server.num_clients).to eql 1
           server.write(Packet.new("TGT","PKT"))
           sleep 0.2
-          server.num_clients.should eql 0
+          expect(server.num_clients).to eql 0
           server.disconnect
           socket.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server write thread unexpectedly died/
+          expect(stdout.string).to match /Tcpip server write thread unexpectedly died/
         end
       end
 
@@ -272,20 +272,20 @@ module Cosmos
 
           server = TcpipServer.new(8888,8889,nil,nil,'Burst')
           server.connect
-          server.num_clients.should eql 0
+          expect(server.num_clients).to eql 0
           sleep 0.2
           socket = TCPSocket.open("127.0.0.1",8888)
           sleep 0.2
-          server.num_clients.should eql 0
+          expect(server.num_clients).to eql 0
           server.disconnect
           socket.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server lost write connection/
+          expect(stdout.string).to match /Tcpip server lost write connection/
         end
       end
 
-      it "should log an error if the client disconnects" do
+      it "logs an error if the client disconnects" do
         capture_io do |stdout|
           allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
           allow(System).to receive_message_chain(:instance, :acl).and_return(false)
@@ -298,36 +298,36 @@ module Cosmos
           socket1 = TCPSocket.open("127.0.0.1",8888)
           socket2 = TCPSocket.open("127.0.0.1",8889)
           sleep 0.5
-          server.num_clients.should eql 2
+          expect(server.num_clients).to eql 2
           packet = Packet.new("TGT","PKT")
           packet.buffer = "\x01\x02\x03\x04"
-          server.write_queue_size.should eql 0
+          expect(server.write_queue_size).to eql 0
           server.write(packet)
           sleep 0.2
-          server.num_clients.should eql 1
+          expect(server.num_clients).to eql 1
           server.disconnect
           socket1.close
           socket2.close
           sleep(0.2)
 
-          stdout.string.should match /Tcpip server lost write connection/
+          expect(stdout.string).to match /Tcpip server lost write connection/
         end
       end
     end
 
     describe "read_queue_size" do
-      it "should return 0 if there is no read port" do
+      it "returns 0 if there is no read port" do
         server = TcpipServer.new(8888,nil,nil,nil,'Burst')
-        server.read_queue_size.should eql 0
+        expect(server.read_queue_size).to eql 0
         server.disconnect
         sleep(0.2)
       end
     end
 
     describe "write_queue_size" do
-      it "should return 0 if there is no write port" do
+      it "returns 0 if there is no write port" do
         server = TcpipServer.new(nil,8889,nil,nil,'Burst')
-        server.write_queue_size.should eql 0
+        expect(server.write_queue_size).to eql 0
         server.disconnect
         sleep(0.2)
       end