cosmos 3.2.1 → 3.3.0

data/spec/system/target_spec.rb

@@ -21,26 +21,26 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should create a target with the given name" do
-        Target.new("TGT").name.should eql "TGT"
+      it "creates a target with the given name" do
+        expect(Target.new("TGT").name).to eql "TGT"
       end
 
-      it "should create a target with the given substitute name" do
+      it "creates a target with the given substitute name" do
         tgt = Target.new("TGT","TGT2")
-        tgt.name.should eql "TGT2"
-        tgt.original_name.should eql "TGT"
+        expect(tgt.name).to eql "TGT2"
+        expect(tgt.original_name).to eql "TGT"
       end
 
-      it "should create a target with the default dir" do
-        Target.new("TGT").dir.should eql File.join(USERPATH,'config','targets','TGT')
+      it "creates a target with the default dir" do
+        expect(Target.new("TGT").dir).to eql File.join(USERPATH,'config','targets','TGT')
       end
 
-      it "should create a target with an override path" do
+      it "creates a target with an override path" do
         saved = File.join(USERPATH,'saved')
-        Target.new("TGT",nil,saved).dir.should eql File.join(saved,'TGT')
+        expect(Target.new("TGT",nil,saved).dir).to eql File.join(saved,'TGT')
       end
 
-      it "should record all the command and telemetry files in the target directory" do
+      it "records all the command and telemetry files in the target directory" do
         tgt_path = File.join(Cosmos::USERPATH,'target_spec_temp')
         tgt_name = "TEST"
         cmd_tlm = File.join(tgt_path,tgt_name,'cmd_tlm')
@@ -51,16 +51,16 @@ module Cosmos
         File.open(File.join(cmd_tlm,'tlm2.txt'),'w') {}
 
         tgt = Target.new(tgt_name,nil,tgt_path)
-        tgt.dir.should eql File.join(tgt_path,tgt_name)
+        expect(tgt.dir).to eql File.join(tgt_path,tgt_name)
         files = Dir[File.join(cmd_tlm,'*.txt')]
-        files.should_not be_empty
-        tgt.cmd_tlm_files.length.should eql 4
-        tgt.cmd_tlm_files.sort.should eql files.sort
+        expect(files).not_to be_empty
+        expect(tgt.cmd_tlm_files.length).to eql 4
+        expect(tgt.cmd_tlm_files.sort).to eql files.sort
 
         FileUtils.rm_r(tgt_path)
       end
 
-      it "should process a target.txt in the target directory" do
+      it "processes a target.txt in the target directory" do
         tgt_path = File.join(Cosmos::USERPATH,'target_spec_temp')
         tgt_name = "TEST"
         tgt_dir = File.join(tgt_path,tgt_name)
@@ -70,13 +70,13 @@ module Cosmos
         end
 
         tgt = Target.new(tgt_name,nil,tgt_path)
-        tgt.dir.should eql tgt_dir
-        tgt.ignored_parameters.should eql ["TEST"]
+        expect(tgt.dir).to eql tgt_dir
+        expect(tgt.ignored_parameters).to eql ["TEST"]
 
         FileUtils.rm_r(tgt_path)
       end
 
-      it "should process an alternative target.txt in the target directory" do
+      it "processes an alternative target.txt in the target directory" do
         tgt_path = File.join(Cosmos::USERPATH,'target_spec_temp')
         tgt_name = "TEST"
         tgt_dir = File.join(tgt_path,tgt_name)
@@ -86,15 +86,15 @@ module Cosmos
         end
 
         tgt = Target.new(tgt_name,nil,tgt_path, 'target_other.txt')
-        tgt.dir.should eql tgt_dir
-        tgt.ignored_parameters.should eql ["BOB"]
+        expect(tgt.dir).to eql tgt_dir
+        expect(tgt.ignored_parameters).to eql ["BOB"]
 
         FileUtils.rm_r(tgt_path)
       end
     end
 
     describe "process_file" do
-      it "should complain about unknown keywords" do
+      it "complains about unknown keywords" do
         tf = Tempfile.new('unittest')
         tf.puts("BLAH")
         tf.close
@@ -103,7 +103,7 @@ module Cosmos
       end
 
       context "with REQUIRE" do
-        it "should take 1 parameters" do
+        it "takes 1 parameters" do
           tf = Tempfile.new('unittest')
           tf.puts("REQUIRE")
           tf.close
@@ -117,7 +117,7 @@ module Cosmos
           tf.unlink
         end
 
-        it "should complain if the file doesn't exist" do
+        it "complains if the file doesn't exist" do
           tf = Tempfile.new('unittest')
           tf.puts("REQUIRE my_file.rb")
           tf.close
@@ -125,7 +125,7 @@ module Cosmos
           tf.unlink
         end
 
-        it "should require the file" do
+        it "requires the file" do
           filename = File.join(File.dirname(__FILE__),'..','..','lib','my_file.rb')
           File.open(filename, 'w') do |file|
             file.puts "class MyFile"
@@ -142,7 +142,7 @@ module Cosmos
       end
 
       context "with IGNORE_PARAMETER" do
-        it "should take 1 parameters" do
+        it "takes 1 parameters" do
           tf = Tempfile.new('unittest')
           tf.puts("IGNORE_PARAMETER")
           tf.close
@@ -156,19 +156,19 @@ module Cosmos
           tf.unlink
         end
 
-        it "should store the parameter" do
+        it "stores the parameter" do
           tf = Tempfile.new('unittest')
           tf.puts("IGNORE_PARAMETER TEST")
           tf.close
           tgt = Target.new("TGT")
           tgt.process_file(tf.path)
-          tgt.ignored_parameters.should eql ["TEST"]
+          expect(tgt.ignored_parameters).to eql ["TEST"]
           tf.unlink
         end
       end
 
       context "with COMMANDS and TELEMETRY" do
-        it "should take 1 parameters" do
+        it "takes 1 parameters" do
           tf = Tempfile.new('unittest')
           tf.puts("COMMANDS")
           tf.close
@@ -194,7 +194,7 @@ module Cosmos
           tf.unlink
         end
 
-        it "should store the filename" do
+        it "stores the filename" do
           tgt_path = File.join(Cosmos::USERPATH,'target_spec_temp')
           tgt_name = "TEST"
           tgt_dir = File.join(tgt_path,tgt_name)
@@ -212,9 +212,9 @@ module Cosmos
           end
 
           tgt = Target.new(tgt_name,nil,tgt_path)
-          tgt.dir.should eql tgt_dir
-          tgt.cmd_tlm_files.length.should eql 2
-          tgt.cmd_tlm_files.should eql [tgt_dir + '/cmd_tlm/tgt_cmds2.txt', tgt_dir + '/cmd_tlm/tgt_tlm3.txt']
+          expect(tgt.dir).to eql tgt_dir
+          expect(tgt.cmd_tlm_files.length).to eql 2
+          expect(tgt.cmd_tlm_files).to eql [tgt_dir + '/cmd_tlm/tgt_cmds2.txt', tgt_dir + '/cmd_tlm/tgt_tlm3.txt']
 
           FileUtils.rm_r(tgt_dir)
         end

data/spec/tools/cmd_tlm_server/api_spec.rb

@@ -55,402 +55,402 @@ module Cosmos
     end
 
     describe "cmd" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd)
         sleep(0.5)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_name, params = @api.cmd("INST COLLECT with TYPE NORMAL, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should complain if parameters are not separated by commas" do
+      it "complains if parameters are not separated by commas" do
         expect { @api.cmd("INST COLLECT with TYPE NORMAL DURATION 5") }.to raise_error(/Missing comma/)
       end
 
-      it "should complain if parameters don't have values" do
+      it "complains if parameters don't have values" do
         expect { @api.cmd("INST COLLECT with TYPE") }.to raise_error(/Missing value/)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_name, params = @api.cmd("INST","COLLECT","TYPE"=>"NORMAL","DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should process commands without parameters" do
+      it "processes commands without parameters" do
         target_name, cmd_name, params = @api.cmd("INST","ABORT")
-        target_name.should eql 'INST'
-        cmd_name.should eql 'ABORT'
-        params.should be {}
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'ABORT'
+        expect(params).to be {}
       end
 
-      it "should complain about too many parameters" do
+      it "complains about too many parameters" do
         expect { @api.cmd("INST","COLLECT","TYPE","DURATION") }.to raise_error(/Invalid number of arguments/)
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should warn about out of range parameters" do
+      it "warns about out of range parameters" do
         expect { @api.cmd("INST COLLECT with TYPE NORMAL, DURATION 1000") }.to raise_error(/not in valid range/)
       end
 
-      it "should warn about hazardous parameters" do
+      it "warns about hazardous parameters" do
         expect { @api.cmd("INST COLLECT with TYPE SPECIAL") }.to raise_error(/Hazardous/)
       end
 
-      it "should warn about hazardous commands" do
+      it "warns about hazardous commands" do
         expect { @api.cmd("INST CLEAR") }.to raise_error(/Hazardous/)
       end
     end
 
     describe "cmd_no_range_check" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_no_range_check)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_no_range_check_name, params = @api.cmd_no_range_check("INST COLLECT with TYPE NORMAL, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_no_range_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_range_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_no_range_check_name, params = @api.cmd_no_range_check("INST","COLLECT","TYPE"=>"NORMAL","DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_no_range_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_range_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_no_range_check("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should not warn about out of range parameters" do
+      it "does not warn about out of range parameters" do
         expect { @api.cmd_no_range_check("INST COLLECT with TYPE NORMAL, DURATION 1000") }.to_not raise_error
       end
 
-      it "should warn about hazardous parameters" do
+      it "warns about hazardous parameters" do
         expect { @api.cmd_no_range_check("INST COLLECT with TYPE SPECIAL") }.to raise_error(/Hazardous/)
       end
 
-      it "should warn about hazardous commands" do
+      it "warns about hazardous commands" do
         expect { @api.cmd_no_range_check("INST CLEAR") }.to raise_error(/Hazardous/)
       end
     end
 
     describe "cmd_no_hazardous_check" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_no_hazardous_check)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_no_hazardous_check_name, params = @api.cmd_no_hazardous_check("INST COLLECT with TYPE NORMAL, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_no_hazardous_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_hazardous_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_no_hazardous_check_name, params = @api.cmd_no_hazardous_check("INST","COLLECT","TYPE"=>"NORMAL","DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_no_hazardous_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_hazardous_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should process parameters that are strings" do
+      it "processes parameters that are strings" do
         target_name, cmd_name, params = @api.cmd_no_hazardous_check("INST ASCIICMD with STRING 'ARM LASER'")
-        target_name.should eql 'INST'
-        cmd_name.should eql 'ASCIICMD'
-        params.should include('STRING'=>'ARM LASER')
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'ASCIICMD'
+        expect(params).to include('STRING'=>'ARM LASER')
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_no_hazardous_check("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should warn about out of range parameters" do
+      it "warns about out of range parameters" do
         expect { @api.cmd_no_hazardous_check("INST COLLECT with TYPE NORMAL, DURATION 1000") }.to raise_error(/not in valid range/)
       end
 
-      it "should not warn about hazardous parameters" do
+      it "does not warn about hazardous parameters" do
         expect { @api.cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL") }.to_not raise_error
       end
 
-      it "should not warn about hazardous commands" do
+      it "does not warn about hazardous commands" do
         expect { @api.cmd_no_hazardous_check("INST CLEAR") }.to_not raise_error
       end
     end
 
     describe "cmd_no_checks" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_no_checks)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_no_checks_name, params = @api.cmd_no_checks("INST COLLECT with TYPE NORMAL, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_no_checks_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_checks_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_no_checks_name, params = @api.cmd_no_checks("INST","COLLECT","TYPE"=>"NORMAL","DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_no_checks_name.should eql 'COLLECT'
-        params.should include('TYPE'=>'NORMAL', 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_checks_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>'NORMAL', 'DURATION'=>5)
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_no_checks("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should not warn about out of range parameters" do
+      it "does not warn about out of range parameters" do
         expect { @api.cmd_no_checks("INST COLLECT with TYPE NORMAL, DURATION 1000") }.to_not raise_error
       end
 
-      it "should not warn about hazardous parameters" do
+      it "does not warn about hazardous parameters" do
         expect { @api.cmd_no_checks("INST COLLECT with TYPE SPECIAL") }.to_not raise_error
       end
 
-      it "should not warn about hazardous commands" do
+      it "does not warn about hazardous commands" do
         expect { @api.cmd_no_checks("INST CLEAR") }.to_not raise_error
       end
     end
 
     describe "cmd_raw" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_raw)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_name, params = @api.cmd_raw("INST COLLECT with TYPE 0, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should complain if parameters are not separated by commas" do
+      it "complains if parameters are not separated by commas" do
         expect { @api.cmd_raw("INST COLLECT with TYPE 0 DURATION 5") }.to raise_error(/Missing comma/)
       end
 
-      it "should complain if parameters don't have values" do
+      it "complains if parameters don't have values" do
         expect { @api.cmd_raw("INST COLLECT with TYPE") }.to raise_error(/Missing value/)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_name, params = @api.cmd_raw("INST","COLLECT","TYPE"=>0,"DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should process commands without parameters" do
+      it "processes commands without parameters" do
         target_name, cmd_name, params = @api.cmd_raw("INST","ABORT")
-        target_name.should eql 'INST'
-        cmd_name.should eql 'ABORT'
-        params.should be {}
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'ABORT'
+        expect(params).to be {}
       end
 
-      it "should complain about too many parameters" do
+      it "complains about too many parameters" do
         expect { @api.cmd_raw("INST","COLLECT","TYPE","DURATION") }.to raise_error(/Invalid number of arguments/)
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_raw("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should warn about out of range parameters" do
+      it "warns about out of range parameters" do
         expect { @api.cmd_raw("INST COLLECT with TYPE 0, DURATION 1000") }.to raise_error(/not in valid range/)
       end
 
-      it "should warn about hazardous parameters" do
+      it "warns about hazardous parameters" do
         expect { @api.cmd_raw("INST COLLECT with TYPE 1") }.to raise_error(/Hazardous/)
       end
 
-      it "should warn about hazardous commands" do
+      it "warns about hazardous commands" do
         expect { @api.cmd_raw("INST CLEAR") }.to raise_error(/Hazardous/)
       end
     end
 
     describe "cmd_no_range_check" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_raw_no_range_check)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_no_range_check_name, params = @api.cmd_raw_no_range_check("INST COLLECT with TYPE 0, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_no_range_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_range_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_no_range_check_name, params = @api.cmd_raw_no_range_check("INST","COLLECT","TYPE"=>0,"DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_no_range_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_range_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_raw_no_range_check("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should not warn about out of range parameters" do
+      it "does not warn about out of range parameters" do
         expect { @api.cmd_raw_no_range_check("INST COLLECT with TYPE 0, DURATION 1000") }.to_not raise_error
       end
 
-      it "should warn about hazardous parameters" do
+      it "warns about hazardous parameters" do
         expect { @api.cmd_raw_no_range_check("INST COLLECT with TYPE 1") }.to raise_error(/Hazardous/)
       end
 
-      it "should warn about hazardous commands" do
+      it "warns about hazardous commands" do
         expect { @api.cmd_raw_no_range_check("INST CLEAR") }.to raise_error(/Hazardous/)
       end
     end
 
     describe "cmd_raw_no_hazardous_check" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_raw_no_hazardous_check)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_no_hazardous_check_name, params = @api.cmd_raw_no_hazardous_check("INST COLLECT with TYPE 0, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_no_hazardous_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_hazardous_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_no_hazardous_check_name, params = @api.cmd_raw_no_hazardous_check("INST","COLLECT","TYPE"=>0,"DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_no_hazardous_check_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_hazardous_check_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should process parameters that are strings" do
+      it "processes parameters that are strings" do
         target_name, cmd_name, params = @api.cmd_raw_no_hazardous_check("INST ASCIICMD with STRING 'ARM LASER'")
-        target_name.should eql 'INST'
-        cmd_name.should eql 'ASCIICMD'
-        params.should include('STRING'=>'ARM LASER')
+        expect(target_name).to eql 'INST'
+        expect(cmd_name).to eql 'ASCIICMD'
+        expect(params).to include('STRING'=>'ARM LASER')
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_raw_no_hazardous_check("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should warn about out of range parameters" do
+      it "warns about out of range parameters" do
         expect { @api.cmd_raw_no_hazardous_check("INST COLLECT with TYPE 0, DURATION 1000") }.to raise_error(/not in valid range/)
       end
 
-      it "should not warn about hazardous parameters" do
+      it "does not warn about hazardous parameters" do
         expect { @api.cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1") }.to_not raise_error
       end
 
-      it "should not warn about hazardous commands" do
+      it "does not warn about hazardous commands" do
         expect { @api.cmd_raw_no_hazardous_check("INST CLEAR") }.to_not raise_error
       end
     end
 
     describe "cmd_raw_no_checks" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_cmd_unknown(:cmd_raw_no_checks)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         target_name, cmd_no_checks_name, params = @api.cmd_raw_no_checks("INST COLLECT with TYPE 0, DURATION 5")
-        target_name.should eql 'INST'
-        cmd_no_checks_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_checks_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         target_name, cmd_no_checks_name, params = @api.cmd_raw_no_checks("INST","COLLECT","TYPE"=>0,"DURATION"=>5)
-        target_name.should eql 'INST'
-        cmd_no_checks_name.should eql 'COLLECT'
-        params.should include('TYPE'=>0, 'DURATION'=>5)
+        expect(target_name).to eql 'INST'
+        expect(cmd_no_checks_name).to eql 'COLLECT'
+        expect(params).to include('TYPE'=>0, 'DURATION'=>5)
       end
 
-      it "should warn about required parameters" do
+      it "warns about required parameters" do
         expect { @api.cmd_raw_no_checks("INST COLLECT with DURATION 5") }.to raise_error(/Required/)
       end
 
-      it "should not warn about out of range parameters" do
+      it "does not warn about out of range parameters" do
         expect { @api.cmd_raw_no_checks("INST COLLECT with TYPE 0, DURATION 1000") }.to_not raise_error
       end
 
-      it "should not warn about hazardous parameters" do
+      it "does not warn about hazardous parameters" do
         expect { @api.cmd_raw_no_checks("INST COLLECT with TYPE 1") }.to_not raise_error
       end
 
-      it "should not warn about hazardous commands" do
+      it "does not warn about hazardous commands" do
         expect { @api.cmd_raw_no_checks("INST CLEAR") }.to_not raise_error
       end
     end
 
     describe "get_cmd_list" do
-      it "should return command names sorted" do
+      it "returns command names sorted" do
         result = @api.get_cmd_list("INST")
-        result.sort.should eql result
+        expect(result.sort).to eql result
       end
 
-      it "should complain with a unknown target" do
+      it "complains with a unknown target" do
         expect { @api.get_cmd_list("BLAH") }.to raise_error(/does not exist/)
       end
 
-      it "should return command names and descriptions for a given target" do
+      it "returns command names and descriptions for a given target" do
         result = @api.get_cmd_list("INST")
-        result[0][0].should eql "ABORT"
+        expect(result[0][0]).to eql "ABORT"
         # The second parameter is the description ... only test one
-        result[0][1].should eql "Aborts a collect on the instrument"
-        result[1][0].should eql "ARYCMD"
-        result[2][0].should eql "ASCIICMD"
-        result[3][0].should eql "CLEAR"
-        result[4][0].should eql "COLLECT"
-        result[5][0].should eql "COSMOS_ERROR_HANDLE"
-        result[6][0].should eql "COSMOS_ERROR_IGNORE"
-        result[7][0].should eql "COSMOS_HANDSHAKE_DS"
-        result[8][0].should eql "COSMOS_HANDSHAKE_EN"
-        result[9][0].should eql "FLTCMD"
-        result[10][0].should eql "LINC_COMMAND"
-        result[11][0].should eql "SETPARAMS"
-        result[12][0].should eql "SLRPNLDEPLOY"
-        result[13][0].should eql "SLRPNLRESET"
+        expect(result[0][1]).to eql "Aborts a collect on the instrument"
+        expect(result[1][0]).to eql "ARYCMD"
+        expect(result[2][0]).to eql "ASCIICMD"
+        expect(result[3][0]).to eql "CLEAR"
+        expect(result[4][0]).to eql "COLLECT"
+        expect(result[5][0]).to eql "COSMOS_ERROR_HANDLE"
+        expect(result[6][0]).to eql "COSMOS_ERROR_IGNORE"
+        expect(result[7][0]).to eql "COSMOS_HANDSHAKE_DS"
+        expect(result[8][0]).to eql "COSMOS_HANDSHAKE_EN"
+        expect(result[9][0]).to eql "FLTCMD"
+        expect(result[10][0]).to eql "LINC_COMMAND"
+        expect(result[11][0]).to eql "SETPARAMS"
+        expect(result[12][0]).to eql "SLRPNLDEPLOY"
+        expect(result[13][0]).to eql "SLRPNLRESET"
       end
     end
 
     describe "get_cmd_param_list" do
-      it "should return parameters for the command" do
+      it "returns parameters for the command" do
         result = @api.get_cmd_param_list("INST","COLLECT")
         # Each element in the results array contains:
         #   name, default, states, description, full units, units, required
-        result.should include ['TYPE',0,{"NORMAL"=>0,"SPECIAL"=>1},'Collect type',nil,nil,true]
-        result.should include ['TEMP',0.0,nil,'Collect temperature','Celcius','C',false]
+        expect(result).to include ['TYPE',0,{"NORMAL"=>0,"SPECIAL"=>1},'Collect type',nil,nil,true]
+        expect(result).to include ['TEMP',0.0,nil,'Collect temperature','Celcius','C',false]
       end
 
-      it "should return array parameters for the command" do
+      it "returns array parameters for the command" do
         result = @api.get_cmd_param_list("INST","ARYCMD")
         # Each element in the results array contains:
         #   name, default, states, description, full units, units, required
-        result.should include ['ARRAY',[],nil,'Array parameter',nil,nil,false]
+        expect(result).to include ['ARRAY',[],nil,'Array parameter',nil,nil,false]
       end
     end
 
     describe "get_cmd_hazardous" do
-      it "should return whether the command with parameters is hazardous" do
-        @api.get_cmd_hazardous("INST","COLLECT",{"TYPE"=>"NORMAL"}).should be_falsey
-        @api.get_cmd_hazardous("INST","COLLECT",{"TYPE"=>"SPECIAL"}).should be_truthy
+      it "returns whether the command with parameters is hazardous" do
+        expect(@api.get_cmd_hazardous("INST","COLLECT",{"TYPE"=>"NORMAL"})).to be_falsey
+        expect(@api.get_cmd_hazardous("INST","COLLECT",{"TYPE"=>"SPECIAL"})).to be_truthy
       end
 
-      it "should return whether the command is hazardous" do
-        @api.get_cmd_hazardous("INST","CLEAR").should be_truthy
+      it "returns whether the command is hazardous" do
+        expect(@api.get_cmd_hazardous("INST","CLEAR")).to be_truthy
       end
     end
 
@@ -464,80 +464,80 @@ module Cosmos
     end
 
     describe "tlm" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_tlm_unknown(:tlm)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         value = @api.tlm("INST HEALTH_STATUS TEMP1")
-        value.should eql -100.0
+        expect(value).to eql -100.0
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         value = @api.tlm("INST","HEALTH_STATUS","TEMP1")
       end
 
-      it "should complain if too many parameters" do
+      it "complains if too many parameters" do
         expect { @api.tlm("INST","HEALTH_STATUS","TEMP1","TEMP2") }.to raise_error(/Invalid number of arguments/)
       end
     end
 
     describe "tlm_raw" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_tlm_unknown(:tlm_raw)
       end
 
-      it "should process a string" do
-        @api.tlm_raw("INST HEALTH_STATUS TEMP1").should eql 0
+      it "processes a string" do
+        expect(@api.tlm_raw("INST HEALTH_STATUS TEMP1")).to eql 0
       end
 
-      it "should return the value using LATEST" do
-        @api.tlm_raw("INST LATEST TEMP1").should eql 0
+      it "returns the value using LATEST" do
+        expect(@api.tlm_raw("INST LATEST TEMP1")).to eql 0
       end
 
-      it "should process parameters" do
-        @api.tlm_raw("INST","HEALTH_STATUS","TEMP1").should eql 0
+      it "processes parameters" do
+        expect(@api.tlm_raw("INST","HEALTH_STATUS","TEMP1")).to eql 0
       end
     end
 
     describe "tlm_formatted" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_tlm_unknown(:tlm_formatted)
       end
 
-      it "should process a string" do
-        @api.tlm_formatted("INST HEALTH_STATUS TEMP1").should eql "-100.000"
+      it "processes a string" do
+        expect(@api.tlm_formatted("INST HEALTH_STATUS TEMP1")).to eql "-100.000"
       end
 
-      it "should return the value using LATEST" do
-        @api.tlm_formatted("INST LATEST TEMP1").should eql "-100.000"
+      it "returns the value using LATEST" do
+        expect(@api.tlm_formatted("INST LATEST TEMP1")).to eql "-100.000"
       end
 
-      it "should process parameters" do
-        @api.tlm_formatted("INST","HEALTH_STATUS","TEMP1").should eql "-100.000"
+      it "processes parameters" do
+        expect(@api.tlm_formatted("INST","HEALTH_STATUS","TEMP1")).to eql "-100.000"
       end
     end
 
     describe "tlm_with_units" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         test_tlm_unknown(:tlm_with_units)
       end
 
-      it "should process a string" do
-        @api.tlm_with_units("INST HEALTH_STATUS TEMP1").should eql "-100.000 C"
+      it "processes a string" do
+        expect(@api.tlm_with_units("INST HEALTH_STATUS TEMP1")).to eql "-100.000 C"
       end
 
-      it "should return the value using LATEST" do
-        @api.tlm_with_units("INST LATEST TEMP1").should eql "-100.000 C"
+      it "returns the value using LATEST" do
+        expect(@api.tlm_with_units("INST LATEST TEMP1")).to eql "-100.000 C"
       end
 
-      it "should process parameters" do
-        @api.tlm_with_units("INST","HEALTH_STATUS","TEMP1").should eql "-100.000 C"
+      it "processes parameters" do
+        expect(@api.tlm_with_units("INST","HEALTH_STATUS","TEMP1")).to eql "-100.000 C"
       end
     end
 
     describe "tlm_variable" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         expect { @api.tlm_variable("BLAH HEALTH_STATUS COLLECTS",:RAW) }.to raise_error(/does not exist/)
         expect { @api.tlm_variable("INST UNKNOWN COLLECTS",:RAW) }.to raise_error(/does not exist/)
         expect { @api.tlm_variable("INST HEALTH_STATUS BLAH",:RAW) }.to raise_error(/does not exist/)
@@ -546,34 +546,34 @@ module Cosmos
         expect { @api.tlm_variable("INST","HEALTH_STATUS","BLAH",:RAW) }.to raise_error(/does not exist/)
       end
 
-      it "should process a string" do
-        @api.tlm_variable("INST HEALTH_STATUS TEMP1",:CONVERTED).should eql -100.0
-        @api.tlm_variable("INST HEALTH_STATUS TEMP1",:RAW).should eql 0
-        @api.tlm_variable("INST HEALTH_STATUS TEMP1",:FORMATTED).should eql "-100.000"
-        @api.tlm_variable("INST HEALTH_STATUS TEMP1",:WITH_UNITS).should eql "-100.000 C"
+      it "processes a string" do
+        expect(@api.tlm_variable("INST HEALTH_STATUS TEMP1",:CONVERTED)).to eql -100.0
+        expect(@api.tlm_variable("INST HEALTH_STATUS TEMP1",:RAW)).to eql 0
+        expect(@api.tlm_variable("INST HEALTH_STATUS TEMP1",:FORMATTED)).to eql "-100.000"
+        expect(@api.tlm_variable("INST HEALTH_STATUS TEMP1",:WITH_UNITS)).to eql "-100.000 C"
       end
 
-      it "should return the value using LATEST" do
-        @api.tlm_variable("INST LATEST TEMP1",:CONVERTED).should eql -100.0
-        @api.tlm_variable("INST LATEST TEMP1",:RAW).should eql 0
-        @api.tlm_variable("INST LATEST TEMP1",:FORMATTED).should eql "-100.000"
-        @api.tlm_variable("INST LATEST TEMP1",:WITH_UNITS).should eql "-100.000 C"
+      it "returns the value using LATEST" do
+        expect(@api.tlm_variable("INST LATEST TEMP1",:CONVERTED)).to eql -100.0
+        expect(@api.tlm_variable("INST LATEST TEMP1",:RAW)).to eql 0
+        expect(@api.tlm_variable("INST LATEST TEMP1",:FORMATTED)).to eql "-100.000"
+        expect(@api.tlm_variable("INST LATEST TEMP1",:WITH_UNITS)).to eql "-100.000 C"
       end
 
-      it "should process parameters" do
-        @api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:CONVERTED).should eql -100.0
-        @api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:RAW).should eql 0
-        @api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:FORMATTED).should eql "-100.000"
-        @api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:WITH_UNITS).should eql "-100.000 C"
+      it "processes parameters" do
+        expect(@api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:CONVERTED)).to eql -100.0
+        expect(@api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:RAW)).to eql 0
+        expect(@api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:FORMATTED)).to eql "-100.000"
+        expect(@api.tlm_variable("INST","HEALTH_STATUS","TEMP1",:WITH_UNITS)).to eql "-100.000 C"
       end
 
-      it "should complain with too many parameters" do
+      it "complains with too many parameters" do
         expect { @api.tlm_variable("INST","HEALTH_STATUS","TEMP1","TEMP2",:CONVERTED) }.to raise_error(/Invalid number of arguments/)
       end
     end
 
     describe "set_tlm" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         expect { @api.set_tlm("BLAH HEALTH_STATUS COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm("INST UNKNOWN COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm("INST HEALTH_STATUS BLAH = 1") }.to raise_error(/does not exist/)
@@ -582,23 +582,23 @@ module Cosmos
         expect { @api.set_tlm("INST","HEALTH_STATUS","BLAH",1) }.to raise_error(/does not exist/)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         @api.set_tlm("INST HEALTH_STATUS TEMP1 = 0.0")
-        @api.tlm("INST HEALTH_STATUS TEMP1").should be_within(0.00001).of(-0.05759)
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to be_within(0.00001).of(-0.05759)
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         @api.set_tlm("INST","HEALTH_STATUS","TEMP1", 0.0)
-        @api.tlm("INST HEALTH_STATUS TEMP1").should be_within(0.00001).of(-0.05759)
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to be_within(0.00001).of(-0.05759)
       end
 
-      it "should complain with too many parameters" do
+      it "complains with too many parameters" do
         expect { @api.set_tlm("INST","HEALTH_STATUS","TEMP1","TEMP2",0.0) }.to raise_error(/Invalid number of arguments/)
       end
     end
 
     describe "set_tlm_raw" do
-      it "should complain about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, commands, and parameters" do
         expect { @api.set_tlm_raw("BLAH HEALTH_STATUS COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm_raw("INST UNKNOWN COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm_raw("INST HEALTH_STATUS BLAH = 1") }.to raise_error(/does not exist/)
@@ -607,156 +607,156 @@ module Cosmos
         expect { @api.set_tlm_raw("INST","HEALTH_STATUS","BLAH",1) }.to raise_error(/does not exist/)
       end
 
-      it "should process a string" do
+      it "processes a string" do
         @api.set_tlm_raw("INST HEALTH_STATUS TEMP1 = 0.0")
-        @api.tlm("INST HEALTH_STATUS TEMP1").should eql -100.0
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to eql -100.0
       end
 
-      it "should process parameters" do
+      it "processes parameters" do
         @api.set_tlm_raw("INST","HEALTH_STATUS","TEMP1", 0.0)
-        @api.tlm("INST HEALTH_STATUS TEMP1").should eql -100.0
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to eql -100.0
       end
     end
 
     describe "get_tlm_packet" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.get_tlm_packet("BLAH","HEALTH_STATUS") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.get_tlm_packet("INST","BLAH") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain using LATEST" do
+      it "complains using LATEST" do
         expect { @api.get_tlm_packet("INST","LATEST") }.to raise_error(RuntimeError, "Telemetry packet 'INST LATEST' does not exist")
       end
 
-      it "should complain about non-existant value_types" do
+      it "complains about non-existant value_types" do
         expect { @api.get_tlm_packet("INST","HEALTH_STATUS",:MINE) }.to raise_error(ArgumentError, "Unknown value type on read: MINE")
       end
 
-      it "should read all telemetry items with their limits states" do
+      it "reads all telemetry items with their limits states" do
         vals = @api.get_tlm_packet("INST","HEALTH_STATUS")
-        vals[0][0].should eql "RECEIVED_TIMESECONDS"
-        vals[0][1].should eql 0.0
-        vals[0][2].should be_nil
-        vals[1][0].should eql "RECEIVED_TIMEFORMATTED"
-        vals[1][1].should eql "No Packet Received Time"
-        vals[1][2].should be_nil
-        vals[2][0].should eql "RECEIVED_COUNT"
-        vals[2][1].should eql 0
-        vals[2][2].should be_nil
+        expect(vals[0][0]).to eql "RECEIVED_TIMESECONDS"
+        expect(vals[0][1]).to eql 0.0
+        expect(vals[0][2]).to be_nil
+        expect(vals[1][0]).to eql "RECEIVED_TIMEFORMATTED"
+        expect(vals[1][1]).to eql "No Packet Received Time"
+        expect(vals[1][2]).to be_nil
+        expect(vals[2][0]).to eql "RECEIVED_COUNT"
+        expect(vals[2][1]).to eql 0
+        expect(vals[2][2]).to be_nil
         # Spot check a few more
-        vals[22][0].should eql "TEMP1"
-        vals[22][1].should eql -100.0
-        vals[22][2].should eql :RED_LOW
-        vals[23][0].should eql "TEMP2"
-        vals[23][1].should eql -100.0
-        vals[23][2].should eql :RED_LOW
-        vals[24][0].should eql "TEMP3"
-        vals[24][1].should eql -100.0
-        vals[24][2].should eql :RED_LOW
-        vals[25][0].should eql "TEMP4"
-        vals[25][1].should eql -100.0
-        vals[25][2].should eql :RED_LOW
+        expect(vals[22][0]).to eql "TEMP1"
+        expect(vals[22][1]).to eql -100.0
+        expect(vals[22][2]).to eql :RED_LOW
+        expect(vals[23][0]).to eql "TEMP2"
+        expect(vals[23][1]).to eql -100.0
+        expect(vals[23][2]).to eql :RED_LOW
+        expect(vals[24][0]).to eql "TEMP3"
+        expect(vals[24][1]).to eql -100.0
+        expect(vals[24][2]).to eql :RED_LOW
+        expect(vals[25][0]).to eql "TEMP4"
+        expect(vals[25][1]).to eql -100.0
+        expect(vals[25][2]).to eql :RED_LOW
       end
     end
 
     describe "get_tlm_values" do
-      it "should handle an empty request" do
-        @api.get_tlm_values([]).should eql [[], [], [], :DEFAULT]
+      it "handles an empty request" do
+        expect(@api.get_tlm_values([])).to eql [[], [], [], :DEFAULT]
       end
 
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.get_tlm_values([["BLAH","HEALTH_STATUS","TEMP1"]]) }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.get_tlm_values([["INST","BLAH","TEMP1"]]) }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.get_tlm_values([["INST","LATEST","BLAH"]]) }.to raise_error(RuntimeError, "Telemetry item 'INST LATEST BLAH' does not exist")
       end
 
-      it "should complain about non-existant value_types" do
+      it "complains about non-existant value_types" do
         expect { @api.get_tlm_values([["INST","HEALTH_STATUS","TEMP1"]],:MINE) }.to raise_error(ArgumentError, "Unknown value type on read: MINE")
       end
 
-      it "should complain about bad arguments" do
+      it "complains about bad arguments" do
         expect { @api.get_tlm_values("INST",:MINE) }.to raise_error(ArgumentError, /item_array must be nested array/)
         expect { @api.get_tlm_values(["INST","HEALTH_STATUS","TEMP1"],:MINE) }.to raise_error(ArgumentError, /item_array must be nested array/)
         expect { @api.get_tlm_values([["INST","HEALTH_STATUS","TEMP1"]],10) }.to raise_error(ArgumentError, /value_types must be a single symbol or array of symbols/)
         expect { @api.get_tlm_values([["INST","HEALTH_STATUS","TEMP1"]],[10]) }.to raise_error(ArgumentError, /value_types must be a single symbol or array of symbols/)
       end
 
-      it "should read all the specified items" do
+      it "reads all the specified items" do
         items = []
         items << %w(INST HEALTH_STATUS TEMP1)
         items << %w(INST HEALTH_STATUS TEMP2)
         items << %w(INST HEALTH_STATUS TEMP3)
         items << %w(INST HEALTH_STATUS TEMP4)
         vals = @api.get_tlm_values(items)
-        vals[0][0].should eql -100.0
-        vals[0][1].should eql -100.0
-        vals[0][2].should eql -100.0
-        vals[0][3].should eql -100.0
-        vals[1][0].should eql :RED_LOW
-        vals[1][1].should eql :RED_LOW
-        vals[1][2].should eql :RED_LOW
-        vals[1][3].should eql :RED_LOW
-        vals[2][0].should eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
-        vals[2][1].should eql [-60.0, -55.0, 30.0, 35.0]
-        vals[2][2].should eql [-25.0, -10.0, 50.0, 55.0]
-        vals[2][3].should eql [-80.0, -70.0, 60.0, 80.0]
-        vals[3].should eql :DEFAULT
-      end
-
-      it "should read all the specified items with one conversion" do
+        expect(vals[0][0]).to eql -100.0
+        expect(vals[0][1]).to eql -100.0
+        expect(vals[0][2]).to eql -100.0
+        expect(vals[0][3]).to eql -100.0
+        expect(vals[1][0]).to eql :RED_LOW
+        expect(vals[1][1]).to eql :RED_LOW
+        expect(vals[1][2]).to eql :RED_LOW
+        expect(vals[1][3]).to eql :RED_LOW
+        expect(vals[2][0]).to eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
+        expect(vals[2][1]).to eql [-60.0, -55.0, 30.0, 35.0]
+        expect(vals[2][2]).to eql [-25.0, -10.0, 50.0, 55.0]
+        expect(vals[2][3]).to eql [-80.0, -70.0, 60.0, 80.0]
+        expect(vals[3]).to eql :DEFAULT
+      end
+
+      it "reads all the specified items with one conversion" do
         items = []
         items << %w(INST HEALTH_STATUS TEMP1)
         items << %w(INST HEALTH_STATUS TEMP2)
         items << %w(INST HEALTH_STATUS TEMP3)
         items << %w(INST HEALTH_STATUS TEMP4)
         vals = @api.get_tlm_values(items, :RAW)
-        vals[0][0].should eql 0
-        vals[0][1].should eql 0
-        vals[0][2].should eql 0
-        vals[0][3].should eql 0
-        vals[1][0].should eql :RED_LOW
-        vals[1][1].should eql :RED_LOW
-        vals[1][2].should eql :RED_LOW
-        vals[1][3].should eql :RED_LOW
-        vals[2][0].should eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
-        vals[2][1].should eql [-60.0, -55.0, 30.0, 35.0]
-        vals[2][2].should eql [-25.0, -10.0, 50.0, 55.0]
-        vals[2][3].should eql [-80.0, -70.0, 60.0, 80.0]
-        vals[3].should eql :DEFAULT
-      end
-
-      it "should read all the specified items with different conversions" do
+        expect(vals[0][0]).to eql 0
+        expect(vals[0][1]).to eql 0
+        expect(vals[0][2]).to eql 0
+        expect(vals[0][3]).to eql 0
+        expect(vals[1][0]).to eql :RED_LOW
+        expect(vals[1][1]).to eql :RED_LOW
+        expect(vals[1][2]).to eql :RED_LOW
+        expect(vals[1][3]).to eql :RED_LOW
+        expect(vals[2][0]).to eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
+        expect(vals[2][1]).to eql [-60.0, -55.0, 30.0, 35.0]
+        expect(vals[2][2]).to eql [-25.0, -10.0, 50.0, 55.0]
+        expect(vals[2][3]).to eql [-80.0, -70.0, 60.0, 80.0]
+        expect(vals[3]).to eql :DEFAULT
+      end
+
+      it "reads all the specified items with different conversions" do
         items = []
         items << %w(INST HEALTH_STATUS TEMP1)
         items << %w(INST HEALTH_STATUS TEMP2)
         items << %w(INST HEALTH_STATUS TEMP3)
         items << %w(INST HEALTH_STATUS TEMP4)
         vals = @api.get_tlm_values(items, [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS])
-        vals[0][0].should eql 0
-        vals[0][1].should eql -100.0
-        vals[0][2].should eql "-100.000"
-        vals[0][3].should eql "-100.000 C"
-        vals[1][0].should eql :RED_LOW
-        vals[1][1].should eql :RED_LOW
-        vals[1][2].should eql :RED_LOW
-        vals[1][3].should eql :RED_LOW
-        vals[2][0].should eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
-        vals[2][1].should eql [-60.0, -55.0, 30.0, 35.0]
-        vals[2][2].should eql [-25.0, -10.0, 50.0, 55.0]
-        vals[2][3].should eql [-80.0, -70.0, 60.0, 80.0]
-        vals[3].should eql :DEFAULT
-      end
-
-      it "should complain if items length != conversions length" do
+        expect(vals[0][0]).to eql 0
+        expect(vals[0][1]).to eql -100.0
+        expect(vals[0][2]).to eql "-100.000"
+        expect(vals[0][3]).to eql "-100.000 C"
+        expect(vals[1][0]).to eql :RED_LOW
+        expect(vals[1][1]).to eql :RED_LOW
+        expect(vals[1][2]).to eql :RED_LOW
+        expect(vals[1][3]).to eql :RED_LOW
+        expect(vals[2][0]).to eql [-80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
+        expect(vals[2][1]).to eql [-60.0, -55.0, 30.0, 35.0]
+        expect(vals[2][2]).to eql [-25.0, -10.0, 50.0, 55.0]
+        expect(vals[2][3]).to eql [-80.0, -70.0, 60.0, 80.0]
+        expect(vals[3]).to eql :DEFAULT
+      end
+
+      it "complains if items length != conversions length" do
         items = []
         items << %w(INST HEALTH_STATUS TEMP1)
         items << %w(INST HEALTH_STATUS TEMP2)
@@ -767,251 +767,251 @@ module Cosmos
     end
 
     describe "get_tlm_list" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.get_tlm_list("BLAH") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should return the sorted packet names for a target" do
+      it "returns the sorted packet names for a target" do
         pkts = @api.get_tlm_list("INST")
-        pkts[0][0].should eql "ADCS"
-        pkts[1][0].should eql "ERROR"
-        pkts[2][0].should eql "HANDSHAKE"
-        pkts[3][0].should eql "HEALTH_STATUS"
-        pkts[4][0].should eql "IMAGE"
-        pkts[5][0].should eql "MECH"
-        pkts[6][0].should eql "PARAMS"
+        expect(pkts[0][0]).to eql "ADCS"
+        expect(pkts[1][0]).to eql "ERROR"
+        expect(pkts[2][0]).to eql "HANDSHAKE"
+        expect(pkts[3][0]).to eql "HEALTH_STATUS"
+        expect(pkts[4][0]).to eql "IMAGE"
+        expect(pkts[5][0]).to eql "MECH"
+        expect(pkts[6][0]).to eql "PARAMS"
       end
     end
 
     describe "get_tlm_item_list" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.get_tlm_item_list("BLAH","HEALTH_STATUS") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.get_tlm_item_list("INST","BLAH") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should return all the items for a target/packet" do
+      it "returns all the items for a target/packet" do
         items = @api.get_tlm_item_list("INST","HEALTH_STATUS")
-        items[0][0].should eql "RECEIVED_TIMESECONDS"
-        items[1][0].should eql "RECEIVED_TIMEFORMATTED"
-        items[2][0].should eql "RECEIVED_COUNT"
+        expect(items[0][0]).to eql "RECEIVED_TIMESECONDS"
+        expect(items[1][0]).to eql "RECEIVED_TIMEFORMATTED"
+        expect(items[2][0]).to eql "RECEIVED_COUNT"
         # Spot check a few more
-        items[22][0].should eql "TEMP1"
-        items[22][1].should be_nil
-        items[22][2].should eql "Temperature #1"
-        items[28][0].should eql "COLLECT_TYPE"
-        items[28][1].should include("NORMAL"=>0, "SPECIAL"=>1)
-        items[28][2].should eql "Most recent collect type"
+        expect(items[22][0]).to eql "TEMP1"
+        expect(items[22][1]).to be_nil
+        expect(items[22][2]).to eql "Temperature #1"
+        expect(items[28][0]).to eql "COLLECT_TYPE"
+        expect(items[28][1]).to include("NORMAL"=>0, "SPECIAL"=>1)
+        expect(items[28][2]).to eql "Most recent collect type"
       end
     end
 
     describe "get_tlm_details" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.get_tlm_details([["BLAH","HEALTH_STATUS","TEMP1"]]) }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.get_tlm_details([["INST","BLAH","TEMP1"]]) }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.get_tlm_details([["INST","LATEST","BLAH"]]) }.to raise_error(RuntimeError, "Telemetry item 'INST LATEST BLAH' does not exist")
       end
 
-      it "should complain about bad parameters" do
+      it "complains about bad parameters" do
         expect { @api.get_tlm_details("INST") }.to raise_error(ArgumentError, /item_array must be nested array/)
         expect { @api.get_tlm_details(["INST","LATEST","BLAH"]) }.to raise_error(ArgumentError, /item_array must be nested array/)
       end
 
-      it "should read all the specified items" do
+      it "reads all the specified items" do
         items = []
         items << %w(INST HEALTH_STATUS TEMP1)
         items << %w(INST HEALTH_STATUS TEMP2)
         items << %w(INST HEALTH_STATUS TEMP3)
         items << %w(INST HEALTH_STATUS TEMP4)
         details = @api.get_tlm_details(items)
-        details.length.should eql 4
-        details[0]["name"].should eql "TEMP1"
-        details[1]["name"].should eql "TEMP2"
-        details[2]["name"].should eql "TEMP3"
-        details[3]["name"].should eql "TEMP4"
+        expect(details.length).to eql 4
+        expect(details[0]["name"]).to eql "TEMP1"
+        expect(details[1]["name"]).to eql "TEMP2"
+        expect(details[2]["name"]).to eql "TEMP3"
+        expect(details[3]["name"]).to eql "TEMP4"
       end
     end
 
     describe "get_out_of_limits" do
-      it "should return all out of limits items" do
+      it "returns all out of limits items" do
         items = @api.get_out_of_limits
         (0..3).each do |i|
-          items[i][0].should eql "INST"
-          items[i][1].should eql "HEALTH_STATUS"
-          items[i][2].should eql "TEMP#{i+1}"
-          items[i][3].should eql :RED_LOW
+          expect(items[i][0]).to eql "INST"
+          expect(items[i][1]).to eql "HEALTH_STATUS"
+          expect(items[i][2]).to eql "TEMP#{i+1}"
+          expect(items[i][3]).to eql :RED_LOW
         end
       end
     end
 
     describe "limits_enabled?" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.limits_enabled?("BLAH","HEALTH_STATUS","TEMP1") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.limits_enabled?("INST","BLAH","TEMP1") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.limits_enabled?("INST","HEALTH_STATUS","BLAH") }.to raise_error(RuntimeError, "Packet item 'INST HEALTH_STATUS BLAH' does not exist")
       end
 
-      it "should return whether limits are enable for an item" do
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_truthy
+      it "returns whether limits are enable for an item" do
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_truthy
       end
     end
 
     describe "enable_limits" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.enable_limits("BLAH","HEALTH_STATUS","TEMP1") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.enable_limits("INST","BLAH","TEMP1") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.enable_limits("INST","HEALTH_STATUS","BLAH") }.to raise_error(RuntimeError, "Packet item 'INST HEALTH_STATUS BLAH' does not exist")
       end
 
-      it "should enable limits for an item" do
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_truthy
+      it "enables limits for an item" do
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_truthy
         @api.disable_limits("INST","HEALTH_STATUS","TEMP1")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_falsey
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_falsey
         @api.enable_limits("INST","HEALTH_STATUS","TEMP1")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_truthy
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_truthy
       end
     end
 
     describe "disable_limits" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.disable_limits("BLAH","HEALTH_STATUS","TEMP1") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.disable_limits("INST","BLAH","TEMP1") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.disable_limits("INST","HEALTH_STATUS","BLAH") }.to raise_error(RuntimeError, "Packet item 'INST HEALTH_STATUS BLAH' does not exist")
       end
 
-      it "should disable limits for an item" do
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_truthy
+      it "disables limits for an item" do
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_truthy
         @api.disable_limits("INST","HEALTH_STATUS","TEMP1")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_falsey
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_falsey
         @api.enable_limits("INST","HEALTH_STATUS","TEMP1")
       end
     end
 
     describe "get_limits" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.get_limits("BLAH","HEALTH_STATUS","TEMP1") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.get_limits("INST","BLAH","TEMP1") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.get_limits("INST","HEALTH_STATUS","BLAH") }.to raise_error(RuntimeError, "Packet item 'INST HEALTH_STATUS BLAH' does not exist")
       end
 
-      it "should get limits for an item" do
-        @api.get_limits("INST","HEALTH_STATUS","TEMP1").should eql([:DEFAULT, 1, true, -80.0, -70.0, 60.0, 80.0, -20.0, 20.0])
-        @api.get_limits("INST","HEALTH_STATUS","TEMP1",:TVAC).should eql([:TVAC, 1, true, -80.0, -30.0, 30.0, 80.0, nil, nil])
+      it "gets limits for an item" do
+        expect(@api.get_limits("INST","HEALTH_STATUS","TEMP1")).to eql([:DEFAULT, 1, true, -80.0, -70.0, 60.0, 80.0, -20.0, 20.0])
+        expect(@api.get_limits("INST","HEALTH_STATUS","TEMP1",:TVAC)).to eql([:TVAC, 1, true, -80.0, -30.0, 30.0, 80.0, nil, nil])
       end
     end
 
     describe "set_limits" do
-      it "should complain about non-existant targets" do
+      it "complains about non-existant targets" do
         expect { @api.set_limits("BLAH","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0) }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
       end
 
-      it "should complain about non-existant packets" do
+      it "complains about non-existant packets" do
         expect { @api.set_limits("INST","BLAH","TEMP1",0.0,10.0,20.0,30.0) }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
       end
 
-      it "should complain about non-existant items" do
+      it "complains about non-existant items" do
         expect { @api.set_limits("INST","HEALTH_STATUS","BLAH",0.0,10.0,20.0,30.0) }.to raise_error(RuntimeError, "Packet item 'INST HEALTH_STATUS BLAH' does not exist")
       end
 
-      it "should get limits for an item" do
-        @api.set_limits("INST","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0).should eql([:CUSTOM, 1, true, 0.0, 10.0, 20.0, 30.0, nil, nil])
-        @api.set_limits("INST","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0,12.0,15.0,:CUSTOM2,2,false).should eql([:CUSTOM2, 2, false, 0.0, 10.0, 20.0, 30.0, 12.0, 15.0])
-        @api.set_limits("INST","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0,12.0,15.0,:CUSTOM,1,true).should eql([:CUSTOM, 1, true, 0.0, 10.0, 20.0, 30.0, 12.0, 15.0])
+      it "gets limits for an item" do
+        expect(@api.set_limits("INST","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0)).to eql([:CUSTOM, 1, true, 0.0, 10.0, 20.0, 30.0, nil, nil])
+        expect(@api.set_limits("INST","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0,12.0,15.0,:CUSTOM2,2,false)).to eql([:CUSTOM2, 2, false, 0.0, 10.0, 20.0, 30.0, 12.0, 15.0])
+        expect(@api.set_limits("INST","HEALTH_STATUS","TEMP1",0.0,10.0,20.0,30.0,12.0,15.0,:CUSTOM,1,true)).to eql([:CUSTOM, 1, true, 0.0, 10.0, 20.0, 30.0, 12.0, 15.0])
       end
     end
 
     describe "get_limits_groups" do
-      it "should return all the limits groups" do
-        @api.get_limits_groups.should eql %w(FIRST SECOND)
+      it "returns all the limits groups" do
+        expect(@api.get_limits_groups).to eql %w(FIRST SECOND)
       end
     end
 
     describe "enable_limits_group" do
-      it "should complain about undefined limits groups" do
+      it "complains about undefined limits groups" do
         expect { @api.enable_limits_group("MINE") }.to raise_error(RuntimeError, "LIMITS_GROUP MINE undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP MINE")
       end
 
-      it "should enable limits for all items in the group" do
+      it "enables limits for all items in the group" do
         @api.disable_limits("INST","HEALTH_STATUS","TEMP1")
         @api.disable_limits("INST","HEALTH_STATUS","TEMP3")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_falsey
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP3").should be_falsey
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_falsey
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP3")).to be_falsey
         @api.enable_limits_group("FIRST")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_truthy
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP3").should be_truthy
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_truthy
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP3")).to be_truthy
       end
     end
 
     describe "disable_limits_group" do
-      it "should complain about undefined limits groups" do
+      it "complains about undefined limits groups" do
         expect { @api.disable_limits_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
         @api.enable_limits("INST","HEALTH_STATUS","TEMP1")
         @api.enable_limits("INST","HEALTH_STATUS","TEMP3")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_truthy
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP3").should be_truthy
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_truthy
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP3")).to be_truthy
         @api.disable_limits_group("FIRST")
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP1").should be_falsey
-        @api.limits_enabled?("INST","HEALTH_STATUS","TEMP3").should be_falsey
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP1")).to be_falsey
+        expect(@api.limits_enabled?("INST","HEALTH_STATUS","TEMP3")).to be_falsey
       end
     end
 
     describe "get_limits_sets, get_limits_set, set_limits_set" do
-      it "should get and set the active limits set" do
+      it "gets and set the active limits set" do
         if @api.get_limits_sets.include?(:CUSTOM)
-          @api.get_limits_sets.should eql [:DEFAULT,:TVAC, :CUSTOM, :CUSTOM2]
+          expect(@api.get_limits_sets).to eql [:DEFAULT,:TVAC, :CUSTOM, :CUSTOM2]
         else
-          @api.get_limits_sets.should eql [:DEFAULT,:TVAC]
+          expect(@api.get_limits_sets).to eql [:DEFAULT,:TVAC]
         end
         @api.set_limits_set("TVAC")
-        @api.get_limits_set.should eql "TVAC"
+        expect(@api.get_limits_set).to eql "TVAC"
         @api.set_limits_set("DEFAULT")
-        @api.get_limits_set.should eql "DEFAULT"
+        expect(@api.get_limits_set).to eql "DEFAULT"
       end
     end
 
     describe "get_target_list" do
-      it "should return all target names" do
-        @api.get_target_list.should eql %w(COSMOS INST META SYSTEM)
+      it "returns all target names" do
+        expect(@api.get_target_list).to eql %w(COSMOS INST META SYSTEM)
       end
     end
 
     describe "subscribe_limits_events" do
-      it "should call CmdTlmServer" do
+      it "calls CmdTlmServer" do
         stub_const("Cosmos::CmdTlmServer::DEFAULT_LIMITS_EVENT_QUEUE_SIZE", 100)
         expect(CmdTlmServer).to receive(:subscribe_limits_events)
         @api.subscribe_limits_events
@@ -1019,21 +1019,21 @@ module Cosmos
     end
 
     describe "unsubscribe_limits_events" do
-      it "should call CmdTlmServer" do
+      it "calls CmdTlmServer" do
         expect(CmdTlmServer).to receive(:unsubscribe_limits_events)
         @api.unsubscribe_limits_events(0)
       end
     end
 
     describe "get_limits_event" do
-      it "should get a limits event" do
+      it "gets a limits event" do
         expect(CmdTlmServer).to receive(:get_limits_event)
         @api.get_limits_event(0)
       end
     end
 
     describe "subscribe_packet_data" do
-      it "should call CmdTlmServer" do
+      it "calls CmdTlmServer" do
         stub_const("Cosmos::CmdTlmServer::DEFAULT_PACKET_DATA_QUEUE_SIZE", 100)
         expect(CmdTlmServer).to receive(:subscribe_packet_data)
         @api.subscribe_packet_data([["TGT","PKT1"],["TGT","PKT2"]])
@@ -1041,14 +1041,14 @@ module Cosmos
     end
 
     describe "unsubscribe_packet_datas" do
-      it "should call CmdTlmServer" do
+      it "calls CmdTlmServer" do
         expect(CmdTlmServer).to receive(:unsubscribe_packet_data)
         @api.unsubscribe_packet_data(10)
       end
     end
 
     describe "get_packet_data" do
-      it "should call CmdTlmServer" do
+      it "calls CmdTlmServer" do
         expect(CmdTlmServer).to receive(:get_packet_data)
         @api.get_packet_data(10)
       end
@@ -1058,7 +1058,7 @@ module Cosmos
     # adding any functionality. Thus we just test that they are are received
     # by the CmdTlmServer.
     describe "CmdTlmServer pass-throughs" do
-      it "should call through to the CmdTlmServer" do
+      it "calls through to the CmdTlmServer" do
         @api.get_interface_names
         @api.connect_interface("INT")
         @api.disconnect_interface("INT")