cosmos 3.2.1 → 3.3.0

data/spec/interfaces/linc_interface_spec.rb

@@ -20,7 +20,7 @@ module Cosmos
     end
 
     describe "connect" do
-      it "should pass a new TcpipClientStream to the stream protocol" do
+      it "passes a new TcpipClientStream to the stream protocol" do
         stream = double("stream")
         allow(stream).to receive(:connect)
         expect(TcpipClientStream).to receive(:new) { stream }
@@ -28,9 +28,9 @@ module Cosmos
         expect(stream).to receive(:raw_logger_pair=) { nil }
         i = LincInterface.new('localhost','8888')
         i.target_names << "INST"
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
       end
     end
 
@@ -44,55 +44,55 @@ module Cosmos
         expect(stream).to receive(:raw_logger_pair=) { nil }
         @i = LincInterface.new('localhost','8888','true','2','nil','5','0','16','4','GSE_HDR_GUID','BIG_ENDIAN','GSE_HDR_LEN')
         @i.target_names << "INST"
-        @i.connected?.should be_falsey
+        expect(@i.connected?).to be_falsey
         @i.connect
-        @i.connected?.should be_truthy
+        expect(@i.connected?).to be_truthy
       end
 
-      it "should return an exception if its not connected" do
+      it "returns an exception if its not connected" do
         i = LincInterface.new('localhost','8888')
         expect { i.write(Packet.new("TGT","PKT")) }.to raise_error("Interface not connected")
       end
 
-      it "should add to the ignored list upon an error ignore command" do
+      it "adds to the ignored list upon an error ignore command" do
         cmd = System.commands.packet("INST","COSMOS_ERROR_IGNORE")
         cmd.restore_defaults
         cmd.write("CODE", 0x55)
         @i.write(cmd)
-        @i.instance_variable_get(:@ignored_error_codes).should include(0x55)
+        expect(@i.instance_variable_get(:@ignored_error_codes)).to include(0x55)
       end
 
-      it "should remove from the ignored list upon an error handle command" do
+      it "removes from the ignored list upon an error handle command" do
         @i.instance_variable_get(:@ignored_error_codes) << 0x66
-        @i.instance_variable_get(:@ignored_error_codes).should include(0x66)
+        expect(@i.instance_variable_get(:@ignored_error_codes)).to include(0x66)
         cmd = System.commands.packet("INST","COSMOS_ERROR_HANDLE")
         cmd.restore_defaults
         cmd.write("CODE", 0x66)
         @i.write(cmd)
-        @i.instance_variable_get(:@ignored_error_codes).should_not include(0x66)
+        expect(@i.instance_variable_get(:@ignored_error_codes)).not_to include(0x66)
       end
 
-      it "should enable and disable handshakes upon command" do
+      it "enables and disable handshakes upon command" do
         enable = System.commands.packet("INST","COSMOS_HANDSHAKE_EN")
         enable.restore_defaults
         disable = System.commands.packet("INST","COSMOS_HANDSHAKE_DS")
         disable.restore_defaults
 
         @i.write(enable)
-        @i.instance_variable_get(:@handshake_enabled).should be_truthy
+        expect(@i.instance_variable_get(:@handshake_enabled)).to be_truthy
         @i.write(disable)
-        @i.instance_variable_get(:@handshake_enabled).should be_falsey
+        expect(@i.instance_variable_get(:@handshake_enabled)).to be_falsey
         @i.write(enable)
-        @i.instance_variable_get(:@handshake_enabled).should be_truthy
+        expect(@i.instance_variable_get(:@handshake_enabled)).to be_truthy
       end
 
-      it "should timeout waiting for handshake" do
+      it "timeouts waiting for handshake" do
         cmd = System.commands.packet("INST","LINC_COMMAND")
         cmd.restore_defaults
         expect { @i.write(cmd) }.to raise_error(/Timeout/)
       end
 
-      it "should not timeout if handshakes disabled" do
+      it "does not timeout if handshakes disabled" do
         disable = System.commands.packet("INST","COSMOS_HANDSHAKE_DS")
         disable.restore_defaults
         @i.write(disable)
@@ -125,7 +125,7 @@ module Cosmos
           allow_any_instance_of(LengthStreamProtocol).to receive(:read).and_return(@handshake)
         end
 
-        it "should not timeout if the handshake is received" do
+        it "does not timeout if the handshake is received" do
           t = Thread.new do
             sleep 1
             @i.read
@@ -134,9 +134,9 @@ module Cosmos
           t.join
         end
 
-        it "should warn if an error code is set" do
+        it "warns if an error code is set" do
           expect(Logger).to receive(:warn) do |msg|
-            msg.should eql "Warning sending command (12345): BAD"
+            expect(msg).to eql "Warning sending command (12345): BAD"
           end
           t = Thread.new do
             sleep 1
@@ -146,7 +146,7 @@ module Cosmos
           t.join
         end
 
-        it "should raise an exception if the status is 'ERROR'" do
+        it "raises an exception if the status is 'ERROR'" do
           @handshake.write("STATUS", "ERROR")
           t = Thread.new do
             sleep 1
@@ -168,12 +168,12 @@ module Cosmos
         expect(stream).to receive(:raw_logger_pair=) { nil }
         @i = LincInterface.new('localhost','8888','true','2','nil','5','0','16','4','GSE_HDR_GUID','BIG_ENDIAN','GSE_HDR_LEN')
         @i.target_names << "INST"
-        @i.connected?.should be_falsey
+        expect(@i.connected?).to be_falsey
         @i.connect
-        @i.connected?.should be_truthy
+        expect(@i.connected?).to be_truthy
       end
 
-      it "should handle local commands" do
+      it "handles local commands" do
         @handshake = System.telemetry.packet("INST","HANDSHAKE")
         @handshake.write("GSE_HDR_ID", 1001)
         @handshake.write("ORIGIN", 1)
@@ -181,13 +181,13 @@ module Cosmos
         allow_any_instance_of(LengthStreamProtocol).to receive(:read).and_return(@handshake)
 
         expect(Logger).to receive(:info) do |msg|
-          msg.should match(/External Command/)
+          expect(msg).to match(/External Command/)
         end
 
         @i.read
       end
 
-      it "should handle response overflows" do
+      it "handles response overflows" do
         @handshake = System.telemetry.packet("INST","HANDSHAKE")
         @handshake.write("GSE_HDR_ID", 1001)
         @handshake.write("ORIGIN", 0)

data/spec/interfaces/serial_interface_spec.rb

@@ -16,38 +16,38 @@ module Cosmos
   describe SerialInterface do
 
     describe "initialize" do
-      it "should initialize the instance variables" do
+      it "initializes the instance variables" do
         i = SerialInterface.new('COM1','COM1','9600','NONE','1','0','0','burst')
-        i.name.should eql "Cosmos::SerialInterface"
+        expect(i.name).to eql "Cosmos::SerialInterface"
       end
 
-      it "should not be writeable if no write port given" do
+      it "is not writeable if no write port given" do
         i = SerialInterface.new('nil','COM1','9600','NONE','1','0','0','burst')
-        i.name.should eql "Cosmos::SerialInterface"
-        i.write_allowed?.should be_falsey
-        i.write_raw_allowed?.should be_falsey
-        i.read_allowed?.should be_truthy
+        expect(i.name).to eql "Cosmos::SerialInterface"
+        expect(i.write_allowed?).to be_falsey
+        expect(i.write_raw_allowed?).to be_falsey
+        expect(i.read_allowed?).to be_truthy
       end
 
-      it "should not be readable if no read port given" do
+      it "is not readable if no read port given" do
         i = SerialInterface.new('COM1','nil','9600','NONE','1','0','0','burst')
-        i.name.should eql "Cosmos::SerialInterface"
-        i.write_allowed?.should be_truthy
-        i.write_raw_allowed?.should be_truthy
-        i.read_allowed?.should be_falsey
+        expect(i.name).to eql "Cosmos::SerialInterface"
+        expect(i.write_allowed?).to be_truthy
+        expect(i.write_raw_allowed?).to be_truthy
+        expect(i.read_allowed?).to be_falsey
       end
     end
 
     describe "connect" do
-      it "should pass a new SerialStream to the stream protocol" do
+      it "passes a new SerialStream to the stream protocol" do
         # Ensure the 'NONE' parity is coverted to a symbol
         if Kernel.is_windows?
           i = SerialInterface.new('COM1','COM1','9600','NONE','1','0','0','burst')
-          i.connected?.should be_falsey
+          expect(i.connected?).to be_falsey
           i.connect
-          i.connected?.should be_truthy
+          expect(i.connected?).to be_truthy
           i.disconnect
-          i.connected?.should be_falsey
+          expect(i.connected?).to be_falsey
         end
       end
     end

data/spec/interfaces/simulated_target_interface_spec.rb

@@ -45,17 +45,17 @@ end
     end
 
     describe "initialize" do
-      it "should complain if the simulated target file doesn't exist" do
+      it "complains if the simulated target file doesn't exist" do
         expect { SimulatedTargetInterface.new("doesnt_exist.rb") }.to raise_error(/Unable to require doesnt_exist.rb/)
       end
 
-      it "should create the simulated target class" do
+      it "creates the simulated target class" do
         SimulatedTargetInterface.new("test_inst.rb")
       end
     end
 
     describe "connect" do
-      it "should create the simulated target" do
+      it "creates the simulated target" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
         sti.connect
@@ -63,63 +63,63 @@ end
     end
 
     describe "connected?" do
-      it "should initially be false" do
+      it "initiallies be false" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        sti.connected?.should be_falsey
+        expect(sti.connected?).to be_falsey
         sti.connect
-        sti.connected?.should be_truthy
+        expect(sti.connected?).to be_truthy
       end
     end
 
     describe "read" do
-      it "should complain if disconnected" do
+      it "complains if disconnected" do
         expect { SimulatedTargetInterface.new("test_inst.rb").read }.to raise_error("Interface not connected")
       end
 
-      it "should return a simulated packet" do
+      it "returns a simulated packet" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        sti.connected?.should be_falsey
+        expect(sti.connected?).to be_falsey
         sti.connect
         pkt = sti.read
-        pkt.target_name.should eql "COSMOS"
-        pkt.packet_name.should eql "VERSION"
+        expect(pkt.target_name).to eql "COSMOS"
+        expect(pkt.packet_name).to eql "VERSION"
         pkt = sti.read
-        pkt.target_name.should eql "COSMOS"
-        pkt.packet_name.should eql "VERSION"
+        expect(pkt.target_name).to eql "COSMOS"
+        expect(pkt.packet_name).to eql "VERSION"
       end
     end
 
     describe "write" do
-      it "should complain if disconnected" do
+      it "complains if disconnected" do
         expect { SimulatedTargetInterface.new("test_inst.rb").write(nil) }.to raise_error("Interface not connected")
       end
 
-      it "should write commands to the simulator" do
+      it "writes commands to the simulator" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        sti.connected?.should be_falsey
+        expect(sti.connected?).to be_falsey
         sti.connect
         sti.write(Packet.new("COSMOS","SETLOGLABEL"))
       end
     end
 
     describe "write_raw" do
-      it "should raise an exception" do
+      it "raises an exception" do
         expect { SimulatedTargetInterface.new("test_inst.rb").write_raw("") }.to raise_error(/not implemented/)
       end
     end
 
     describe "disconnect" do
-      it "should disconnect from the simulator" do
+      it "disconnects from the simulator" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        sti.connected?.should be_falsey
+        expect(sti.connected?).to be_falsey
         sti.connect
-        sti.connected?.should be_truthy
+        expect(sti.connected?).to be_truthy
         sti.disconnect
-        sti.connected?.should be_falsey
+        expect(sti.connected?).to be_falsey
       end
     end
 

data/spec/interfaces/stream_interface_spec.rb

@@ -23,27 +23,27 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should complain if the stream protocol doesn't exist" do
+      it "complains if the stream protocol doesn't exist" do
         File.delete(@file) if File.exist?(@file)
         expect { StreamInterface.new("test") }.to raise_error(/Unable to require test_stream_protocol.rb/)
         expect { StreamInterface.new("test") }.to raise_error(/Ensure test_stream_protocol.rb is in the COSMOS lib directory./)
       end
 
-      it "should complain if the stream protocol has a bug" do
+      it "complains if the stream protocol has a bug" do
         File.open(@file, 'w') {|file| file.puts "blah" }
         expect { StreamInterface.new("test") }.to raise_error(/Unable to require test_stream_protocol.rb/)
       end
     end
 
     describe "connect" do
-      it "should raise an exception" do
+      it "raises an exception" do
         si = StreamInterface.new("burst")
         expect { si.connect }.to raise_error("Interface connect method not implemented")
       end
     end
 
     describe "connected?, disconnect, bytes_read, bytes_written" do
-      it "should defer to the stream protocol" do
+      it "defers to the stream protocol" do
         File.open(@file, 'w') do |file|
           file.puts "class TestStreamProtocol"
           file.puts "attr_accessor :bytes_read, :bytes_written"
@@ -56,17 +56,17 @@ module Cosmos
         load @file
 
         si = StreamInterface.new("test")
-        si.connected?.should eql 1
-        si.disconnect.should eql 2
+        expect(si.connected?).to eql 1
+        expect(si.disconnect).to eql 2
         si.bytes_read = 10
-        si.bytes_read.should eql 10
+        expect(si.bytes_read).to eql 10
         si.bytes_written = 20
-        si.bytes_written.should eql 20
+        expect(si.bytes_written).to eql 20
       end
     end
 
     describe "read" do
-      it "should read from the stream interface and count the packet" do
+      it "reads from the stream interface and count the packet" do
         File.open(@file, 'w') do |file|
           file.puts "class TestStreamProtocol"
           file.puts "def interface=(i); i; end"
@@ -77,13 +77,13 @@ module Cosmos
         load @file
 
         si = StreamInterface.new("test")
-        si.read.should eql 1
-        si.read_count.should eql 1
+        expect(si.read).to eql 1
+        expect(si.read_count).to eql 1
       end
     end
 
     describe "write, write_raw" do
-      it "should complain if the stream interface isn't connected" do
+      it "complains if the stream interface isn't connected" do
         File.open(@file, 'w') do |file|
           file.puts "class TestStreamProtocol"
           file.puts "def interface=(i); i; end"
@@ -98,7 +98,7 @@ module Cosmos
         expect { si.write_raw(nil) }.to raise_error(/Interface not connected/)
       end
 
-      it "should disconnect after write errors" do
+      it "disconnects after write errors" do
         $disconnect = false
         File.open(@file, 'w') do |file|
           file.puts "class TestStreamProtocol"
@@ -112,27 +112,27 @@ module Cosmos
         # Ensure we reload since TestStreamProtocol is used throughout
         load @file
 
-        $disconnect.should be_falsey
+        expect($disconnect).to be_falsey
         si = StreamInterface.new("test")
         begin
           si.write(nil)
         rescue
         end
-        si.write_count.should eql 0
-        $disconnect.should be_truthy
+        expect(si.write_count).to eql 0
+        expect($disconnect).to be_truthy
 
         $disconnect = false
-        $disconnect.should be_falsey
+        expect($disconnect).to be_falsey
         si = StreamInterface.new("test")
         begin
           si.write_raw(nil)
         rescue
         end
-        si.write_count.should eql 0
-        $disconnect.should be_truthy
+        expect(si.write_count).to eql 0
+        expect($disconnect).to be_truthy
       end
 
-      it "should write to the stream interface and count the packet" do
+      it "writes to the stream interface and count the packet" do
         File.open(@file, 'w') do |file|
           file.puts "class TestStreamProtocol"
           file.puts "def interface=(i); i; end"
@@ -146,9 +146,9 @@ module Cosmos
 
         si = StreamInterface.new("test")
         si.write(nil)
-        si.write_count.should eql 1
+        expect(si.write_count).to eql 1
         si.write_raw(nil)
-        si.write_count.should eql 2
+        expect(si.write_count).to eql 2
       end
     end
 

data/spec/interfaces/tcpip_client_interface_spec.rb

@@ -16,38 +16,38 @@ module Cosmos
   describe TcpipClientInterface do
 
     describe "initialize" do
-      it "should initialize the instance variables" do
+      it "initializes the instance variables" do
         i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
       end
 
-      it "should not be writeable if no write port given" do
+      it "is not writeable if no write port given" do
         i = TcpipClientInterface.new('localhost','nil','8889','nil','5','burst')
-        i.name.should eql "Cosmos::TcpipClientInterface"
-        i.write_allowed?.should be_falsey
-        i.write_raw_allowed?.should be_falsey
-        i.read_allowed?.should be_truthy
+        expect(i.name).to eql "Cosmos::TcpipClientInterface"
+        expect(i.write_allowed?).to be_falsey
+        expect(i.write_raw_allowed?).to be_falsey
+        expect(i.read_allowed?).to be_truthy
       end
 
-      it "should not be readable if no read port given" do
+      it "is not readable if no read port given" do
         i = TcpipClientInterface.new('localhost','8888','nil','5','nil','burst')
-        i.name.should eql "Cosmos::TcpipClientInterface"
-        i.write_allowed?.should be_truthy
-        i.write_raw_allowed?.should be_truthy
-        i.read_allowed?.should be_falsey
+        expect(i.name).to eql "Cosmos::TcpipClientInterface"
+        expect(i.write_allowed?).to be_truthy
+        expect(i.write_raw_allowed?).to be_truthy
+        expect(i.read_allowed?).to be_falsey
       end
     end
 
     describe "connect" do
-      it "should pass a new TcpipClientStream to the stream protocol" do
+      it "passes a new TcpipClientStream to the stream protocol" do
         stream = double("stream")
         allow(stream).to receive(:connect)
         expect(TcpipClientStream).to receive(:new) { stream }
         expect(stream).to receive(:connected?) { true }
         expect(stream).to receive(:raw_logger_pair=) { nil }
         i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
       end
     end
   end