cosmos 3.2.1 → 3.3.0

data/spec/packets/commands_spec.rb

@@ -18,8 +18,8 @@ module Cosmos
   describe Commands do
 
     describe "initialize" do
-      it "should have no warnings" do
-        Commands.new(PacketConfig.new).warnings.should be_empty
+      it "has no warnings" do
+        expect(Commands.new(PacketConfig.new).warnings).to be_empty
       end
     end
 
@@ -60,307 +60,307 @@ module Cosmos
     end
 
     describe "target_names" do
-      it "should return an array with just UNKNOWN if no targets" do
-        Commands.new(PacketConfig.new).target_names.should eql ["UNKNOWN"]
+      it "returns an empty array if no targets" do
+        expect(Commands.new(PacketConfig.new).target_names).to eql []
       end
 
-      it "should return all target names" do
-        @cmd.target_names.should eql ["TGT1","TGT2","UNKNOWN"]
+      it "returns all target names" do
+        expect(@cmd.target_names).to eql ["TGT1","TGT2"]
       end
     end
 
     describe "packets" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @cmd.packets("tgtX") }.to raise_error(RuntimeError, "Command target 'TGTX' does not exist")
       end
 
-      it "should return all packets target TGT1" do
+      it "returns all packets target TGT1" do
         pkts = @cmd.packets("TGT1")
-        pkts.length.should eql 2
-        pkts.keys.should include("PKT1")
-        pkts.keys.should include("PKT2")
+        expect(pkts.length).to eql 2
+        expect(pkts.keys).to include("PKT1")
+        expect(pkts.keys).to include("PKT2")
       end
 
-      it "should return all packets target TGT2" do
+      it "returns all packets target TGT2" do
         pkts = @cmd.packets("TGT2")
-        pkts.length.should eql 3
-        pkts.keys.should include("PKT3")
-        pkts.keys.should include("PKT4")
-        pkts.keys.should include("PKT5")
+        expect(pkts.length).to eql 3
+        expect(pkts.keys).to include("PKT3")
+        expect(pkts.keys).to include("PKT4")
+        expect(pkts.keys).to include("PKT5")
       end
     end
 
     describe "params" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @cmd.params("TGTX","PKT1") }.to raise_error(RuntimeError, "Command target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @cmd.params("TGT1","PKTX") }.to raise_error(RuntimeError, "Command packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should return all items from packet TGT1/PKT1" do
+      it "returns all items from packet TGT1/PKT1" do
         items = @cmd.params("TGT1","PKT1")
-        items.length.should eql 4
-        items[0].name.should eql "ITEM1"
-        items[1].name.should eql "ITEM2"
-        items[2].name.should eql "ITEM3"
-        items[3].name.should eql "ITEM4"
+        expect(items.length).to eql 4
+        expect(items[0].name).to eql "ITEM1"
+        expect(items[1].name).to eql "ITEM2"
+        expect(items[2].name).to eql "ITEM3"
+        expect(items[3].name).to eql "ITEM4"
       end
     end
 
     describe "packet" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @cmd.packet("tgtX","pkt1") }.to raise_error(RuntimeError, "Command target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @cmd.packet("TGT1","PKTX") }.to raise_error(RuntimeError, "Command packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should return the specified packet" do
+      it "returns the specified packet" do
         pkt = @cmd.packet("TGT1","PKT1")
-        pkt.target_name.should eql "TGT1"
-        pkt.packet_name.should eql "PKT1"
+        expect(pkt.target_name).to eql "TGT1"
+        expect(pkt.packet_name).to eql "PKT1"
       end
     end
 
     describe "identify" do
       it "return nil with a nil buffer" do
-        @cmd.identify(nil).should be_nil
+        expect(@cmd.identify(nil)).to be_nil
       end
 
-      it "should only check the targets given" do
+      it "only checks the targets given" do
         buffer = "\x01\x02\x03\x04"
         pkt = @cmd.identify(buffer,["TGT1"])
         pkt.enable_method_missing
-        pkt.item1.should eql 1
-        pkt.item2.should eql 2
-        pkt.item3.should eql 3
-        pkt.item4.should eql 4
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 3
+        expect(pkt.item4).to eql 4
       end
 
-      it "should return nil with unknown targets given" do
+      it "returns nil with unknown targets given" do
         buffer = "\x01\x02\x03\x04"
-        @cmd.identify(buffer,["TGTX"]).should be_nil
+        expect(@cmd.identify(buffer,["TGTX"])).to be_nil
       end
 
       context "with an unknown buffer" do
-        it "should log an invalid sized buffer" do
+        it "logs an invalid sized buffer" do
           capture_io do |stdout|
             buffer = "\x01\x02\x03"
             pkt = @cmd.identify(buffer)
             pkt.enable_method_missing
-            pkt.item1.should eql 1
-            pkt.item2.should eql 2
-            pkt.item3.should eql 3
-            pkt.item4.should eql 0
-            stdout.string.should match(/ERROR: TGT1 PKT1 received with actual packet length of 3 but defined length of 4/)
+            expect(pkt.item1).to eql 1
+            expect(pkt.item2).to eql 2
+            expect(pkt.item3).to eql 3
+            expect(pkt.item4).to eql 0
+            expect(stdout.string).to match(/ERROR: TGT1 PKT1 received with actual packet length of 3 but defined length of 4/)
           end
         end
 
-        it "should log an invalid sized buffer" do
+        it "logs an invalid sized buffer" do
           capture_io do |stdout|
             buffer = "\x01\x02\x03\x04\x05"
             pkt = @cmd.identify(buffer)
             pkt.enable_method_missing
-            pkt.item1.should eql 1
-            pkt.item2.should eql 2
-            pkt.item3.should eql 3
-            pkt.item4.should eql 4
-            stdout.string.should match(/ERROR: TGT1 PKT1 received with actual packet length of 5 but defined length of 4/)
+            expect(pkt.item1).to eql 1
+            expect(pkt.item2).to eql 2
+            expect(pkt.item3).to eql 3
+            expect(pkt.item4).to eql 4
+            expect(stdout.string).to match(/ERROR: TGT1 PKT1 received with actual packet length of 5 but defined length of 4/)
           end
         end
 
-        it "should identify TGT1 PKT1 but not affect the latest data table" do
+        it "identifies TGT1 PKT1 but not affect the latest data table" do
           buffer = "\x01\x02\x03\x04"
           pkt = @cmd.identify(buffer)
           pkt.enable_method_missing
-          pkt.item1.should eql 1
-          pkt.item2.should eql 2
-          pkt.item3.should eql 3
-          pkt.item4.should eql 4
+          expect(pkt.item1).to eql 1
+          expect(pkt.item2).to eql 2
+          expect(pkt.item3).to eql 3
+          expect(pkt.item4).to eql 4
 
           # Now request the packet from the latest data table
           pkt = @cmd.packet("TGT1","PKT1")
           pkt.enable_method_missing
-          pkt.item1.should eql 0
-          pkt.item2.should eql 0
-          pkt.item3.should eql 0
-          pkt.item4.should eql 0
+          expect(pkt.item1).to eql 0
+          expect(pkt.item2).to eql 0
+          expect(pkt.item3).to eql 0
+          expect(pkt.item4).to eql 0
         end
 
-        it "should identify TGT1 PKT2" do
+        it "identifies TGT1 PKT2" do
           buffer = "\x02\x02"
           pkt = @cmd.identify(buffer)
           pkt.enable_method_missing
-          pkt.item1.should eql 2
-          pkt.item2.should eql "GOOD"
+          expect(pkt.item1).to eql 2
+          expect(pkt.item2).to eql "GOOD"
         end
 
-        it "should identify TGT2 PKT1" do
+        it "identifies TGT2 PKT1" do
           buffer = "\x03\x02"
           pkt = @cmd.identify(buffer)
           pkt.enable_method_missing
-          pkt.item1.should eql 3
-          pkt.item2.should eql 2
+          expect(pkt.item1).to eql 3
+          expect(pkt.item2).to eql 2
         end
       end
     end
 
     describe "build_cmd" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @cmd.build_cmd("tgtX","pkt1") }.to raise_error(RuntimeError, "Command target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @cmd.build_cmd("tgt1","pktX") }.to raise_error(RuntimeError, "Command packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { cmd = @cmd.build_cmd("tgt1","pkt1",{"itemX"=>1}) }.to raise_error(RuntimeError, "Packet item 'TGT1 PKT1 ITEMX' does not exist")
       end
 
-      it "should create a populated command packet with default values" do
+      it "creates a populated command packet with default values" do
         cmd = @cmd.build_cmd("TGT1","PKT1")
         cmd.enable_method_missing
-        cmd.item1.should eql 1
-        cmd.item2.should eql 2
-        cmd.item3.should eql 3
-        cmd.item4.should eql 4
+        expect(cmd.item1).to eql 1
+        expect(cmd.item2).to eql 2
+        expect(cmd.item3).to eql 3
+        expect(cmd.item4).to eql 4
       end
 
-      it "should complain about out of range item values" do
+      it "complains about out of range item values" do
         expect { @cmd.build_cmd("tgt1","pkt1",{"item2"=>1000}) }.to raise_error(RuntimeError, "Command parameter 'TGT1 PKT1 ITEM2' = 1000 not in valid range of 0 to 254")
       end
 
-      it "should ignore out of range item values if requested" do
+      it "ignores out of range item values if requested" do
         cmd = @cmd.build_cmd("tgt1","pkt1",{"item2"=>255}, false)
         cmd.enable_method_missing
-        cmd.item1.should eql 1
-        cmd.item2.should eql 255
-        cmd.item3.should eql 3
-        cmd.item4.should eql 4
+        expect(cmd.item1).to eql 1
+        expect(cmd.item2).to eql 255
+        expect(cmd.item3).to eql 3
+        expect(cmd.item4).to eql 4
       end
 
-      it "should create a command packet with override item values" do
+      it "creates a command packet with override item values" do
         items = {"ITEM2" => 10, "ITEM4" => 11}
         cmd = @cmd.build_cmd("TGT1","PKT1",items)
         cmd.enable_method_missing
-        cmd.item1.should eql 1
-        cmd.item2.should eql 10
-        cmd.item3.should eql 3
-        cmd.item4.should eql 11
+        expect(cmd.item1).to eql 1
+        expect(cmd.item2).to eql 10
+        expect(cmd.item3).to eql 3
+        expect(cmd.item4).to eql 11
       end
 
-      it "should create a command packet with override item value states" do
+      it "creates a command packet with override item value states" do
         items = {"ITEM2" => "GOOD"}
         cmd = @cmd.build_cmd("TGT1","PKT2",items)
         cmd.enable_method_missing
-        cmd.item1.should eql 2
-        cmd.item2.should eql "GOOD"
-        cmd.read("ITEM2",:RAW).should eql 2
+        expect(cmd.item1).to eql 2
+        expect(cmd.item2).to eql "GOOD"
+        expect(cmd.read("ITEM2",:RAW)).to eql 2
       end
 
-      it "should complain about missing required parameters" do
+      it "complains about missing required parameters" do
         expect { @cmd.build_cmd("tgt2","pkt3") }.to raise_error(RuntimeError, "Required command parameter 'TGT2 PKT3 ITEM2' not given")
       end
 
-      it "should support building raw commands" do
+      it "supports building raw commands" do
         items = {"ITEM2" => 10}
         cmd = @cmd.build_cmd("TGT2","PKT5",items,false,false)
-        cmd.raw.should eql false
-        cmd.read("ITEM2").should eql 20
+        expect(cmd.raw).to eql false
+        expect(cmd.read("ITEM2")).to eql 20
         items = {"ITEM2" => 10}
         cmd = @cmd.build_cmd("TGT1","PKT1",items,false,true)
-        cmd.raw.should eql true
-        cmd.read("ITEM2").should eql 10
+        expect(cmd.raw).to eql true
+        expect(cmd.read("ITEM2")).to eql 10
       end
     end
 
     describe "format" do
-      it "should create a string representation of a command" do
+      it "creates a string representation of a command" do
         pkt = @cmd.packet("TGT1","PKT1")
-        @cmd.format(pkt).should eql "cmd('TGT1 PKT1 with ITEM1 0, ITEM2 0, ITEM3 0, ITEM4 0')"
+        expect(@cmd.format(pkt)).to eql "cmd('TGT1 PKT1 with ITEM1 0, ITEM2 0, ITEM3 0, ITEM4 0')"
 
         pkt = @cmd.packet("TGT2","PKT4")
         string = ''
         pkt.write("ITEM2","HELLO WORLD")
-        @cmd.format(pkt).should eql "cmd('TGT2 PKT4 with ITEM1 0, ITEM2 \"HELLO WORLD\"')"
+        expect(@cmd.format(pkt)).to eql "cmd('TGT2 PKT4 with ITEM1 0, ITEM2 \"HELLO WORLD\"')"
 
         pkt = @cmd.packet("TGT2","PKT4")
         string = ''
         pkt.write("ITEM2","HELLO WORLD")
         pkt.raw = true
-        @cmd.format(pkt).should eql "cmd_raw('TGT2 PKT4 with ITEM1 0, ITEM2 \"HELLO WORLD\"')"
+        expect(@cmd.format(pkt)).to eql "cmd_raw('TGT2 PKT4 with ITEM1 0, ITEM2 \"HELLO WORLD\"')"
 
         # If the string is too big it should truncate it
         (1..2028).each {|i| string << 'A' }
         pkt.write("ITEM2",string)
         pkt.raw = false
         result = @cmd.format(pkt)
-        result.should match(/cmd\('TGT2 PKT4 with ITEM1 0, ITEM2 \"AAAAAAAAAAA/)
-        result.should match(/AAAAAAAAAAA.../)
+        expect(result).to match(/cmd\('TGT2 PKT4 with ITEM1 0, ITEM2 \"AAAAAAAAAAA/)
+        expect(result).to match(/AAAAAAAAAAA.../)
       end
 
-      it "should ignore parameters" do
+      it "ignores parameters" do
         pkt = @cmd.packet("TGT1","PKT1")
-        @cmd.format(pkt,['ITEM3','ITEM4']).should eql "cmd('TGT1 PKT1 with ITEM1 0, ITEM2 0')"
+        expect(@cmd.format(pkt,['ITEM3','ITEM4'])).to eql "cmd('TGT1 PKT1 with ITEM1 0, ITEM2 0')"
       end
     end
 
     describe "cmd_hazardous?" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @cmd.cmd_hazardous?("tgtX","pkt1") }.to raise_error(RuntimeError, "Command target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @cmd.cmd_hazardous?("tgt1","pktX") }.to raise_error(RuntimeError, "Command packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { cmd = @cmd.cmd_hazardous?("tgt1","pkt1",{"itemX"=>1}) }.to raise_error(RuntimeError, "Packet item 'TGT1 PKT1 ITEMX' does not exist")
       end
 
-      it "should return true if the command overall is hazardous" do
+      it "returns true if the command overall is hazardous" do
         hazardous, description = @cmd.cmd_hazardous?("TGT1","PKT1")
-        hazardous.should be_falsey
-        description.should be_nil
+        expect(hazardous).to be_falsey
+        expect(description).to be_nil
         hazardous, description = @cmd.cmd_hazardous?("tgt2","pkt3")
-        hazardous.should be_truthy
-        description.should eql "Hazardous"
+        expect(hazardous).to be_truthy
+        expect(description).to eql "Hazardous"
       end
 
-      it "should return true if a command parameter is hazardous" do
+      it "returns true if a command parameter is hazardous" do
         hazardous, description = @cmd.cmd_hazardous?("TGT1","PKT2",{"ITEM2"=>0})
-        hazardous.should be_truthy
-        description.should eql "Hazardous"
+        expect(hazardous).to be_truthy
+        expect(description).to eql "Hazardous"
         hazardous, description = @cmd.cmd_hazardous?("TGT1","PKT2",{"ITEM2"=>1})
-        hazardous.should be_truthy
-        description.should eql ""
+        expect(hazardous).to be_truthy
+        expect(description).to eql ""
         hazardous, description = @cmd.cmd_hazardous?("TGT1","PKT2",{"ITEM2"=>2})
-        hazardous.should be_falsey
-        description.should be_nil
+        expect(hazardous).to be_falsey
+        expect(description).to be_nil
       end
     end
 
     describe "clear_counters" do
-      it "should clear the received counters in all packets" do
+      it "clears the received counters in all packets" do
         @cmd.packet("TGT1","PKT1").received_count = 1
         @cmd.packet("TGT1","PKT2").received_count = 2
         @cmd.packet("TGT2","PKT3").received_count = 3
         @cmd.packet("TGT2","PKT4").received_count = 4
         @cmd.clear_counters
-        @cmd.packet("TGT1","PKT1").received_count.should eql 0
-        @cmd.packet("TGT1","PKT2").received_count.should eql 0
-        @cmd.packet("TGT2","PKT3").received_count.should eql 0
-        @cmd.packet("TGT2","PKT4").received_count.should eql 0
+        expect(@cmd.packet("TGT1","PKT1").received_count).to eql 0
+        expect(@cmd.packet("TGT1","PKT2").received_count).to eql 0
+        expect(@cmd.packet("TGT2","PKT3").received_count).to eql 0
+        expect(@cmd.packet("TGT2","PKT4").received_count).to eql 0
       end
     end
 
     describe "all" do
-      it "should return all packets" do
-        @cmd.all.keys.should eql %w(UNKNOWN TGT1 TGT2)
+      it "returns all packets" do
+        expect(@cmd.all.keys).to eql %w(UNKNOWN TGT1 TGT2)
       end
     end
 

data/spec/packets/limits_response_spec.rb

@@ -17,7 +17,7 @@ module Cosmos
   describe LimitsResponse do
 
     describe "call" do
-      it "should raise an exception" do
+      it "raises an exception" do
         expect { LimitsResponse.new.call(nil,nil,nil) }.to raise_error(/defined by subclass/)
       end
     end

data/spec/packets/limits_spec.rb

@@ -59,53 +59,53 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should have no warnings" do
-        Limits.new(PacketConfig.new).warnings.should be_empty
+      it "has no warnings" do
+        expect(Limits.new(PacketConfig.new).warnings).to be_empty
       end
     end
 
     describe "sets" do
-      it "should return the defined limits set" do
-        @limits.sets.should eql [:DEFAULT, :TVAC]
+      it "returns the defined limits set" do
+        expect(@limits.sets).to eql [:DEFAULT, :TVAC]
       end
     end
 
     describe "groups" do
-      it "should return the limits groups" do
-        @limits.groups.should_not be_empty
+      it "returns the limits groups" do
+        expect(@limits.groups).not_to be_empty
       end
     end
 
     describe "config=" do
-      it "should set the underlying configuration" do
+      it "sets the underlying configuration" do
         tf = Tempfile.new('unittest')
         tf.puts ''
         tf.close
         pc = PacketConfig.new
         pc.process_file(tf.path, "SYSTEM")
-        @limits.sets.should eql [:DEFAULT, :TVAC]
-        @limits.groups.should_not be_empty
+        expect(@limits.sets).to eql [:DEFAULT, :TVAC]
+        expect(@limits.groups).not_to be_empty
         @limits.config = pc
-        @limits.sets.should eql [:DEFAULT]
-        @limits.groups.should eql({})
+        expect(@limits.sets).to eql [:DEFAULT]
+        expect(@limits.groups).to eql({})
         tf.unlink
       end
     end
 
     describe "out_of_limits" do
-      it "should return all out of limits telemetry items" do
+      it "returns all out of limits telemetry items" do
         @tlm.update!("TGT1","PKT1","\x00\x03\x03\x04\x05")
         @tlm.packet("TGT1","PKT1").check_limits
         items = @limits.out_of_limits
-        items[0][0].should eql "TGT1"
-        items[0][1].should eql "PKT1"
-        items[0][2].should eql "ITEM1"
-        items[0][3].should eql :RED_LOW
+        expect(items[0][0]).to eql "TGT1"
+        expect(items[0][1]).to eql "PKT1"
+        expect(items[0][2]).to eql "ITEM1"
+        expect(items[0][3]).to eql :RED_LOW
       end
     end
 
     describe "overall_limits_state" do
-      it "should return overall limits state of the system" do
+      it "returns overall limits state of the system" do
         # Cause packet 2 to be green
         @tlm.update!("TGT1","PKT2","\x03\x03")
         @tlm.packet("TGT1","PKT2").check_limits
@@ -134,7 +134,7 @@ module Cosmos
         expect(@limits.overall_limits_state).to eq :RED
       end
 
-      it "should mark a stale packet green if all items are ignored" do
+      it "marks a stale packet green if all items are ignored" do
         # Cause packet 2 to be green
         @tlm.update!("TGT1","PKT2","\x03\x03")
         @tlm.packet("TGT1","PKT2").check_limits
@@ -145,7 +145,7 @@ module Cosmos
         expect(@limits.overall_limits_state([%w(TGT1 PKT1 ITEM1),%w(TGT1 PKT1 ITEM2),%w(TGT1 PKT1 ITEM3),%w(TGT1 PKT1 ITEM4)])).to eq :GREEN
       end
 
-      it "should handle non-existant ignored telemetry items" do
+      it "handles non-existant ignored telemetry items" do
         # Cause packet 2 to be green
         @tlm.update!("TGT1","PKT2","\x03\x03")
         @tlm.packet("TGT1","PKT2").check_limits
@@ -156,7 +156,7 @@ module Cosmos
         expect(@limits.overall_limits_state([%w(TGT1 PKT1 BLAH)])).to eq :YELLOW
       end
 
-      it "should ignore specified telemetry items" do
+      it "ignores specified telemetry items" do
         # Cause packet 2 to be green
         @tlm.update!("TGT1","PKT2","\x03\x03")
         @tlm.packet("TGT1","PKT2").check_limits
@@ -174,11 +174,11 @@ module Cosmos
     end
 
     describe "enable_group" do
-      it "should complain about undefined limits groups" do
+      it "complains about undefined limits groups" do
         expect { @limits.enable_group("MINE") }.to raise_error(RuntimeError, "LIMITS_GROUP MINE undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP MINE")
       end
 
-      it "should complain about undefined items" do
+      it "complains about undefined items" do
         tf = Tempfile.new('unittest')
         tf.puts 'LIMITS_GROUP GROUP1'
         tf.puts '  LIMITS_GROUP_ITEM TGT1 PKT1 ITEM1'
@@ -190,134 +190,134 @@ module Cosmos
         tf.unlink
       end
 
-      it "should enable limits for all items in the group" do
+      it "enables limits for all items in the group" do
         @limits.enable_group("group1")
         pkt = @tlm.packet("TGT1","PKT1")
-        pkt.get_item("ITEM1").limits.enabled.should be_truthy
-        pkt.get_item("ITEM2").limits.enabled.should be_truthy
-        pkt.get_item("ITEM3").limits.enabled.should be_truthy
-        pkt.get_item("ITEM4").limits.enabled.should be_truthy
-        pkt.get_item("ITEM5").limits.enabled.should be_falsey
+        expect(pkt.get_item("ITEM1").limits.enabled).to be_truthy
+        expect(pkt.get_item("ITEM2").limits.enabled).to be_truthy
+        expect(pkt.get_item("ITEM3").limits.enabled).to be_truthy
+        expect(pkt.get_item("ITEM4").limits.enabled).to be_truthy
+        expect(pkt.get_item("ITEM5").limits.enabled).to be_falsey
       end
     end
 
     describe "disable_group" do
-      it "should complain about undefined limits groups" do
+      it "complains about undefined limits groups" do
         expect { @limits.disable_group("MINE") }.to raise_error(RuntimeError, "LIMITS_GROUP MINE undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP MINE")
       end
 
-      it "should disable limits for all items in the group" do
+      it "disables limits for all items in the group" do
         pkt = @tlm.packet("TGT1","PKT1")
         pkt.enable_limits("ITEM1")
         pkt.enable_limits("ITEM2")
-        pkt.get_item("ITEM1").limits.enabled.should be_truthy
-        pkt.get_item("ITEM2").limits.enabled.should be_truthy
+        expect(pkt.get_item("ITEM1").limits.enabled).to be_truthy
+        expect(pkt.get_item("ITEM2").limits.enabled).to be_truthy
 
         @limits.disable_group("group1")
-        pkt.get_item("ITEM1").limits.enabled.should be_falsey
-        pkt.get_item("ITEM2").limits.enabled.should be_falsey
+        expect(pkt.get_item("ITEM1").limits.enabled).to be_falsey
+        expect(pkt.get_item("ITEM2").limits.enabled).to be_falsey
       end
     end
 
     describe "enabled?" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @limits.enabled?("TGTX","PKT1","ITEM1") }.to raise_error(RuntimeError, "Telemetry target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @limits.enabled?("TGT1","PKTX","ITEM1") }.to raise_error(RuntimeError, "Telemetry packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @limits.enabled?("TGT1","PKT1","ITEMX") }.to raise_error(RuntimeError, "Packet item 'TGT1 PKT1 ITEMX' does not exist")
       end
 
-      it "should return whether limits are enable for an item" do
+      it "returns whether limits are enable for an item" do
         pkt = @tlm.packet("TGT1","PKT1")
-        @limits.enabled?("TGT1","PKT1","ITEM5").should be_falsey
+        expect(@limits.enabled?("TGT1","PKT1","ITEM5")).to be_falsey
         pkt.enable_limits("ITEM5")
-        @limits.enabled?("TGT1","PKT1","ITEM5").should be_truthy
+        expect(@limits.enabled?("TGT1","PKT1","ITEM5")).to be_truthy
       end
     end
 
     describe "enable" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @limits.enable("TGTX","PKT1","ITEM1") }.to raise_error(RuntimeError, "Telemetry target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @limits.enable("TGT1","PKTX","ITEM1") }.to raise_error(RuntimeError, "Telemetry packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @limits.enable("TGT1","PKT1","ITEMX") }.to raise_error(RuntimeError, "Packet item 'TGT1 PKT1 ITEMX' does not exist")
       end
 
-      it "should enable limits for an item" do
+      it "enables limits for an item" do
         pkt = @tlm.packet("TGT1","PKT1")
-        @limits.enabled?("TGT1","PKT1","ITEM5").should be_falsey
+        expect(@limits.enabled?("TGT1","PKT1","ITEM5")).to be_falsey
         @limits.enable("TGT1","PKT1","ITEM5")
-        @limits.enabled?("TGT1","PKT1","ITEM5").should be_truthy
+        expect(@limits.enabled?("TGT1","PKT1","ITEM5")).to be_truthy
       end
     end
 
     describe "disable" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @limits.disable("TGTX","PKT1","ITEM1") }.to raise_error(RuntimeError, "Telemetry target 'TGTX' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @limits.disable("TGT1","PKTX","ITEM1") }.to raise_error(RuntimeError, "Telemetry packet 'TGT1 PKTX' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @limits.disable("TGT1","PKT1","ITEMX") }.to raise_error(RuntimeError, "Packet item 'TGT1 PKT1 ITEMX' does not exist")
       end
 
-      it "should disable limits for an item" do
+      it "disables limits for an item" do
         pkt = @tlm.packet("TGT1","PKT1")
         @limits.enable("TGT1","PKT1","ITEM1")
-        @limits.enabled?("TGT1","PKT1","ITEM1").should be_truthy
+        expect(@limits.enabled?("TGT1","PKT1","ITEM1")).to be_truthy
         @limits.disable("TGT1","PKT1","ITEM1")
-        @limits.enabled?("TGT1","PKT1","ITEM1").should be_falsey
+        expect(@limits.enabled?("TGT1","PKT1","ITEM1")).to be_falsey
       end
     end
 
     describe "get" do
-      it "should get the limits for an item with limits" do
-        @limits.get("TGT1", "PKT1", "ITEM1").should eql [:DEFAULT, 1, true, 1.0, 2.0, 4.0, 5.0, nil, nil]
+      it "gets the limits for an item with limits" do
+        expect(@limits.get("TGT1", "PKT1", "ITEM1")).to eql [:DEFAULT, 1, true, 1.0, 2.0, 4.0, 5.0, nil, nil]
       end
 
-      it "should handle an item without limits" do
-        @limits.get("TGT1", "PKT1", "ITEM5").should eql [nil, nil, nil, nil, nil, nil, nil, nil, nil]
+      it "handles an item without limits" do
+        expect(@limits.get("TGT1", "PKT1", "ITEM5")).to eql [nil, nil, nil, nil, nil, nil, nil, nil, nil]
       end
 
-      it "should support a specified limits set" do
-        @limits.get("TGT1", "PKT1", "ITEM1", :TVAC).should eql [:TVAC, 1, true, 6.0, 7.0, 12.0, 13.0, 9.0, 10.0]
+      it "supports a specified limits set" do
+        expect(@limits.get("TGT1", "PKT1", "ITEM1", :TVAC)).to eql [:TVAC, 1, true, 6.0, 7.0, 12.0, 13.0, 9.0, 10.0]
       end
 
-      it "should handle an item without limits for the given limits set" do
-        @limits.get("TGT1", "PKT2", "ITEM1", :TVAC).should eql [nil, nil, nil, nil, nil, nil, nil, nil, nil]
+      it "handles an item without limits for the given limits set" do
+        expect(@limits.get("TGT1", "PKT2", "ITEM1", :TVAC)).to eql [nil, nil, nil, nil, nil, nil, nil, nil, nil]
       end
     end
 
     describe "set" do
-      it "should set limits for an item" do
-        @limits.set("TGT1", "PKT1", "ITEM5", 1, 2, 3, 4, nil, nil, :DEFAULT).should eql [:DEFAULT, 1, true, 1.0, 2.0, 3.0, 4.0, nil, nil]
+      it "sets limits for an item" do
+        expect(@limits.set("TGT1", "PKT1", "ITEM5", 1, 2, 3, 4, nil, nil, :DEFAULT)).to eql [:DEFAULT, 1, true, 1.0, 2.0, 3.0, 4.0, nil, nil]
       end
 
-      it "should enforce setting DEFAULT limits first" do
+      it "enforces setting DEFAULT limits first" do
         expect { @limits.set("TGT1", "PKT1", "ITEM5", 1, 2, 3, 4) }.to raise_error(RuntimeError, "DEFAULT limits must be defined for TGT1 PKT1 ITEM5 before setting limits set CUSTOM")
-        @limits.set("TGT1", "PKT1", "ITEM5", 5, 6, 7, 8, nil, nil, :DEFAULT).should eql [:DEFAULT, 1, true, 5.0, 6.0, 7.0, 8.0, nil, nil]
-        @limits.set("TGT1", "PKT1", "ITEM5", 1, 2, 3, 4).should eql [:CUSTOM, 1, true, 1.0, 2.0, 3.0, 4.0, nil, nil]
+        expect(@limits.set("TGT1", "PKT1", "ITEM5", 5, 6, 7, 8, nil, nil, :DEFAULT)).to eql [:DEFAULT, 1, true, 5.0, 6.0, 7.0, 8.0, nil, nil]
+        expect(@limits.set("TGT1", "PKT1", "ITEM5", 1, 2, 3, 4)).to eql [:CUSTOM, 1, true, 1.0, 2.0, 3.0, 4.0, nil, nil]
       end
 
-      it "should allow setting other limits sets" do
-        @limits.set("TGT1", "PKT1", "ITEM1", 1, 2, 3, 4, nil, nil, :TVAC).should eql [:TVAC, 1, true, 1.0, 2.0, 3.0, 4.0, nil, nil]
+      it "allows setting other limits sets" do
+        expect(@limits.set("TGT1", "PKT1", "ITEM1", 1, 2, 3, 4, nil, nil, :TVAC)).to eql [:TVAC, 1, true, 1.0, 2.0, 3.0, 4.0, nil, nil]
       end
 
-      it "should handle green limits" do
-        @limits.set("TGT1", "PKT1", "ITEM1", 1, 2, 5, 6, 3, 4, nil).should eql [:DEFAULT, 1, true, 1.0, 2.0, 5.0, 6.0, 3.0, 4.0]
+      it "handles green limits" do
+        expect(@limits.set("TGT1", "PKT1", "ITEM1", 1, 2, 5, 6, 3, 4, nil)).to eql [:DEFAULT, 1, true, 1.0, 2.0, 5.0, 6.0, 3.0, 4.0]
       end
     end