cosmos 3.2.1 → 3.3.0

data/spec/processors/new_packet_log_processor_spec.rb

@@ -16,21 +16,21 @@ module Cosmos
   describe NewPacketLogProcessor do
 
     describe "initialize" do
-      it "should take a packet log writer name" do
+      it "takes a packet log writer name" do
         a = NewPacketLogProcessor.new('MINE')
-        a.value_type.should eql :CONVERTED
+        expect(a.value_type).to eql :CONVERTED
       end
     end
 
     describe "call" do
-      it "should start logging" do
+      it "starts logging" do
         log_name = nil
         allow(CmdTlmServer).to receive_message_chain(:instance,:start_logging) do |name|
           log_name = name
         end
         a = NewPacketLogProcessor.new()
         a.call(nil, nil)
-        log_name.should eql('ALL')
+        expect(log_name).to eql('ALL')
       end
     end
 

data/spec/processors/processor_spec.rb

@@ -16,36 +16,36 @@ module Cosmos
   describe Processor do
 
     describe "initialize" do
-      it "should store an optional value_type" do
+      it "stores an optional value_type" do
         a = Processor.new(:RAW)
-        a.value_type.should eql :RAW
+        expect(a.value_type).to eql :RAW
         b = Processor.new
-        b.value_type.should eql :CONVERTED
+        expect(b.value_type).to eql :CONVERTED
       end
     end
 
     describe "call" do
-      it "should raise an exception" do
+      it "raises an exception" do
         expect { Processor.new.call(0, 0) }.to raise_error("call method must be defined by subclass")
       end
     end
 
     describe "to_s" do
-      it "should return a String" do
-        Processor.new.to_s.should eql "Processor"
+      it "returns a String" do
+        expect(Processor.new.to_s).to eql "Processor"
       end
     end
 
     describe "name" do
-      it "should have an assignable name" do
+      it "has an assignable name" do
         a = Processor.new
         a.name = "Test"
-        a.name.should eql "TEST"
+        expect(a.name).to eql "TEST"
       end
     end
 
     describe "reset" do
-      it "should have a reset method" do
+      it "has a reset method" do
         a = Processor.new
         expect { a.reset }.not_to raise_error
       end

data/spec/processors/statistics_processor_spec.rb

@@ -17,42 +17,42 @@ module Cosmos
   describe StatisticsProcessor do
 
     describe "initialize" do
-      it "should take an item_name, samples_to_average, and value_type" do
+      it "takes an item_name, samples_to_average, and value_type" do
         p = StatisticsProcessor.new('TEST', '5', 'RAW')
-        p.value_type.should eql :RAW
-        p.instance_variable_get("@item_name").should eql 'TEST'
-        p.instance_variable_get("@samples_to_average").should eql 5
+        expect(p.value_type).to eql :RAW
+        expect(p.instance_variable_get("@item_name")).to eql 'TEST'
+        expect(p.instance_variable_get("@samples_to_average")).to eql 5
       end
     end
 
     describe "call and reset" do
-      it "should generate statistics" do
+      it "generates statistics" do
         p = StatisticsProcessor.new('TEST', '5', 'RAW')
         packet = Packet.new("tgt","pkt")
         packet.append_item("TEST", 8, :UINT)
         packet.buffer= "\x01"
         p.call(packet, packet.buffer)
-        p.results[:MAX].should eql 1
-        p.results[:MIN].should eql 1
-        p.results[:MEAN].should be_within(0.001).of(1.0)
-        p.results[:STDDEV].should be_within(0.001).of(0.0)
+        expect(p.results[:MAX]).to eql 1
+        expect(p.results[:MIN]).to eql 1
+        expect(p.results[:MEAN]).to be_within(0.001).of(1.0)
+        expect(p.results[:STDDEV]).to be_within(0.001).of(0.0)
         packet.buffer= "\x02"
         p.call(packet, packet.buffer)
-        p.results[:MAX].should eql 2
-        p.results[:MIN].should eql 1
-        p.results[:MEAN].should be_within(0.001).of(1.5)
-        p.results[:STDDEV].should be_within(0.001).of(0.7071)
+        expect(p.results[:MAX]).to eql 2
+        expect(p.results[:MIN]).to eql 1
+        expect(p.results[:MEAN]).to be_within(0.001).of(1.5)
+        expect(p.results[:STDDEV]).to be_within(0.001).of(0.7071)
         packet.buffer= "\x00"
         p.call(packet, packet.buffer)
-        p.results[:MAX].should eql 2
-        p.results[:MIN].should eql 0
-        p.results[:MEAN].should be_within(0.001).of(1.0)
-        p.results[:STDDEV].should be_within(0.001).of(1.0)
+        expect(p.results[:MAX]).to eql 2
+        expect(p.results[:MIN]).to eql 0
+        expect(p.results[:MEAN]).to be_within(0.001).of(1.0)
+        expect(p.results[:STDDEV]).to be_within(0.001).of(1.0)
         p.reset
-        p.results[:MAX].should eql nil
-        p.results[:MIN].should eql nil
-        p.results[:MEAN].should eql nil
-        p.results[:STDDEV].should eql nil
+        expect(p.results[:MAX]).to eql nil
+        expect(p.results[:MIN]).to eql nil
+        expect(p.results[:MEAN]).to eql nil
+        expect(p.results[:STDDEV]).to eql nil
       end
     end
   end

data/spec/processors/watermark_processor_spec.rb

@@ -17,33 +17,33 @@ module Cosmos
   describe WatermarkProcessor do
 
     describe "initialize" do
-      it "should take an item_name and value_type" do
+      it "takes an item_name and value_type" do
         p = WatermarkProcessor.new('TEST', 'RAW')
-        p.value_type.should eql :RAW
-        p.instance_variable_get("@item_name").should eql 'TEST'
+        expect(p.value_type).to eql :RAW
+        expect(p.instance_variable_get("@item_name")).to eql 'TEST'
       end
     end
 
     describe "call and reset" do
-      it "should generate a high and low water mark" do
+      it "generates a high and low water mark" do
         p = WatermarkProcessor.new('TEST', 'RAW')
         packet = Packet.new("tgt","pkt")
         packet.append_item("TEST", 8, :UINT)
         packet.buffer= "\x01"
         p.call(packet, packet.buffer)
-        p.results[:HIGH_WATER].should eql 1
-        p.results[:LOW_WATER].should eql 1
+        expect(p.results[:HIGH_WATER]).to eql 1
+        expect(p.results[:LOW_WATER]).to eql 1
         packet.buffer= "\x02"
         p.call(packet, packet.buffer)
-        p.results[:HIGH_WATER].should eql 2
-        p.results[:LOW_WATER].should eql 1
+        expect(p.results[:HIGH_WATER]).to eql 2
+        expect(p.results[:LOW_WATER]).to eql 1
         packet.buffer= "\x00"
         p.call(packet, packet.buffer)
-        p.results[:HIGH_WATER].should eql 2
-        p.results[:LOW_WATER].should eql 0
+        expect(p.results[:HIGH_WATER]).to eql 2
+        expect(p.results[:LOW_WATER]).to eql 0
         p.reset
-        p.results[:HIGH_WATER].should eql nil
-        p.results[:LOW_WATER].should eql nil
+        expect(p.results[:HIGH_WATER]).to eql nil
+        expect(p.results[:LOW_WATER]).to eql nil
       end
     end
   end

data/spec/script/script_spec.rb

@@ -53,166 +53,166 @@ module Cosmos
     end
 
     describe "cmd" do
-      it "should send a command" do
+      it "sends a command" do
         capture_io do |stdout|
           cmd("INST ABORT")
-          stdout.string.should match /cmd\(\'INST ABORT\'\)/ #'
+          expect(stdout.string).to match /cmd\(\'INST ABORT\'\)/ #'
         end
       end
 
-      it "should check parameter ranges" do
+      it "checks parameter ranges" do
         expect { cmd("INST COLLECT with TYPE NORMAL, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
       end
 
-      it "should prompt for a hazardous command" do
+      it "prompts for a hazardous command" do
         capture_io do |stdout|
           expect(self).to receive(:gets) { 'y' } # Send hazardous command
           cmd("INST COLLECT with TYPE SPECIAL")
 
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
-          stdout.string.should match /cmd\(\'INST COLLECT/ # '
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match /cmd\(\'INST COLLECT/ # '
           stdout.rewind
 
           expect(self).to receive(:gets) { 'n' } # Don't send hazardous
           expect(self).to receive(:gets) { 'y' } # Stop running script
           cmd("INST COLLECT with TYPE SPECIAL")
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
         end
       end
     end
 
     describe "cmd_no_range_check" do
-      it "should send an out of range command" do
+      it "sends an out of range command" do
         expect { cmd_no_range_check("INST COLLECT with TYPE NORMAL, DURATION 20") }.to_not raise_error
       end
 
-      it "should prompt for a hazardous command" do
+      it "prompts for a hazardous command" do
         capture_io do |stdout|
           expect(self).to receive(:gets) { 'y' } # Send hazardous command
           cmd_no_range_check("INST COLLECT with TYPE SPECIAL")
 
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
-          stdout.string.should match /cmd\(\'INST COLLECT/ # '
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match /cmd\(\'INST COLLECT/ # '
           stdout.rewind
 
           expect(self).to receive(:gets) { 'n' } # Don't send hazardous
           expect(self).to receive(:gets) { 'y' } # Stop running script
           cmd_no_range_check("INST COLLECT with TYPE SPECIAL")
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
         end
       end
     end
 
     describe "cmd_no_hazardous_check" do
-      it "should check parameter ranges" do
+      it "checks parameter ranges" do
         expect { cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
       end
 
-      it "should send a hazardous command without prompting" do
+      it "sends a hazardous command without prompting" do
         capture_io do |stdout|
           cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL")
 
-          stdout.string.should match "Command INST COLLECT being sent ignoring hazardous warnings"
-          stdout.string.should match /cmd\(\'INST COLLECT/ # '
+          expect(stdout.string).to match "Command INST COLLECT being sent ignoring hazardous warnings"
+          expect(stdout.string).to match /cmd\(\'INST COLLECT/ # '
         end
       end
     end
 
     describe "cmd_no_checks" do
-      it "should send an out of range hazardous command without prompting" do
+      it "sends an out of range hazardous command without prompting" do
         capture_io do |stdout|
           cmd_no_checks("INST COLLECT with TYPE SPECIAL, DURATION 20")
 
-          stdout.string.should match "Command INST COLLECT being sent ignoring hazardous warnings"
-          stdout.string.should match /cmd\(\'INST COLLECT/ # '
+          expect(stdout.string).to match "Command INST COLLECT being sent ignoring hazardous warnings"
+          expect(stdout.string).to match /cmd\(\'INST COLLECT/ # '
         end
       end
     end
 
     describe "cmd_raw" do
-      it "should send a command" do
+      it "sends a command" do
         capture_io do |stdout|
           cmd_raw("INST ABORT")
-          stdout.string.should match /cmd_raw\(\'INST ABORT\'\)/ # '
+          expect(stdout.string).to match /cmd_raw\(\'INST ABORT\'\)/ # '
         end
       end
 
-      it "should check parameter ranges" do
+      it "checks parameter ranges" do
         expect { cmd_raw("INST COLLECT with TYPE 0, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/) # '
       end
 
-      it "should prompt for a hazardous command" do
+      it "prompts for a hazardous command" do
         capture_io do |stdout|
           expect(self).to receive(:gets) { 'y' } # Send hazardous command
           cmd_raw("INST COLLECT with TYPE 1")
 
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
-          stdout.string.should match /cmd_raw\(\'INST COLLECT/ # '
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match /cmd_raw\(\'INST COLLECT/ # '
           stdout.rewind
 
           expect(self).to receive(:gets) { 'n' } # Don't send hazardous
           expect(self).to receive(:gets) { 'y' } # Stop running script
           cmd_raw("INST COLLECT with TYPE 1")
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
         end
       end
     end
 
     describe "cmd_raw_no_range_check" do
-      it "should send an out of range command" do
+      it "sends an out of range command" do
         expect { cmd_raw_no_range_check("INST COLLECT with TYPE 0, DURATION 20") }.to_not raise_error
       end
 
-      it "should prompt for a hazardous command" do
+      it "prompts for a hazardous command" do
         capture_io do |stdout|
           expect(self).to receive(:gets) { 'y' } # Send hazardous command
           cmd_raw_no_range_check("INST COLLECT with TYPE 1")
 
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
-          stdout.string.should match /cmd_raw\(\'INST COLLECT/ # '
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match /cmd_raw\(\'INST COLLECT/ # '
           stdout.rewind
 
           expect(self).to receive(:gets) { 'n' } # Don't send hazardous
           expect(self).to receive(:gets) { 'y' } # Stop running script
           cmd_raw_no_range_check("INST COLLECT with TYPE 1")
-          stdout.string.should match "Warning: Command INST COLLECT is Hazardous"
+          expect(stdout.string).to match "Warning: Command INST COLLECT is Hazardous"
         end
       end
     end
 
     describe "cmd_raw_no_hazardous_check" do
-      it "should check parameter ranges" do
+      it "checks parameter ranges" do
         expect { cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
       end
 
-      it "should send a hazardous command without prompting" do
+      it "sends a hazardous command without prompting" do
         capture_io do |stdout|
           cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1")
-          stdout.string.should match "Command INST COLLECT being sent ignoring hazardous warnings"
-          stdout.string.should match /cmd_raw\(\'INST COLLECT/ #'
+          expect(stdout.string).to match "Command INST COLLECT being sent ignoring hazardous warnings"
+          expect(stdout.string).to match /cmd_raw\(\'INST COLLECT/ #'
         end
       end
     end
 
     describe "cmd_raw_no_checks" do
-      it "should send an out of range hazardous command without prompting" do
+      it "sends an out of range hazardous command without prompting" do
         capture_io do |stdout|
           cmd_raw_no_checks("INST COLLECT with TYPE 1, DURATION 20")
-          stdout.string.should match "Command INST COLLECT being sent ignoring hazardous warnings"
-          stdout.string.should match /cmd_raw\(\'INST COLLECT/ #'
+          expect(stdout.string).to match "Command INST COLLECT being sent ignoring hazardous warnings"
+          expect(stdout.string).to match /cmd_raw\(\'INST COLLECT/ #'
         end
       end
     end
 
     describe "send_raw" do
-      it "should send data to the write_raw interface method" do
+      it "sends data to the write_raw interface method" do
         expect_any_instance_of(Interface).to receive(:write_raw).with('\x00')
         send_raw('INST_INT', '\x00')
       end
     end
 
     describe "send_raw_file" do
-      it "should send file data to the write_raw interface method" do
+      it "sends file data to the write_raw interface method" do
         file = File.open('raw_test_file.bin','wb')
         file.write '\x00\x01\x02\x03'
         file.close
@@ -226,36 +226,36 @@ module Cosmos
     end
 
     describe "get_cmd_list" do
-      it "should return all the target commands" do
+      it "returns all the target commands" do
         list = get_cmd_list("INST")
         # Only check for the collect command to make this test list dependent
         # on the demo INST command definition file
-        list.should include(["COLLECT", "Starts a collect on the instrument"])
+        expect(list).to include(["COLLECT", "Starts a collect on the instrument"])
       end
     end
 
     describe "get_cmd_param_list" do
-      it "should return all the parameters for a command" do
+      it "returns all the parameters for a command" do
         list = get_cmd_param_list("INST", "COLLECT")
-        list.should include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true])
+        expect(list).to include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true])
       end
     end
 
     describe "get_cmd_hazardous" do
-      it "should return whether a command is hazardous" do
-        get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"NORMAL"}).should be_falsey
-        get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"SPECIAL"}).should be_truthy
+      it "returns whether a command is hazardous" do
+        expect(get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"NORMAL"})).to be_falsey
+        expect(get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"SPECIAL"})).to be_truthy
       end
     end
 
     describe "tlm, tlm_raw, tlm_formatted, tlm_with_units, tlm_variable, set_tlm, set_tlm_raw" do
-      it "should pass through to the cmd_tlm_server" do
+      it "passes through to the cmd_tlm_server" do
         expect {
-          tlm("INST HEALTH_STATUS TEMP1").should eql -100.0
-          tlm_raw("INST HEALTH_STATUS TEMP1").should eql 0
-          tlm_formatted("INST HEALTH_STATUS TEMP1").should eql "-100.000"
-          tlm_with_units("INST HEALTH_STATUS TEMP1").should eql "-100.000 C"
-          tlm_variable("INST HEALTH_STATUS TEMP1", :RAW).should eql 0
+          expect(tlm("INST HEALTH_STATUS TEMP1")).to eql -100.0
+          expect(tlm_raw("INST HEALTH_STATUS TEMP1")).to eql 0
+          expect(tlm_formatted("INST HEALTH_STATUS TEMP1")).to eql "-100.000"
+          expect(tlm_with_units("INST HEALTH_STATUS TEMP1")).to eql "-100.000 C"
+          expect(tlm_variable("INST HEALTH_STATUS TEMP1", :RAW)).to eql 0
           set_tlm("INST HEALTH_STATUS TEMP1 = 1")
           set_tlm_raw("INST HEALTH_STATUS TEMP1 = 0")
         }.to_not raise_error
@@ -263,53 +263,53 @@ module Cosmos
     end
 
     describe "get_tlm_packet" do
-      it "should get the packet values" do
-        get_tlm_packet("INST", "HEALTH_STATUS", :RAW).should include(["TEMP1", 0, :RED_LOW])
+      it "gets the packet values" do
+        expect(get_tlm_packet("INST", "HEALTH_STATUS", :RAW)).to include(["TEMP1", 0, :RED_LOW])
       end
     end
 
     describe "get_tlm_values" do
-      it "should get the given values" do
+      it "gets the given values" do
         vals = get_tlm_values([["INST", "HEALTH_STATUS", "TEMP1"], ["INST", "HEALTH_STATUS", "TEMP2"]])
-        vals[0][0].should eql -100.0
-        vals[1][0].should eql :RED_LOW
-        vals[2][0].should eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
-        vals[3].should eql :DEFAULT
+        expect(vals[0][0]).to eql -100.0
+        expect(vals[1][0]).to eql :RED_LOW
+        expect(vals[2][0]).to eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
+        expect(vals[3]).to eql :DEFAULT
       end
     end
 
     describe "get_tlm_list" do
-      it "should get packets for a given target" do
-        get_tlm_list("INST").should include(["HEALTH_STATUS", "Health and status from the instrument"])
+      it "gets packets for a given target" do
+        expect(get_tlm_list("INST")).to include(["HEALTH_STATUS", "Health and status from the instrument"])
       end
     end
 
     describe "get_tlm_item_list" do
-      it "should get telemetry for a given packet" do
-        get_tlm_item_list("INST", "HEALTH_STATUS").should include(["TEMP1",nil,"Temperature #1"])
+      it "gets telemetry for a given packet" do
+        expect(get_tlm_item_list("INST", "HEALTH_STATUS")).to include(["TEMP1",nil,"Temperature #1"])
       end
     end
 
     describe "get_tlm_details" do
-      it "should get telemetry for a given packet" do
+      it "gets telemetry for a given packet" do
         details = get_tlm_details([["INST", "HEALTH_STATUS", "TEMP1"], ["INST", "HEALTH_STATUS", "TEMP2"]])
-        details[0]["name"].should eql "TEMP1"
-        details[1]["name"].should eql "TEMP2"
+        expect(details[0]["name"]).to eql "TEMP1"
+        expect(details[1]["name"]).to eql "TEMP2"
       end
     end
 
     describe "get_out_of_limits" do
-      it "should get all out of limits items" do
-        get_out_of_limits.should include(["INST","HEALTH_STATUS","TEMP1",:RED_LOW])
+      it "gets all out of limits items" do
+        expect(get_out_of_limits).to include(["INST","HEALTH_STATUS","TEMP1",:RED_LOW])
       end
     end
 
     describe "get_overall_limits_state" do
-      it "should get the overall limits state of the system" do
-        get_overall_limits_state.should eql :RED
+      it "gets the overall limits state of the system" do
+        expect(get_overall_limits_state).to eql :RED
       end
 
-      it "should ignore specified items" do
+      it "ignores specified items" do
         ignore = []
         ignore << %w(INST HEALTH_STATUS TEMP1)
         ignore << %w(INST HEALTH_STATUS TEMP2)
@@ -317,106 +317,106 @@ module Cosmos
         ignore << %w(INST HEALTH_STATUS TEMP4)
         ignore << %w(INST HEALTH_STATUS GROUND1STATUS)
         ignore << %w(INST HEALTH_STATUS GROUND2STATUS)
-        get_overall_limits_state(ignore).should eql :STALE
+        expect(get_overall_limits_state(ignore)).to eql :STALE
       end
     end
 
     describe "limits_enabled?, disable_limits, enable_limits" do
-      it "should enable, disable, and check limits for an item" do
-        limits_enabled?("INST HEALTH_STATUS TEMP1").should be_truthy
+      it "enables, disable, and check limits for an item" do
+        expect(limits_enabled?("INST HEALTH_STATUS TEMP1")).to be_truthy
         disable_limits("INST HEALTH_STATUS TEMP1")
-        limits_enabled?("INST HEALTH_STATUS TEMP1").should be_falsey
+        expect(limits_enabled?("INST HEALTH_STATUS TEMP1")).to be_falsey
         enable_limits("INST HEALTH_STATUS TEMP1")
-        limits_enabled?("INST HEALTH_STATUS TEMP1").should be_truthy
+        expect(limits_enabled?("INST HEALTH_STATUS TEMP1")).to be_truthy
       end
     end
 
     describe "get_limits, set_limits" do
-      it "should get and set limits for an item" do
-        get_limits("INST", "HEALTH_STATUS", "TEMP1").should eql [:DEFAULT, 1, true, -80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
-        set_limits("INST", "HEALTH_STATUS", "TEMP1", 1, 2, 5, 6, 3, 4).should eql [:CUSTOM, 1, true, 1.0, 2.0, 5.0, 6.0, 3.0, 4.0]
+      it "gets and set limits for an item" do
+        expect(get_limits("INST", "HEALTH_STATUS", "TEMP1")).to eql [:DEFAULT, 1, true, -80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
+        expect(set_limits("INST", "HEALTH_STATUS", "TEMP1", 1, 2, 5, 6, 3, 4)).to eql [:CUSTOM, 1, true, 1.0, 2.0, 5.0, 6.0, 3.0, 4.0]
       end
     end
 
     describe "get_limits_groups, enable_limits_group, disable_limits_group" do
-      it "should enable, disable, and get groups" do
-        get_limits_groups.should include("FIRST")
+      it "enables, disable, and get groups" do
+        expect(get_limits_groups).to include("FIRST")
         enable_limits_group("FIRST")
         disable_limits_group("FIRST")
       end
     end
 
     describe "get_limits_sets, enable_limits_set, disable_limits_set" do
-      it "should enable, disable, and get sets CTS-16" do
+      it "enables, disable, and get sets CTS-16" do
         if get_limits_sets.include?(:CUSTOM)
-          get_limits_sets.should eql [:DEFAULT,:TVAC,:CUSTOM]
+          expect(get_limits_sets).to eql [:DEFAULT,:TVAC,:CUSTOM]
         else
-          get_limits_sets.should eql [:DEFAULT,:TVAC]
+          expect(get_limits_sets).to eql [:DEFAULT,:TVAC]
         end
         set_limits_set(:TVAC)
-        get_limits_set.should eql :TVAC
+        expect(get_limits_set).to eql :TVAC
         set_limits_set(:DEFAULT)
-        get_limits_set.should eql :DEFAULT
+        expect(get_limits_set).to eql :DEFAULT
       end
     end
 
     describe "get_target_list" do
-      it "should return the list of targets" do
-        get_target_list.should include("INST")
+      it "returns the list of targets" do
+        expect(get_target_list).to include("INST")
       end
     end
 
     describe "subscribe_limits_events, get_limits_event, unsubscribe_limits_events" do
-      it "should raise an error if non_block and the queue is empty" do
+      it "raises an error if non_block and the queue is empty" do
         id = subscribe_limits_events
         expect { get_limits_event(id, true) }.to raise_error(ThreadError, "queue empty")
         unsubscribe_limits_events(id)
       end
 
-      it "should subscribe and get limits change events" do
+      it "subscribes and get limits change events" do
         id = subscribe_limits_events
         CmdTlmServer.instance.post_limits_event(:LIMITS_CHANGE, ['TGT','PKT','ITEM',:YELLOW,:RED])
         result = get_limits_event(id, true)
-        result[0].should eql :LIMITS_CHANGE
+        expect(result[0]).to eql :LIMITS_CHANGE
         unsubscribe_limits_events(id)
       end
 
-      it "should subscribe and get limits settings events" do
+      it "subscribes and get limits settings events" do
         id = subscribe_limits_events
         CmdTlmServer.instance.post_limits_event(:LIMITS_SETTINGS, ['TGT','PKT','ITEM',:DEFAULT])
         result = get_limits_event(id, true)
-        result[0].should eql :LIMITS_SETTINGS
+        expect(result[0]).to eql :LIMITS_SETTINGS
         unsubscribe_limits_events(id)
       end
 
-      it "should handle unknown limits events" do
+      it "handles unknown limits events" do
         id = subscribe_limits_events
         CmdTlmServer.instance.post_limits_event(:UNKNOWN, "This is a test")
         result = get_limits_event(id, true)
-        result[0].should eql :UNKNOWN
+        expect(result[0]).to eql :UNKNOWN
         unsubscribe_limits_events(id)
       end
     end
 
     describe "subscribe_packet_data, get_packet, unsubscribe_packet_data" do
-      it "should raise an error if non_block and the queue is empty" do
+      it "raises an error if non_block and the queue is empty" do
         id = subscribe_packet_data([["INST","HEALTH_STATUS"]])
         expect { get_packet(id, true) }.to raise_error(ThreadError, "queue empty")
         unsubscribe_packet_data(id)
       end
 
-      it "should subscribe and get limits events" do
+      it "subscribes and get limits events" do
         id = subscribe_packet_data([["INST","HEALTH_STATUS"]])
         CmdTlmServer.instance.post_packet(System.telemetry.packet("INST","HEALTH_STATUS"))
         packet = get_packet(id, true)
-        packet.target_name.should eql "INST"
-        packet.packet_name.should eql "HEALTH_STATUS"
+        expect(packet.target_name).to eql "INST"
+        expect(packet.packet_name).to eql "HEALTH_STATUS"
         unsubscribe_packet_data(id)
       end
     end
 
     describe "play_wav_file" do
-      it "should play a wav file if Qt is available" do
+      it "plays a wav file if Qt is available" do
         module Qt
           def self.execute_in_main_thread(bool); yield; end
           class CoreApplication; def self.instance; true; end; end;
@@ -428,7 +428,7 @@ module Cosmos
     end
 
     describe "status_bar" do
-      it "should set the ScriptRunner status bar" do
+      it "sets the ScriptRunner status bar" do
         class ScriptRunner; end
         sc = ScriptRunner.new
         expect(sc).to receive(:script_set_status).with("HI")
@@ -437,56 +437,56 @@ module Cosmos
     end
 
     describe "ask_string, ask" do
-      it "should get user input" do
+      it "gets user input" do
         $stdout = StringIO.new
         expect(self).to receive(:gets) { '10' }
-        ask_string("").should eql '10'
+        expect(ask_string("")).to eql '10'
         expect(self).to receive(:gets) { '10' }
-        ask("").should eql 10
+        expect(ask("")).to eql 10
         $stdout = STDOUT
       end
     end
 
     describe "prompt, prompt_message_box" do
-      it "should prompt the user for input" do
+      it "prompts the user for input" do
         $stdout = StringIO.new
         expect(self).to receive(:gets) { 'message' }
-        prompt("").should eql 'message'
+        expect(prompt("")).to eql 'message'
         expect(self).to receive(:gets) { 'b1' }
-        message_box("",["b1","b2"]).should eql 'b1'
+        expect(message_box("",["b1","b2"])).to eql 'b1'
         $stdout = STDOUT
       end
     end
 
     describe "check, check_formatted, check_with_units, check_raw" do
-      it "should check a telemetry item vs a condition" do
+      it "checks a telemetry item vs a condition" do
         capture_io do |stdout|
           check("INST HEALTH_STATUS TEMP1 == -100")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == -100 success"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == -100 success"
           stdout.rewind
 
           check("INST","HEALTH_STATUS","TEMP1","== -100")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == -100 success"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == -100 success"
           stdout.rewind
 
           check_formatted("INST HEALTH_STATUS TEMP1 == '-100.000'")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000' success"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000' success"
           stdout.rewind
 
           check_formatted("INST","HEALTH_STATUS","TEMP1","== '-100.000'")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000' success"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000' success"
           stdout.rewind
 
           check_with_units("INST HEALTH_STATUS TEMP1 == '-100.000 C'")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000 C' success"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000 C' success"
           stdout.rewind
 
           check_with_units("INST","HEALTH_STATUS","TEMP1","== '-100.000 C'")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000 C' success"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == '-100.000 C' success"
           stdout.rewind
 
           check_raw("INST HEALTH_STATUS TEMP1")
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == 0"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == 0"
         end
 
         check("INST HEALTH_STATUS TEMP1 < 0")
@@ -495,17 +495,17 @@ module Cosmos
     end
 
     describe "check_tolerance, check_tolerance_raw" do
-      it "should check a telemetry item vs tolerance" do
+      it "checks a telemetry item vs tolerance" do
         capture_io do |stdout|
           check_tolerance("INST HEALTH_STATUS TEMP1", -100.0, 1)
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 was within range"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 was within range"
           stdout.rewind
 
           expect { check_tolerance("INST HEALTH_STATUS TEMP1", -200.0, 1) }.to raise_error(CheckError, /CHECK: INST HEALTH_STATUS TEMP1 failed to be within range/)
           stdout.rewind
 
           check_tolerance_raw("INST HEALTH_STATUS TEMP1", 0, 1)
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 was within range"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 was within range"
           stdout.rewind
 
           expect { check_tolerance_raw("INST HEALTH_STATUS TEMP1", 100, 1) }.to raise_error(CheckError, /CHECK: INST HEALTH_STATUS TEMP1 failed to be within range/)
@@ -515,10 +515,10 @@ module Cosmos
     end
 
     describe "check_expression" do
-      it "should check an arbitrary expression" do
+      it "checks an arbitrary expression" do
         capture_io do |stdout|
           check_expression("true == true")
-          stdout.string.should match "CHECK: true == true is TRUE"
+          expect(stdout.string).to match "CHECK: true == true is TRUE"
       end
 
         expect { check_expression("true == false") }.to raise_error(CheckError, "CHECK: true == false is FALSE")
@@ -526,70 +526,70 @@ module Cosmos
     end
 
     describe "wait, wait_raw, wait_tolerance, wait_tolerance_raw" do
-      it "should wait for telemetry check to be true" do
+      it "waits for telemetry check to be true" do
         capture_io do |stdout|
           # Success
           wait("INST HEALTH_STATUS TEMP1 == -100.0", 5)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 == -100.0"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 == -100.0"
           stdout.rewind
           wait_raw("INST HEALTH_STATUS TEMP1 == 0", 5)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 == 0"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 == 0"
           stdout.rewind
           wait_tolerance("INST HEALTH_STATUS TEMP1", -100.0, 1, 5)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 was within"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 was within"
           stdout.rewind
           wait_tolerance_raw("INST HEALTH_STATUS TEMP1", 0, 1, 5)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 was within"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 was within"
           stdout.rewind
 
           # Failure
           wait("INST HEALTH_STATUS TEMP1 == -200.0", 0.1)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 == -200.0 failed"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 == -200.0 failed"
           stdout.rewind
           wait_raw("INST HEALTH_STATUS TEMP1 == 100", 0.1)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 == 100 failed"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 == 100 failed"
           stdout.rewind
           wait_tolerance("INST HEALTH_STATUS TEMP1", -200.0, 1, 0.1)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 failed to be within"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 failed to be within"
           stdout.rewind
           wait_tolerance_raw("INST HEALTH_STATUS TEMP1", 100, 1, 0.1)
-          stdout.string.should match "WAIT: INST HEALTH_STATUS TEMP1 failed to be within"
+          expect(stdout.string).to match "WAIT: INST HEALTH_STATUS TEMP1 failed to be within"
           stdout.rewind
         end
       end
     end
 
     describe "wait_expression" do
-      it "should wait for an expression to be true" do
+      it "waits for an expression to be true" do
         capture_io do |stdout|
           # Success
           wait_expression("true == true", 5)
-          stdout.string.should match "WAIT: true == true is TRUE"
+          expect(stdout.string).to match "WAIT: true == true is TRUE"
           stdout.rewind
 
           # Failure
           wait_expression("true == false", 0.1)
-          stdout.string.should match "WAIT: true == false is FALSE"
+          expect(stdout.string).to match "WAIT: true == false is FALSE"
           stdout.rewind
         end
       end
     end
 
     describe "wait_check, wait_check_raw, wait_check_tolerance, wait_check_tolerance_raw" do
-      it "should wait for telemetry check to be true" do
+      it "waits for telemetry check to be true" do
         capture_io do |stdout|
           # Success
           wait_check("INST HEALTH_STATUS TEMP1 == -100.0", 5)
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == -100.0"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == -100.0"
           stdout.rewind
           wait_check_raw("INST HEALTH_STATUS TEMP1 == 0", 5)
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 == 0"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 == 0"
           stdout.rewind
           wait_check_tolerance("INST HEALTH_STATUS TEMP1", -100.0, 1, 5)
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 was within"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 was within"
           stdout.rewind
           wait_check_tolerance_raw("INST HEALTH_STATUS TEMP1", 0, 1, 5)
-          stdout.string.should match "CHECK: INST HEALTH_STATUS TEMP1 was within"
+          expect(stdout.string).to match "CHECK: INST HEALTH_STATUS TEMP1 was within"
           stdout.rewind
         end
 
@@ -604,11 +604,11 @@ module Cosmos
     end
 
     describe "wait_check_expression" do
-      it "should wait for an expression to be true" do
+      it "waits for an expression to be true" do
         capture_io do |stdout|
           # Success
           wait_check_expression("true == true", 5)
-          stdout.string.should match "CHECK: true == true is TRUE"
+          expect(stdout.string).to match "CHECK: true == true is TRUE"
           stdout.rewind
         end
 
@@ -618,7 +618,7 @@ module Cosmos
     end
 
     describe "wait_packet, wait_check_packet" do
-      it "should wait for a certain number of packets" do
+      it "waits for a certain number of packets" do
         capture_io do |stdout|
           wait_packet("INST","HEALTH_STATUS",1,0.1)
         end
@@ -628,36 +628,36 @@ module Cosmos
     end
 
     describe "get_interface_names" do
-      it "should return all interfaces" do
-        get_interface_names.should include("INST_INT")
+      it "returns all interfaces" do
+        expect(get_interface_names).to include("INST_INT")
       end
     end
 
     describe "connect_interface, disconnect_interface, interface_state" do
-      it "should connect, disconnect and return the state of the interface CTS-3" do
+      it "connects, disconnect and return the state of the interface CTS-3" do
         connect_interface("INST_INT")
-        interface_state("INST_INT").should eql "CONNECTED"
+        expect(interface_state("INST_INT")).to eql "CONNECTED"
         disconnect_interface("INST_INT")
       end
     end
 
     describe "map_target_to_interface" do
-      it "should map a target name to an interface" do
+      it "maps a target name to an interface" do
         map_target_to_interface("INST","INST_INT")
       end
     end
 
     describe "connect_router, disconnect_router, get_router_names, router_state" do
-      it "should return connect, disconnect, and list the routers CTS-11" do
-        get_router_names.should include("PREIDENTIFIED_ROUTER")
+      it "returns connect, disconnect, and list the routers CTS-11" do
+        expect(get_router_names).to include("PREIDENTIFIED_ROUTER")
         connect_router("PREIDENTIFIED_ROUTER")
-        router_state("PREIDENTIFIED_ROUTER").should eql "CONNECTED"
+        expect(router_state("PREIDENTIFIED_ROUTER")).to eql "CONNECTED"
         disconnect_router("PREIDENTIFIED_ROUTER")
       end
     end
 
     describe "logging methods" do
-      it "should start and stop logging and get filenames CTS-14" do
+      it "starts and stop logging and get filenames CTS-14" do
         start_logging
         stop_logging
         get_cmd_log_filename
@@ -678,23 +678,23 @@ module Cosmos
         start_new_server_message_log
         sleep 0.1
         filename = get_server_message_log_filename
-        filename.should match /server_messages.txt/
+        expect(filename).to match /server_messages.txt/
       end
     end
 
     describe "display" do
-      it "should display a telemetry viewer screen" do
+      it "displays a telemetry viewer screen" do
         expect { display("HI") }.to raise_error(RuntimeError, /HI could not be displayed/)
       end
     end
     describe "clear" do
-      it "should close a telemetry viewer screen" do
+      it "closes a telemetry viewer screen" do
         expect { clear("HI") }.to raise_error(RuntimeError, /HI could not be cleared/)
       end
     end
 
     describe "ScriptRunnerFrame methods" do
-      it "should call various ScriptRunnerFrame methods" do
+      it "calls various ScriptRunnerFrame methods" do
         class Dummy; def method_missing(meth, *args, &block); end; end
         class ScriptRunnerFrame
           def self.method_missing(meth, *args, &block); end
@@ -712,22 +712,22 @@ module Cosmos
     end
 
     describe "start" do
-      it "should start a script locally" do
+      it "starts a script locally" do
         class ScriptRunnerFrame; def self.instance; false; end; end
         start("cosmos.rb")
       end
 
-      it "should start a script without the .rb extension" do
+      it "starts a script without the .rb extension" do
         class ScriptRunnerFrame; def self.instance; false; end; end
         start("cosmos")
       end
 
-      it "should raise an error if the script can't be found" do
+      it "raises an error if the script can't be found" do
         class ScriptRunnerFrame; def self.instance; false; end; end
         expect { start("unknown_script.rb") }.to raise_error(RuntimeError)
       end
 
-      it "should start a script within ScriptRunnerFrame" do
+      it "starts a script within ScriptRunnerFrame" do
         class ScriptRunnerFrame
           @@instrumented_cache = {}
           def self.instance; true; end