cosmos 3.2.1 → 3.3.0

data/spec/tools/cmd_tlm_server/packet_logging_spec.rb

@@ -22,13 +22,13 @@ module Cosmos
     end
 
     describe "start" do
-      it "should start each log writer" do
+      it "starts each log writer" do
         tf = Tempfile.new('unittest')
         tf.puts '#'
         tf.close
         pl = PacketLogging.new(CmdTlmServerConfig.new(tf.path))
         default = pl.all['DEFAULT']
-        default.should be_a PacketLogWriterPair
+        expect(default).to be_a PacketLogWriterPair
         expect(default.cmd_log_writer).to receive(:start).with('LABEL')
         expect(default.tlm_log_writer).to receive(:start).with('LABEL')
         pl.start('ALL','LABEL')
@@ -37,13 +37,13 @@ module Cosmos
     end
 
     describe "stop" do
-      it "should stop each log writer" do
+      it "stops each log writer" do
         tf = Tempfile.new('unittest')
         tf.puts '#'
         tf.close
         pl = PacketLogging.new(CmdTlmServerConfig.new(tf.path))
         default = pl.all['DEFAULT']
-        default.should be_a PacketLogWriterPair
+        expect(default).to be_a PacketLogWriterPair
         expect(default.cmd_log_writer).to receive(:stop)
         expect(default.tlm_log_writer).to receive(:stop)
         pl.stop
@@ -52,7 +52,7 @@ module Cosmos
     end
 
     describe "start_cmd, stop_cmd" do
-      it "should complain about unknown log writers" do
+      it "complains about unknown log writers" do
         tf = Tempfile.new('unittest')
         tf.puts '#'
         tf.close
@@ -62,13 +62,13 @@ module Cosmos
         tf.unlink
       end
 
-      it "should start/stop a telemetry log writer" do
+      it "starts/stop a telemetry log writer" do
         tf = Tempfile.new('unittest')
         tf.puts 'PACKET_LOG_WRITER MY_WRITER packet_log_writer.rb'
         tf.close
         pl = PacketLogging.new(CmdTlmServerConfig.new(tf.path))
         mine = pl.all['MY_WRITER']
-        mine.should be_a PacketLogWriterPair
+        expect(mine).to be_a PacketLogWriterPair
         expect(mine.cmd_log_writer).to receive(:start).with('LABEL')
         pl.start_cmd('MY_WRITER','LABEL')
         expect(mine.cmd_log_writer).to receive(:stop)
@@ -78,7 +78,7 @@ module Cosmos
     end
 
     describe "start_tlm, stop_tlm" do
-      it "should complain about unknown log writers" do
+      it "complains about unknown log writers" do
         tf = Tempfile.new('unittest')
         tf.puts '#'
         tf.close
@@ -88,13 +88,13 @@ module Cosmos
         tf.unlink
       end
 
-      it "should start/stop a telemetry log writer" do
+      it "starts/stop a telemetry log writer" do
         tf = Tempfile.new('unittest')
         tf.puts 'PACKET_LOG_WRITER MY_WRITER packet_log_writer.rb'
         tf.close
         pl = PacketLogging.new(CmdTlmServerConfig.new(tf.path))
         mine = pl.all['MY_WRITER']
-        mine.should be_a PacketLogWriterPair
+        expect(mine).to be_a PacketLogWriterPair
         expect(mine.tlm_log_writer).to receive(:start).with('LABEL')
         pl.start_tlm('MY_WRITER','LABEL')
         expect(mine.tlm_log_writer).to receive(:stop)
@@ -104,7 +104,7 @@ module Cosmos
     end
 
     describe "cmd_filename, tlm_filename" do
-      it "should complain about unknown log writers" do
+      it "complains about unknown log writers" do
         tf = Tempfile.new('unittest')
         tf.puts '#'
         tf.close
@@ -114,28 +114,28 @@ module Cosmos
         tf.unlink
       end
 
-      it "should return the filename" do
+      it "returns the filename" do
         tf = Tempfile.new('unittest')
         tf.puts '#'
         tf.close
         pl = PacketLogging.new(CmdTlmServerConfig.new(tf.path))
         default = pl.all['DEFAULT']
-        default.should be_a PacketLogWriterPair
+        expect(default).to be_a PacketLogWriterPair
         expect(default.cmd_log_writer).to receive(:filename).and_return("test_file")
-        pl.cmd_filename("DEFAULT").should eql "test_file"
+        expect(pl.cmd_filename("DEFAULT")).to eql "test_file"
         expect(default.tlm_log_writer).to receive(:filename).and_return("test_file")
-        pl.tlm_filename("DEFAULT").should eql "test_file"
+        expect(pl.tlm_filename("DEFAULT")).to eql "test_file"
         tf.unlink
       end
     end
 
     describe "all"
-      it "should list all telemetry log writer pairs" do
+      it "lists all telemetry log writer pairs" do
         tf = Tempfile.new('unittest')
         tf.puts 'PACKET_LOG_WRITER MY_WRITER packet_log_writer.rb'
         tf.close
         pl = PacketLogging.new(CmdTlmServerConfig.new(tf.path))
-        pl.all.keys.should eql %w(DEFAULT MY_WRITER)
+        expect(pl.all.keys).to eql %w(DEFAULT MY_WRITER)
         tf.unlink
       end
   end

data/spec/tools/cmd_tlm_server/router_thread_spec.rb

@@ -39,11 +39,11 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.5
-          Thread.list.length.should eql(1)
-          stdout.string.should match "disconnected interface"
+          expect(Thread.list.length).to eql(1)
+          expect(stdout.string).to match "disconnected interface"
         end
       end
 
@@ -57,11 +57,11 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.5
-          Thread.list.length.should eql(1)
-          stdout.string.should match "Error routing command"
+          expect(Thread.list.length).to eql(1)
+          expect(stdout.string).to match "Error routing command"
         end
       end
 
@@ -81,11 +81,11 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.5
-          Thread.list.length.should eql(1)
-          stdout.string.should match "Received unknown identified command: BOB SMITH"
+          expect(Thread.list.length).to eql(1)
+          expect(stdout.string).to match "Received unknown identified command: BOB SMITH"
         end
       end
 
@@ -109,11 +109,11 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.5
-          Thread.list.length.should eql(1)
-          stdout.string.should match "Received unknown identified command: BOB SMITH"
+          expect(Thread.list.length).to eql(1)
+          expect(stdout.string).to match "Received unknown identified command: BOB SMITH"
         end
         expect(target).to have_received(:interface).twice #and_return(@interface)
       end
@@ -138,11 +138,11 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          Thread.list.length.should eql(2)
+          expect(Thread.list.length).to eql(2)
           thread.stop
           sleep 0.5
-          Thread.list.length.should eql(1)
-          stdout.string.should match "target with no interface"
+          expect(Thread.list.length).to eql(1)
+          expect(stdout.string).to match "target with no interface"
         end
       end
     end

data/spec/tools/cmd_tlm_server/routers_spec.rb

@@ -21,7 +21,7 @@ module Cosmos
     end
 
     describe "start" do
-      it "should connect each router" do
+      it "connects each router" do
         tf = Tempfile.new('unittest')
         tf.puts 'ROUTER MY_ROUTER interface.rb'
         tf.close
@@ -37,7 +37,7 @@ module Cosmos
           routers.all['MY_ROUTER'].connect_on_startup = true
           routers.start
 
-          stdout.string.should match "Creating thread for router MY_ROUTER"
+          expect(stdout.string).to match "Creating thread for router MY_ROUTER"
           routers.stop
         end
         tf.unlink
@@ -46,7 +46,7 @@ module Cosmos
     end
 
     describe "stop" do
-      it "should disconnect each router" do
+      it "disconnects each router" do
         tf = Tempfile.new('unittest')
         tf.puts 'ROUTER MY_ROUTER interface.rb'
         tf.close
@@ -61,13 +61,13 @@ module Cosmos
           routers.all['MY_ROUTER'].connect_on_startup = true
           routers.start
           sleep 0.1
-          routers.state("MY_ROUTER").should eql "ATTEMPTING"
-          routers.state("MY_ROUTER").should eql "CONNECTED"
+          expect(routers.state("MY_ROUTER")).to eql "ATTEMPTING"
+          expect(routers.state("MY_ROUTER")).to eql "CONNECTED"
           routers.stop
           sleep 0.1
-          routers.state("MY_ROUTER").should eql "DISCONNECTED"
+          expect(routers.state("MY_ROUTER")).to eql "DISCONNECTED"
 
-          stdout.string.should match "Disconnected from router MY_ROUTER"
+          expect(stdout.string).to match "Disconnected from router MY_ROUTER"
         end
         tf.unlink
         sleep(0.2)
@@ -75,29 +75,29 @@ module Cosmos
     end
 
     describe "add_preidentified" do
-      it "should add a preidentified router to all interfaces" do
+      it "adds a preidentified router to all interfaces" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE DEST1 tcpip_client_interface.rb localhost 8888 8888 5 5 burst'
         tf.puts 'INTERFACE DEST2 tcpip_client_interface.rb localhost 8888 8888 5 5 burst'
         tf.close
         config = CmdTlmServerConfig.new(tf.path)
-        config.interfaces.keys.should eql %w(DEST1 DEST2)
-        config.interfaces['DEST1'].routers.should be_empty
-        config.interfaces['DEST2'].routers.should be_empty
+        expect(config.interfaces.keys).to eql %w(DEST1 DEST2)
+        expect(config.interfaces['DEST1'].routers).to be_empty
+        expect(config.interfaces['DEST2'].routers).to be_empty
 
         routers = Routers.new(config)
-        routers.all.keys.should be_empty
+        expect(routers.all.keys).to be_empty
         routers.add_preidentified("PRE", 9999)
-        routers.all.keys.should eql %w(PRE)
+        expect(routers.all.keys).to eql %w(PRE)
 
-        config.interfaces['DEST1'].routers[0].name.should eql "PRE"
-        config.interfaces['DEST2'].routers[0].name.should eql "PRE"
+        expect(config.interfaces['DEST1'].routers[0].name).to eql "PRE"
+        expect(config.interfaces['DEST2'].routers[0].name).to eql "PRE"
         tf.unlink
       end
     end
 
     describe "recreate" do
-      it "should complain about unknown routers" do
+      it "complains about unknown routers" do
         tf = Tempfile.new('unittest')
         tf.puts 'ROUTER MY_ROUTER interface.rb'
         tf.close
@@ -108,7 +108,7 @@ module Cosmos
     end
 
     describe "connect" do
-      it "should complain about unknown routers" do
+      it "complains about unknown routers" do
         tf = Tempfile.new('unittest')
         tf.puts 'ROUTER MY_ROUTER interface.rb'
         tf.close
@@ -117,7 +117,7 @@ module Cosmos
         tf.unlink
       end
 
-      it "should connect a router" do
+      it "connects a router" do
         tf = Tempfile.new('unittest')
         tf.puts 'INTERFACE DEST1 tcpip_client_interface.rb localhost 8888 8888 5 5 burst'
         tf.puts 'INTERFACE DEST2 tcpip_client_interface.rb localhost 8888 8888 5 5 burst'
@@ -150,22 +150,22 @@ module Cosmos
 
           config = CmdTlmServerConfig.new(tf.path)
           routers = Routers.new(config)
-          routers.all["MY_ROUTER"].interfaces[0].name.should eql "DEST1"
-          routers.all["MY_ROUTER"].interfaces[1].name.should eql "DEST2"
-          config.interfaces['DEST1'].routers[0].name.should eql "MY_ROUTER"
-          config.interfaces['DEST2'].routers[0].name.should eql "MY_ROUTER"
+          expect(routers.all["MY_ROUTER"].interfaces[0].name).to eql "DEST1"
+          expect(routers.all["MY_ROUTER"].interfaces[1].name).to eql "DEST2"
+          expect(config.interfaces['DEST1'].routers[0].name).to eql "MY_ROUTER"
+          expect(config.interfaces['DEST2'].routers[0].name).to eql "MY_ROUTER"
           routers.connect("MY_ROUTER")
           sleep 0.1
-          stdout.string.should match "Connecting to MY_ROUTER"
+          expect(stdout.string).to match "Connecting to MY_ROUTER"
           routers.disconnect("MY_ROUTER")
           routers.connect("MY_ROUTER",'localhost',8888,8888,6,6,'length')
           sleep 0.1
-          stdout.string.should match "Disconnected from router MY_ROUTER"
-          stdout.string.should match "Connecting to MY_ROUTER"
-          routers.all["MY_ROUTER"].interfaces[0].name.should eql "DEST1"
-          routers.all["MY_ROUTER"].interfaces[1].name.should eql "DEST2"
-          config.interfaces['DEST1'].routers[0].name.should eql "MY_ROUTER"
-          config.interfaces['DEST2'].routers[0].name.should eql "MY_ROUTER"
+          expect(stdout.string).to match "Disconnected from router MY_ROUTER"
+          expect(stdout.string).to match "Connecting to MY_ROUTER"
+          expect(routers.all["MY_ROUTER"].interfaces[0].name).to eql "DEST1"
+          expect(routers.all["MY_ROUTER"].interfaces[1].name).to eql "DEST2"
+          expect(config.interfaces['DEST1'].routers[0].name).to eql "MY_ROUTER"
+          expect(config.interfaces['DEST2'].routers[0].name).to eql "MY_ROUTER"
           routers.disconnect("MY_ROUTER")
           routers.stop
 
@@ -182,20 +182,20 @@ module Cosmos
     end
 
     describe "names" do
-      it "should list all the router names" do
+      it "lists all the router names" do
         tf = Tempfile.new('unittest')
         tf.puts 'ROUTER ROUTER1 interface.rb'
         tf.puts 'ROUTER ROUTER2 interface.rb'
         tf.puts 'ROUTER ROUTER3 interface.rb'
         tf.close
         routers = Routers.new(CmdTlmServerConfig.new(tf.path))
-        routers.names.should eql %w(ROUTER1 ROUTER2 ROUTER3)
+        expect(routers.names).to eql %w(ROUTER1 ROUTER2 ROUTER3)
         tf.unlink
       end
     end
 
     describe "clear_counters" do
-      it "should clear all router counters" do
+      it "clears all router counters" do
         tf = Tempfile.new('unittest')
         tf.puts 'ROUTER ROUTER1 interface.rb'
         tf.puts 'ROUTER ROUTER2 interface.rb'
@@ -210,10 +210,10 @@ module Cosmos
         end
         routers.clear_counters
         routers.all.each do |name, router|
-          router.bytes_written.should eql 0
-          router.bytes_read.should eql 0
-          router.write_count.should eql 0
-          router.read_count.should eql 0
+          expect(router.bytes_written).to eql 0
+          expect(router.bytes_read).to eql 0
+          expect(router.write_count).to eql 0
+          expect(router.read_count).to eql 0
         end
         tf.unlink
       end

data/spec/top_level/top_level_spec.rb

@@ -13,16 +13,16 @@ require 'cosmos/top_level'
 require 'fileutils'
 
 describe "HazardousError" do
-  it "should have accessors" do
+  it "has accessors" do
     error = HazardousError.new
     error.target_name = "TGT"
-    error.target_name.should eql "TGT"
+    expect(error.target_name).to eql "TGT"
     error.cmd_name = "CMD"
-    error.cmd_name.should eql "CMD"
+    expect(error.cmd_name).to eql "CMD"
     error.cmd_params = ["ID","BLAH"]
-    error.cmd_params.should eql ["ID","BLAH"]
+    expect(error.cmd_params).to eql ["ID","BLAH"]
     error.hazardous_description = "Description"
-    error.hazardous_description.should eql "Description"
+    expect(error.hazardous_description).to eql "Description"
   end
 end
 
@@ -34,18 +34,18 @@ module Cosmos
   end
 
   describe "FatalError" do
-    it "should be a StandardError" do
-      FatalError.new.should be_a StandardError
+    it "is a StandardError" do
+      expect(FatalError.new).to be_a StandardError
     end
   end
 
   describe "self.disable_warnings" do
-    it "should disable Ruby warnings" do
+    it "disables Ruby warnings" do
       stderr = StringIO.new('', 'r+')
       $stderr = stderr
       save = Cosmos::PATH
       Cosmos::PATH = "HI"
-      stderr.string.should match /warning\: already initialized constant/
+      expect(stderr.string).to match /warning\: already initialized constant/
       Cosmos::PATH = save
 
       save_mutex = Cosmos::COSMOS_MUTEX
@@ -53,7 +53,7 @@ module Cosmos
         Cosmos::COSMOS_MUTEX = "HI"
         Cosmos::COSMOS_MUTEX = save_mutex
       end
-      stderr.string.should_not match "warning: already initialized constant COSMOS_MUTEX"
+      expect(stderr.string).not_to match "warning: already initialized constant COSMOS_MUTEX"
       $stderr = STDERR
     end
   end
@@ -66,35 +66,35 @@ module Cosmos
       ENV.delete('COSMOS_USERPATH')
     end
 
-    it "should be initially set" do
-      Cosmos::USERPATH.should_not be_nil
+    it "is initially set" do
+      expect(Cosmos::USERPATH).not_to be_nil
     end
 
     context "when searching for userpath.txt" do
-      it "should giveup if it can't be found" do
+      it "giveups if it can't be found" do
         old = Cosmos::USERPATH
         Cosmos.define_user_path(Dir.home)
-        Cosmos::USERPATH.should eql old
+        expect(Cosmos::USERPATH).to eql old
       end
 
-      it "should set the path to where userpath.txt is found" do
+      it "sets the path to where userpath.txt is found" do
         ENV.delete('COSMOS_USERPATH')
         old = Cosmos::USERPATH
-        old.should_not eql File.dirname(__FILE__)
+        expect(old).not_to eql File.dirname(__FILE__)
         File.open(File.join(File.dirname(__FILE__), 'userpath.txt'),'w') {|f| f.puts '' }
         Cosmos.define_user_path(File.dirname(__FILE__))
-        Cosmos::USERPATH.should eql File.dirname(__FILE__)
+        expect(Cosmos::USERPATH).to eql File.dirname(__FILE__)
         File.delete(File.join(File.dirname(__FILE__), 'userpath.txt'))
       end
     end
   end
 
   describe "self.add_to_search_path" do
-    it "should add a directory to the Ruby search path" do
+    it "adds a directory to the Ruby search path" do
       if Kernel.is_windows?
-        $:.should_not include("C:/test/path")
+        expect($:).not_to include("C:/test/path")
         Cosmos.add_to_search_path("C:/test/path")
-        $:.should include("C:/test/path")
+        expect($:).to include("C:/test/path")
       end
     end
   end
@@ -107,7 +107,7 @@ module Cosmos
       ENV.delete('COSMOS_USERPATH')
     end
 
-    it "should dump and load a Ruby object" do
+    it "dumps and load a Ruby object" do
       capture_io do |stdout|
         # Configure the user path to be local
         ENV['COSMOS_USERPATH'] = File.dirname(__FILE__)
@@ -116,29 +116,29 @@ module Cosmos
         array = [1,2,3,4]
         Cosmos.marshal_dump('marshal_test', array)
         array_load = Cosmos.marshal_load('marshal_test')
-        File.exist?(File.join(Cosmos::USERPATH,'marshal_test')).should be_truthy
-        array.should eql array_load
+        expect(File.exist?(File.join(Cosmos::USERPATH,'marshal_test'))).to be_truthy
+        expect(array).to eql array_load
         File.delete(File.join(Cosmos::USERPATH,'marshal_test'))
       end
     end
 
-    it "should rescue marshal dump errors" do
+    it "rescues marshal dump errors" do
       capture_io do |stdout|
         system_exit_count = $system_exit_count
         Cosmos.marshal_dump('marshal_test', Proc.new { '' })
-        $system_exit_count.should be > system_exit_count
-        stdout.string.should match "no _dump_data is defined for class Proc"
+        expect($system_exit_count).to be > system_exit_count
+        expect(stdout.string).to match "no _dump_data is defined for class Proc"
       end
       Cosmos.cleanup_exceptions()
     end
 
-    it "should rescue marshal load errors" do
+    it "rescues marshal load errors" do
       # Attempt to load something that doesn't exist
-      Cosmos.marshal_load('blah').should be_nil
+      expect(Cosmos.marshal_load('blah')).to be_nil
 
       # Attempt to load something that doesn't have the marshal header
       File.open(File.join(Cosmos::USERPATH,'marshal_test'),'wb') {|f| f.puts "marshal!" }
-      Cosmos.marshal_load('marshal_test').should be_nil
+      expect(Cosmos.marshal_load('marshal_test')).to be_nil
 
       # Attempt to load something that has a bad marshal
       File.open(File.join(Cosmos::USERPATH,'marshal_test'),'wb') do |file|
@@ -148,29 +148,29 @@ module Cosmos
 
       capture_io do |stdout|
         Cosmos.marshal_load('marshal_test')
-        stdout.string.should match "Marshal load failed with exception"
+        expect(stdout.string).to match "Marshal load failed with exception"
       end
       Cosmos.cleanup_exceptions()
     end
   end
 
   describe "run_process" do
-    it "should return a Thread" do
+    it "returns a Thread" do
       if Kernel.is_windows?
         capture_io do |stdout|
           thread = Cosmos.run_process("ping 192.0.0.234 -n 1 -w 1000 > nul")
           sleep 0.1
-          thread.should be_a Thread
-          thread.alive?.should be_truthy
+          expect(thread).to be_a Thread
+          expect(thread.alive?).to be_truthy
           sleep 2
-          thread.alive?.should be_falsey
+          expect(thread.alive?).to be_falsey
         end
       end
     end
   end
 
   describe "run_process_check_output" do
-    it "should execute a command while capturing output" do
+    it "executes a command while capturing output" do
       if Kernel.is_windows?
         require 'Qt'
         allow(::Qt::Application).to receive(:instance).and_return(nil)
@@ -178,27 +178,27 @@ module Cosmos
         allow(Logger).to receive(:error) {|str| output = str}
         thread = Cosmos.run_process_check_output("ping 192.0.0.234 -n 1 -w 1000")
         sleep 0.1 while thread.alive?
-        output.should match "Pinging 192.0.0.234"
+        expect(output).to match "Pinging 192.0.0.234"
       end
     end
   end
 
   describe "md5_files" do
-    it "should calculate a MD5 sum across files" do
+    it "calculates a MD5 sum across files" do
       File.open(File.join(Cosmos::USERPATH,'test1.txt'),'w') {|f| f.puts "test1" }
       File.open(File.join(Cosmos::USERPATH,'test2.txt'),'w') {|f| f.puts "test2" }
       digest = Cosmos.md5_files(["test1.txt", "test2.txt"])
-      digest.digest.length.should be 16
-      digest.hexdigest.should eql 'e51dfbea83de9c7e6b49560089d8a170'
+      expect(digest.digest.length).to be 16
+      expect(digest.hexdigest).to eql 'e51dfbea83de9c7e6b49560089d8a170'
       File.delete(File.join(Cosmos::USERPATH, 'test1.txt'))
       File.delete(File.join(Cosmos::USERPATH, 'test2.txt'))
     end
   end
 
   describe "create_log_file" do
-    it "should create a log file even if System LOGS doesn't exist" do
+    it "creates a log file even if System LOGS doesn't exist" do
       filename = Cosmos.create_log_file('test', 'X:/directory/which/does/not/exit')
-      File.exist?(filename).should be_truthy
+      expect(File.exist?(filename)).to be_truthy
       File.delete(filename)
 
       Cosmos.set_working_dir do
@@ -220,13 +220,13 @@ module Cosmos
         # Create a logs directory as the first order backup
         FileUtils.mkdir('logs')
         filename = Cosmos.create_log_file('test', 'X:/directory/which/does/not/exit')
-        File.exist?(filename).should be_truthy
+        expect(File.exist?(filename)).to be_truthy
         File.delete(filename)
 
         # Delete logs and see if we still get a log file
         FileUtils.rm_rf('logs')
         filename = Cosmos.create_log_file('test', 'X:/directory/which/does/not/exit')
-        File.exist?(filename).should be_truthy
+        expect(File.exist?(filename)).to be_truthy
         File.delete(filename)
 
         # Restore outputs
@@ -236,55 +236,55 @@ module Cosmos
   end
 
   describe "write_exception_file" do
-    it "should write an exception file" do
+    it "writes an exception file" do
       file = Cosmos.write_exception_file(nil, 'test1_exception', File.dirname(__FILE__))
-      File.exist?(file).should be_truthy
+      expect(File.exist?(file)).to be_truthy
       file = Cosmos.write_exception_file(RuntimeError.new, 'test2_exception', File.dirname(__FILE__))
-      File.exist?(file).should be_truthy
+      expect(File.exist?(file)).to be_truthy
       Cosmos.cleanup_exceptions()
     end
   end
 
   describe "catch_fatal_exception" do
-    it "should catch exceptions before the GUI is available" do
+    it "catches exceptions before the GUI is available" do
       capture_io do |stdout|
         system_exit_count = $system_exit_count
         Cosmos.catch_fatal_exception do
           raise "AHHH!!!"
         end
-        $system_exit_count.should eql(system_exit_count + 1)
-        stdout.string.should match "Fatal Exception! Exiting..."
+        expect($system_exit_count).to eql(system_exit_count + 1)
+        expect(stdout.string).to match "Fatal Exception! Exiting..."
       end
       Cosmos.cleanup_exceptions()
     end
   end
 
   describe "handle_fatal_exception" do
-    it "should write to the Logger and exit" do
+    it "writes to the Logger and exit" do
       capture_io do |stdout|
         system_exit_count = $system_exit_count
         Cosmos.handle_fatal_exception(RuntimeError.new)
-        $system_exit_count.should eql(system_exit_count + 1)
-        stdout.string.should match "Fatal Exception! Exiting..."
+        expect($system_exit_count).to eql(system_exit_count + 1)
+        expect(stdout.string).to match "Fatal Exception! Exiting..."
       end
       Cosmos.cleanup_exceptions()
     end
   end
 
   describe "handle_critical_exception" do
-    it "should write to the Logger" do
+    it "writes to the Logger" do
       capture_io do |stdout|
         system_exit_count = $system_exit_count
         Cosmos.handle_critical_exception(RuntimeError.new)
-        $system_exit_count.should eql(system_exit_count)
-        stdout.string.should match "Critical Exception!"
+        expect($system_exit_count).to eql(system_exit_count)
+        expect(stdout.string).to match "Critical Exception!"
       end
       Cosmos.cleanup_exceptions()
     end
   end
 
   describe "safe_thread" do
-    it "should handle exceptions" do
+    it "handles exceptions" do
       capture_io do |stdout|
         thread = Cosmos.safe_thread("Test", 1) do
           raise "TestError"
@@ -292,7 +292,7 @@ module Cosmos
         def thread.graceful_kill
         end
         sleep 1
-        stdout.string.should match "Test thread unexpectedly died."
+        expect(stdout.string).to match "Test thread unexpectedly died."
         Cosmos.kill_thread(thread, thread)
       end
       Cosmos.cleanup_exceptions()
@@ -300,7 +300,7 @@ module Cosmos
   end
 
   describe "require_class" do
-    it "should require the class represented by the filename" do
+    it "requires the class represented by the filename" do
       # Explicitly load cosmos.rb to ensure the Cosmos::USERPATH/lib
       # directory is in the path
       load 'cosmos.rb'
@@ -318,14 +318,14 @@ module Cosmos
   end
 
   describe "open_in_text_editor" do
-    it "should open the file in a text editor" do
+    it "opens the file in a text editor" do
       expect(Cosmos).to receive(:system).with(/#{File.basename(__FILE__)}/)
       Cosmos.open_in_text_editor(__FILE__)
     end
   end
 
   describe "open_in_web_browser" do
-    it "should open the file in a web browser" do
+    it "opens the file in a web browser" do
       expect(Cosmos).to receive(:system).with(/#{File.basename(__FILE__)}/)
       Cosmos.open_in_web_browser(__FILE__)
     end