cosmos 3.2.1 → 3.3.0

data/spec/tools/cmd_tlm_server/interface_thread_spec.rb

@@ -52,23 +52,23 @@ module Cosmos
     end
 
     describe "start" do
-      it "should log connection errors" do
+      it "logs connection errors" do
         capture_io do |stdout|
           allow(@interface).to receive(:connected?).and_return(false)
           allow(@interface).to receive(:connect) { raise "ConnectError" }
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "Connection Failed: RuntimeError : ConnectError"
+          expect(stdout.string).to match "Connection Failed: RuntimeError : ConnectError"
         end
       end
 
-      it "should not log connection errors when there is a callback" do
+      it "does not log connection errors when there is a callback" do
         capture_io do |stdout|
           allow(@interface).to receive(:connected?).and_return(false)
           allow(@interface).to receive(:connect) { raise "ConnectError" }
@@ -79,36 +79,36 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           error_count = 0
           thread.connection_failed_callback = Proc.new do |error|
-            error.message.should eql "ConnectError"
+            expect(error.message).to eql "ConnectError"
             error_count += 1
           end
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
-          error_count.should eql 2
+          expect(Thread.list.length).to eql(1)
+          expect(error_count).to eql 2
 
-          stdout.string.should_not match "Connection Failed: ConnectError"
+          expect(stdout.string).not_to match "Connection Failed: ConnectError"
         end
       end
 
-      it "should log the connection" do
+      it "logs the connection" do
         capture_io do |stdout|
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "Connection Success"
+          expect(stdout.string).to match "Connection Success"
         end
       end
 
-      it "should not log the connection when there is a callback" do
+      it "does not log the connection when there is a callback" do
         capture_io do |stdout|
           thread = InterfaceThread.new(@interface)
           callback_called = false
@@ -117,17 +117,17 @@ module Cosmos
           end
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
-          callback_called.should be_truthy
+          expect(Thread.list.length).to eql(1)
+          expect(callback_called).to be_truthy
 
-          stdout.string.should_not match "Connection Success"
+          expect(stdout.string).not_to match "Connection Success"
         end
       end
 
-      it "should log the connection being lost" do
+      it "logs the connection being lost" do
         capture_io do |stdout|
           allow(@interface).to receive(:read).and_return(nil)
           # Make the reconnect_delay be slightly longer than half of 0.1 which is
@@ -137,16 +137,16 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "Connection Lost"
+          expect(stdout.string).to match "Connection Lost"
         end
       end
 
-      it "should not log the connection being lost when there is a callback" do
+      it "does not log the connection being lost when there is a callback" do
         capture_io do |stdout|
           allow(@interface).to receive(:read).and_return(nil)
           @interface.auto_reconnect = false
@@ -159,32 +159,32 @@ module Cosmos
           sleep 1
           # Since we set auto_reconnect to false we shouldn't see the interface
           # thread because it will be killed
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
-          callback_called.should be_truthy
+          expect(Thread.list.length).to eql(1)
+          expect(callback_called).to be_truthy
 
-          stdout.string.should_not match "Connection Lost"
+          expect(stdout.string).not_to match "Connection Lost"
         end
       end
 
-      it "should handle a read exception" do
+      it "handles a read exception" do
         capture_io do |stdout|
           allow(@interface).to receive(:read) { raise "ReadError" }
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "ReadError"
+          expect(stdout.string).to match "ReadError"
         end
       end
 
-      it "should handle a read connection reset" do
+      it "handles a read connection reset" do
         capture_io do |stdout|
           allow(@interface).to receive(:read) { raise Errno::ECONNRESET }
           # Make the reconnect_delay be slightly longer than half of 0.1 which is
@@ -194,16 +194,16 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "ECONNRESET"
+          expect(stdout.string).to match "ECONNRESET"
         end
       end
 
-      it "should log any thread exceptions" do
+      it "logs any thread exceptions" do
         capture_io do |stdout|
           allow(@interface).to receive(:connected?) { raise "ConnectedError" }
           thread = InterfaceThread.new(@interface)
@@ -212,45 +212,45 @@ module Cosmos
           thread.stop
           sleep 0.2
 
-          stdout.string.should match "Packet reading thread unexpectedly died"
+          expect(stdout.string).to match "Packet reading thread unexpectedly died"
         end
       end
 
-      it "should not thread exceptions when there is a callback" do
+      it "does not thread exceptions when there is a callback" do
         capture_io do |stdout|
           allow(@interface).to receive(:connected?) { raise "ConnectedError" }
           thread = InterfaceThread.new(@interface)
           callback_called = false
           thread.fatal_exception_callback = Proc.new do |error|
-            error.message.should eql "ConnectedError"
+            expect(error.message).to eql "ConnectedError"
             callback_called = true
           end
           thread.start
           sleep 0.1
           thread.stop
           sleep 0.2
-          callback_called.should be_truthy
+          expect(callback_called).to be_truthy
 
-          stdout.string.should_not match "Packet reading thread unexpectedly died"
+          expect(stdout.string).not_to match "Packet reading thread unexpectedly died"
         end
       end
 
-      it "should handle unidentified packets" do
+      it "handles unidentified packets" do
         capture_io do |stdout|
           @packet = Packet.new(nil,nil)
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "Unknown 2 byte packet"
+          expect(stdout.string).to match "Unknown 2 byte packet"
         end
       end
 
-      it "should handle identified yet unknown telemetry" do
+      it "handles identified yet unknown telemetry" do
         capture_io do |stdout|
           @packet.target_name = 'BOB'
           @packet.packet_name = 'SMITH'
@@ -258,15 +258,15 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
-          stdout.string.should match "Received unknown identified telemetry: BOB SMITH"
+          expect(Thread.list.length).to eql(1)
+          expect(stdout.string).to match "Received unknown identified telemetry: BOB SMITH"
         end
       end
 
-      it "should write to all defined routers" do
+      it "writes to all defined routers" do
         capture_io do |stdout|
           router = double("Router")
           allow(router).to receive(:write_allowed?).and_return(true)
@@ -277,16 +277,16 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.2
-          Thread.list.length.should eql(1)
+          expect(Thread.list.length).to eql(1)
 
-          stdout.string.should match "Problem writing to router"
+          expect(stdout.string).to match "Problem writing to router"
         end
       end
 
-      it "should write to all defined packet log writers" do
+      it "writes to all defined packet log writers" do
         writer = double("LogWriter")
         allow(writer).to receive_message_chain(:tlm_log_writer,:write)
         @interface.packet_log_writer_pairs = [writer]
@@ -294,10 +294,10 @@ module Cosmos
         threads = Thread.list.length
         thread.start
         sleep 0.1
-        Thread.list.length.should eql(2)
+        expect(Thread.list.length).to eql(2)
         thread.stop
         sleep 0.2
-        Thread.list.length.should eql(1)
+        expect(Thread.list.length).to eql(1)
       end
 
     end

data/spec/tools/cmd_tlm_server/interfaces_spec.rb

@@ -22,7 +22,7 @@ module Cosmos
     end
 
     describe "map_all_targets" do
-      it "should complain about an unknown interface" do
+      it "complains about an unknown interface" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
@@ -31,10 +31,10 @@ module Cosmos
         tf.unlink
       end
 
-      it "should map all targets to the interface" do
+      it "maps all targets to the interface" do
         System.targets.each do |name, target|
           target.interface = nil
-          target.interface.should be_nil
+          expect(target.interface).to be_nil
         end
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
@@ -42,14 +42,14 @@ module Cosmos
         interfaces = Interfaces.new(CmdTlmServerConfig.new(tf.path))
         interfaces.map_all_targets("MY_INT")
         System.targets.each do |name, target|
-          target.interface.name.should eql 'MY_INT'
+          expect(target.interface.name).to eql 'MY_INT'
         end
         tf.unlink
       end
     end
 
     describe "map_target" do
-      it "should complain about an unknown interface" do
+      it "complains about an unknown interface" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
@@ -58,7 +58,7 @@ module Cosmos
         tf.unlink
       end
 
-      it "should complain about an unknown target" do
+      it "complains about an unknown target" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
@@ -68,23 +68,23 @@ module Cosmos
       end
 
 
-      it "should map a target to the interface" do
+      it "maps a target to the interface" do
         System.targets.each do |name, target|
           target.interface = nil
-          target.interface.should be_nil
+          expect(target.interface).to be_nil
         end
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
         interfaces = Interfaces.new(CmdTlmServerConfig.new(tf.path))
         interfaces.map_target("COSMOS","MY_INT")
-        System.targets["COSMOS"].interface.name.should eql "MY_INT"
+        expect(System.targets["COSMOS"].interface.name).to eql "MY_INT"
         tf.unlink
       end
     end
 
     describe "start" do
-      it "should connect each interface" do
+      it "connects each interface" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
@@ -100,7 +100,7 @@ module Cosmos
           interfaces.all['MY_INT'].connect_on_startup = true
           interfaces.start
 
-          stdout.string.should match "Creating thread for interface MY_INT"
+          expect(stdout.string).to match "Creating thread for interface MY_INT"
 
           interfaces.stop
           sleep 0.1
@@ -110,7 +110,7 @@ module Cosmos
     end
 
     describe "stop" do
-      it "should disconnect each interface" do
+      it "disconnects each interface" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
@@ -125,15 +125,15 @@ module Cosmos
           interfaces.all['MY_INT'].connect_on_startup = true
           interfaces.start
           sleep 0.5
-          interfaces.state("MY_INT").should eql "ATTEMPTING"
+          expect(interfaces.state("MY_INT")).to eql "ATTEMPTING"
           sleep 0.1
-          interfaces.state("MY_INT").should eql "CONNECTED"
+          expect(interfaces.state("MY_INT")).to eql "CONNECTED"
           sleep 0.1
           interfaces.stop
           sleep 0.5
-          interfaces.state("MY_INT").should eql "DISCONNECTED"
+          expect(interfaces.state("MY_INT")).to eql "DISCONNECTED"
 
-          stdout.string.should match "Disconnected from interface MY_INT"
+          expect(stdout.string).to match "Disconnected from interface MY_INT"
 
           sleep 0.1
         end
@@ -142,7 +142,7 @@ module Cosmos
     end
 
     describe "connect" do
-      it "should complain about unknown interfaces" do
+      it "complains about unknown interfaces" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
@@ -151,7 +151,7 @@ module Cosmos
         tf.unlink
       end
 
-      it "should connect a interface" do
+      it "connects a interface" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE DEST1 tcpip_client_interface.rb localhost 8888 8888 5 5 burst'
         tf.puts 'INTERFACE DEST2 tcpip_client_interface.rb localhost 8888 8888 5 5 burst'
@@ -183,18 +183,18 @@ module Cosmos
 
           config = CmdTlmServerConfig.new(tf.path)
           interfaces = Interfaces.new(config)
-          config.interfaces['DEST1'].routers[0].name.should eql "MY_ROUTER"
-          config.interfaces['DEST2'].routers[0].name.should eql "MY_ROUTER"
+          expect(config.interfaces['DEST1'].routers[0].name).to eql "MY_ROUTER"
+          expect(config.interfaces['DEST2'].routers[0].name).to eql "MY_ROUTER"
           interfaces.connect("DEST1")
           sleep 0.2
-          stdout.string.should match "Connecting to DEST1"
+          expect(stdout.string).to match "Connecting to DEST1"
           interfaces.disconnect("DEST1")
           interfaces.connect("DEST1",'localhost',8888,8888,6,6,'length')
           sleep 0.2
-          config.interfaces['DEST1'].routers[0].name.should eql "MY_ROUTER"
-          config.interfaces['DEST2'].routers[0].name.should eql "MY_ROUTER"
-          stdout.string.should match "Disconnected from interface DEST1"
-          stdout.string.should match "Connecting to DEST1"
+          expect(config.interfaces['DEST1'].routers[0].name).to eql "MY_ROUTER"
+          expect(config.interfaces['DEST2'].routers[0].name).to eql "MY_ROUTER"
+          expect(stdout.string).to match "Disconnected from interface DEST1"
+          expect(stdout.string).to match "Connecting to DEST1"
           interfaces.disconnect("DEST1")
           interfaces.stop
 
@@ -211,20 +211,20 @@ module Cosmos
     end
 
     describe "names" do
-      it "should list all the interface names" do
+      it "lists all the interface names" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE INTERFACE1 interface.rb'
         tf.puts 'INTERFACE INTERFACE2 interface.rb'
         tf.puts 'INTERFACE INTERFACE3 interface.rb'
         tf.close
         interfaces = Interfaces.new(CmdTlmServerConfig.new(tf.path))
-        interfaces.names.should eql %w(INTERFACE1 INTERFACE2 INTERFACE3)
+        expect(interfaces.names).to eql %w(INTERFACE1 INTERFACE2 INTERFACE3)
         tf.unlink
       end
     end
 
     describe "clear_counters" do
-      it "should clear all interface counters" do
+      it "clears all interface counters" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE INTERFACE1 interface.rb'
         tf.puts 'INTERFACE INTERFACE2 interface.rb'
@@ -239,10 +239,10 @@ module Cosmos
         end
         interfaces.clear_counters
         interfaces.all.each do |name, interface|
-          interface.bytes_written.should eql 0
-          interface.bytes_read.should eql 0
-          interface.write_count.should eql 0
-          interface.read_count.should eql 0
+          expect(interface.bytes_written).to eql 0
+          expect(interface.bytes_read).to eql 0
+          expect(interface.write_count).to eql 0
+          expect(interface.read_count).to eql 0
         end
         tf.unlink
       end