cosmos 3.2.1 → 3.3.0

data/spec/spec_helper.rb

@@ -91,7 +91,7 @@ RSpec.configure do |config|
 
   config.after(:each) do
     # Make sure we didn't leave any lingering threads
-    Thread.list.length.should eql(1)
+    expect(Thread.list.length).to eql(1)
   end
 end
 
@@ -132,23 +132,54 @@ def capture_io
 end
 
 RSpec.configure do |c|
-  c.around(:each) do |example|
-    if ENV.key?("PROFILE")
-      klass = example.metadata[:example_group][:example_group][:description_args][0].to_s.gsub(/::/,'')
-      method = example.metadata[:description_args][0].to_s.gsub!(/ /,'_')
+  if ENV.key?("PROFILE")
+    c.before(:suite) do
       RubyProf.start
+    end
+    c.after(:suite) do |example|
+      result = RubyProf.stop
+      ignore = [/BasicObject/]
+      # Get all the RSpec constants so we can ignore them
+      RSpec.constants.each do |constant|
+        if Object.const_get("RSpec::#{constant}").respond_to? :constants
+          Object.const_get("RSpec::#{constant}").constants.each {|sub| ignore << Regexp.new("RSpec::#{constant}::#{sub}") }
+        else
+          ignore << Regexp.new("RSpec::#{constant}")
+        end
+      end
+      # But don't ignore RSpec::Core::Runner because it's the root.
+      # Ignoring this causes "can't eliminate root method (RuntimeError)"
+      ignore.delete(Regexp.new("RSpec::Core::Runner"))
+
+      result.eliminate_methods!(ignore)
+      printer = RubyProf::GraphHtmlPrinter.new(result)
+      printer.print(File.open("profile.html", 'w+'), :min_percent => 1)
+    end
+    c.around(:each) do |example|
+      # Run each test 100 times to prevent startup issues from dominating
       100.times do
         example.run
       end
-      result = RubyProf.stop
-      result.eliminate_methods!([/RSpec/, /BasicObject/])
-      printer = RubyProf::GraphHtmlPrinter.new(result)
-      dir = "./profile/#{klass}"
-      FileUtils.mkdir_p(dir)
-      printer.print(File.open("#{dir}/#{method}.html", 'w+'), :min_percent => 2)
-    else
-      example.run
     end
   end
+# This code causes a new profile file to be created for each test case which is excessive and hard to read
+#  c.around(:each) do |example|
+#    if ENV.key?("PROFILE")
+#      klass = example.metadata[:example_group][:example_group][:description_args][0].to_s.gsub(/::/,'')
+#      method = example.metadata[:description_args][0].to_s.gsub!(/ /,'_')
+#      RubyProf.start
+#      100.times do
+#        example.run
+#      end
+#      result = RubyProf.stop
+#      result.eliminate_methods!([/RSpec/, /BasicObject/])
+#      printer = RubyProf::GraphHtmlPrinter.new(result)
+#      dir = "./profile/#{klass}"
+#      FileUtils.mkdir_p(dir)
+#      printer.print(File.open("#{dir}/#{method}.html", 'w+'), :min_percent => 2)
+#    else
+#      example.run
+#    end
+#  end
 end
 

data/spec/streams/burst_stream_protocol_spec.rb

@@ -16,15 +16,15 @@ module Cosmos
   describe BurstStreamProtocol do
 
     describe "initialize" do
-      it "should initialize attributes" do
+      it "initializes attributes" do
         bsp = BurstStreamProtocol.new
-        bsp.bytes_read.should eql 0
-        bsp.bytes_written.should eql 0
-        bsp.interface.should be_nil
-        bsp.stream.should be_nil
-        bsp.post_read_data_callback.should be_nil
-        bsp.post_read_packet_callback.should be_nil
-        bsp.pre_write_packet_callback.should be_nil
+        expect(bsp.bytes_read).to eql 0
+        expect(bsp.bytes_written).to eql 0
+        expect(bsp.interface).to be_nil
+        expect(bsp.stream).to be_nil
+        expect(bsp.post_read_data_callback).to be_nil
+        expect(bsp.post_read_packet_callback).to be_nil
+        expect(bsp.pre_write_packet_callback).to be_nil
       end
     end
   end

data/spec/streams/fixed_stream_protocol_spec.rb

@@ -27,19 +27,19 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should initialize attributes" do
-        @fsp.bytes_read.should eql 0
-        @fsp.bytes_written.should eql 0
-        @fsp.interface.should be_nil
-        @fsp.stream.should be_nil
-        @fsp.post_read_data_callback.should be_nil
-        @fsp.post_read_packet_callback.should be_nil
-        @fsp.pre_write_packet_callback.should be_nil
+      it "initializes attributes" do
+        expect(@fsp.bytes_read).to eql 0
+        expect(@fsp.bytes_written).to eql 0
+        expect(@fsp.interface).to be_nil
+        expect(@fsp.stream).to be_nil
+        expect(@fsp.post_read_data_callback).to be_nil
+        expect(@fsp.post_read_packet_callback).to be_nil
+        expect(@fsp.pre_write_packet_callback).to be_nil
       end
     end
 
     describe "read" do
-      it "should complain if no interface set" do
+      it "complains if no interface set" do
         class MyStream < Stream
           def connect; end
           def connected?; true; end
@@ -50,7 +50,7 @@ module Cosmos
         expect { @fsp.read }.to raise_error(/Interface required/)
       end
 
-      it "should read telemetry data from the stream" do
+      it "reads telemetry data from the stream" do
         class MyStream < Stream
           def connect; end
           def connected?; true; end
@@ -62,24 +62,24 @@ module Cosmos
         interface.target_names = %w(TEST COSMOS)
         @fsp.interface = interface
         packet = @fsp.read
-        packet.received_time.to_f.should be_within(0.1).of(Time.now.to_f)
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'VERSION'
+        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
+        expect(packet.target_name).to eql 'COSMOS'
+        expect(packet.packet_name).to eql 'VERSION'
         packet = @fsp.read
-        packet.received_time.to_f.should be_within(0.1).of(Time.now.to_f)
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'LIMITS_CHANGE'
+        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
+        expect(packet.target_name).to eql 'COSMOS'
+        expect(packet.packet_name).to eql 'LIMITS_CHANGE'
         packet = @fsp.read
-        packet.received_time.to_f.should be_within(0.1).of(Time.now.to_f)
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'VERSION'
+        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
+        expect(packet.target_name).to eql 'COSMOS'
+        expect(packet.packet_name).to eql 'VERSION'
         packet = @fsp.read
-        packet.received_time.to_f.should be_within(0.1).of(Time.now.to_f)
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'LIMITS_CHANGE'
+        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
+        expect(packet.target_name).to eql 'COSMOS'
+        expect(packet.packet_name).to eql 'LIMITS_CHANGE'
       end
 
-      it "should read command data from the stream" do
+      it "reads command data from the stream" do
         @fsp = FixedStreamProtocol.new(8, 0, '0x1ACFFC1D', false)
 
         $index = 0
@@ -102,9 +102,9 @@ module Cosmos
         interface.target_names = %w(TEST COSMOS)
         @fsp.interface = interface
         packet = @fsp.read
-        packet.received_time.to_f.should be_within(0.01).of(Time.now.to_f)
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'STARTLOGGING'
+        expect(packet.received_time.to_f).to be_within(0.01).of(Time.now.to_f)
+        expect(packet.target_name).to eql 'COSMOS'
+        expect(packet.packet_name).to eql 'STARTLOGGING'
       end
     end
 

data/spec/streams/length_stream_protocol_spec.rb

@@ -17,20 +17,20 @@ module Cosmos
 
   describe LengthStreamProtocol do
     describe "initialize" do
-      it "should initialize attributes" do
+      it "initializes attributes" do
         lsp = LengthStreamProtocol.new(1)
-        lsp.bytes_read.should eql 0
-        lsp.bytes_written.should eql 0
-        lsp.interface.should be_nil
-        lsp.stream.should be_nil
-        lsp.post_read_data_callback.should be_nil
-        lsp.post_read_packet_callback.should be_nil
-        lsp.pre_write_packet_callback.should be_nil
+        expect(lsp.bytes_read).to eql 0
+        expect(lsp.bytes_written).to eql 0
+        expect(lsp.interface).to be_nil
+        expect(lsp.stream).to be_nil
+        expect(lsp.post_read_data_callback).to be_nil
+        expect(lsp.post_read_packet_callback).to be_nil
+        expect(lsp.pre_write_packet_callback).to be_nil
       end
     end
 
     describe "read" do
-      it "should read BIG_ENDIAN length fields from the stream" do
+      it "reads BIG_ENDIAN length fields from the stream" do
         class MyStream < Stream
           def connect; end
           def connected?; true; end
@@ -56,7 +56,7 @@ module Cosmos
         $buffer1 = "\x00\x01\x00\x05"
         $buffer2 = "\x03\x04"
         packet = lsp.read
-        packet.buffer.length.should eql 6
+        expect(packet.buffer.length).to eql 6
 
         lsp = LengthStreamProtocol.new(16, # bit offset
                                         16, # bit size
@@ -68,7 +68,7 @@ module Cosmos
         $buffer1 = "\x00\x01\x00\x05"
         $buffer2 = "\x03\x04\x05\x06\x07\x08\x09"
         packet = lsp.read
-        packet.buffer.length.should eql 11
+        expect(packet.buffer.length).to eql 11
 
         lsp = LengthStreamProtocol.new(19, # bit offset
                                         5,  # bit size
@@ -80,7 +80,7 @@ module Cosmos
         $buffer1 = "\x00\x01\x05"
         $buffer2 = "\x03\x04"
         packet = lsp.read
-        packet.buffer.length.should eql 5
+        expect(packet.buffer.length).to eql 5
 
         lsp = LengthStreamProtocol.new(16, # bit offset
                                         16, # bit size
@@ -97,7 +97,7 @@ module Cosmos
         expect { packet = lsp.read }.to raise_error(RuntimeError, "Length value received larger than max_length: 65535 > 50")
       end
 
-      it "should read LITTLE_ENDIAN length fields from the stream" do
+      it "reads LITTLE_ENDIAN length fields from the stream" do
         class MyStream < Stream
           def connect; end
           def connected?; true; end
@@ -123,7 +123,7 @@ module Cosmos
         $buffer1 = "\x00\x01\x05\x00"
         $buffer2 = "\x03\x04"
         packet = lsp.read
-        packet.buffer.length.should eql 6
+        expect(packet.buffer.length).to eql 6
 
         lsp = LengthStreamProtocol.new(16, # bit offset
                                         16, # bit size
@@ -135,7 +135,7 @@ module Cosmos
         $buffer1 = "\x00\x01\x05\x00"
         $buffer2 = "\x03\x04\x05\x06\x07\x08\x09"
         packet = lsp.read
-        packet.buffer.length.should eql 11
+        expect(packet.buffer.length).to eql 11
 
         lsp = LengthStreamProtocol.new(19, # bit offset
                                         5,  # bit size
@@ -147,7 +147,7 @@ module Cosmos
         $buffer1 = "\x00\x01\x05"
         $buffer2 = "\x03\x04"
         packet = lsp.read
-        packet.buffer.length.should eql 5
+        expect(packet.buffer.length).to eql 5
 
         lsp = LengthStreamProtocol.new(16, # bit offset
                                         16, # bit size
@@ -166,7 +166,7 @@ module Cosmos
     end
 
     describe "write" do
-      it "should fill the length field and sync pattern if told to" do
+      it "fills the length field and sync pattern if told to" do
         class MyStream < Stream
           def connect; end
           @@written_data = nil
@@ -213,8 +213,8 @@ module Cosmos
         lsp.write(packet)
         # Since we discarded 2 leading bytes, they are put back in the final stream data
         # with the sync word and then then length is set to 0
-        MyStream.written_data.should eql("\xBA\x5E\xBA\x11\x00\x00")
-        packet.buffer.should eql("\x01\x02\x00\x00")
+        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\x00\x00")
+        expect(packet.buffer).to eql("\x01\x02\x00\x00")
 
         lsp = LengthStreamProtocol.new(32, # bit offset
                                         16, # bit size
@@ -234,8 +234,8 @@ module Cosmos
         # Since we discarded 4 leading bytes, they are put back in the final stream data
         # with the sync word and then then length is set to 1 followed by the
         # last two bytes in the buffer. The \x01\x02 get written over by the length.
-        MyStream.written_data.should eql("\xBA\x5E\xBA\x11\x00\x01\x03\x04")
-        packet.buffer.should eql("\x00\x01\x03\x04")
+        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\x00\x01\x03\x04")
+        expect(packet.buffer).to eql("\x00\x01\x03\x04")
 
         lsp = LengthStreamProtocol.new(32, # bit offset
                                         16, # bit size
@@ -254,8 +254,8 @@ module Cosmos
         lsp.write(packet)
         # Since we discarded 6 leading bytes, they are put back in the final stream data
         # with the sync word and then then length is set to 2 followed by the buffer data.
-        MyStream.written_data.should eql("\xBA\x5E\xBA\x11\x00\x02\x01\x02\x03\x04")
-        packet.buffer.should eql("\x01\x02\x03\x04")
+        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\x00\x02\x01\x02\x03\x04")
+        expect(packet.buffer).to eql("\x01\x02\x03\x04")
 
         lsp = LengthStreamProtocol.new(64, # bit offset
                                         32, # bit size
@@ -272,8 +272,8 @@ module Cosmos
         packet.buffer = "\x00\x00\x00\x00\x01\x02\x03\x04"
         lsp.write(packet)
         # Since we discarded 8 leading bytes, they are put back in the final stream data
-        MyStream.written_data.should eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
-        packet.buffer.should eql("\x00\x00\x00\x04\x01\x02\x03\x04")
+        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
+        expect(packet.buffer).to eql("\x00\x00\x00\x04\x01\x02\x03\x04")
 
         lsp = LengthStreamProtocol.new(64, # bit offset
                                         32, # bit size
@@ -290,8 +290,8 @@ module Cosmos
         packet.buffer = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04"
         lsp.write(packet)
         # Since we discarded 0 leading bytes, they are simply written over by the write call
-        MyStream.written_data.should eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
-        packet.buffer.should eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
+        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
+        expect(packet.buffer).to eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
       end
     end
 

data/spec/streams/preidentified_stream_protocol_spec.rb

@@ -26,7 +26,7 @@ module Cosmos
       clean_config()
     end
 
-    it "should handle receiving a bad packet length" do
+    it "handles receiving a bad packet length" do
       @psp = PreidentifiedStreamProtocol.new(nil, 5)
       pkt = System.telemetry.packet("COSMOS","VERSION")
       class MyStream < Stream
@@ -44,19 +44,19 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should initialize attributes" do
-        @psp.bytes_read.should eql 0
-        @psp.bytes_written.should eql 0
-        @psp.interface.should be_nil
-        @psp.stream.should be_nil
-        @psp.post_read_data_callback.should be_nil
-        @psp.post_read_packet_callback.should be_nil
-        @psp.pre_write_packet_callback.should be_nil
+      it "initializes attributes" do
+        expect(@psp.bytes_read).to eql 0
+        expect(@psp.bytes_written).to eql 0
+        expect(@psp.interface).to be_nil
+        expect(@psp.stream).to be_nil
+        expect(@psp.post_read_data_callback).to be_nil
+        expect(@psp.post_read_packet_callback).to be_nil
+        expect(@psp.pre_write_packet_callback).to be_nil
       end
     end
 
     describe "write" do
-      it "should create a packet header" do
+      it "creates a packet header" do
         pkt = System.telemetry.packet("COSMOS","VERSION")
         class MyStream < Stream
           def connect; end
@@ -69,25 +69,25 @@ module Cosmos
         time = Time.new(2020,1,31,12,15,30.5)
         pkt.received_time = time
         @psp.write(pkt)
-        $buffer[0..3].unpack('N')[0].should eql time.to_f.to_i
-        $buffer[4..7].unpack('N')[0].should eql 500000
+        expect($buffer[0..3].unpack('N')[0]).to eql time.to_f.to_i
+        expect($buffer[4..7].unpack('N')[0]).to eql 500000
         offset = 8
         tgt_name_length = $buffer[offset].unpack('C')[0]
         offset += 1 # for the length field
-        $buffer[offset...(offset+tgt_name_length)].should eql 'COSMOS'
+        expect($buffer[offset...(offset+tgt_name_length)]).to eql 'COSMOS'
         offset += tgt_name_length
         pkt_name_length = $buffer[offset].unpack('C')[0]
         offset += 1 # for the length field
-        $buffer[offset...(offset+pkt_name_length)].should eql 'VERSION'
+        expect($buffer[offset...(offset+pkt_name_length)]).to eql 'VERSION'
         offset += pkt_name_length
-        $buffer[offset..(offset+3)].unpack('N')[0].should eql pkt.buffer.length
+        expect($buffer[offset..(offset+3)].unpack('N')[0]).to eql pkt.buffer.length
         offset += 4
-        $buffer[offset..-1].should eql pkt.buffer
+        expect($buffer[offset..-1]).to eql pkt.buffer
       end
     end
 
     describe "read" do
-      it "should return a packet" do
+      it "returns a packet" do
         pkt = System.telemetry.packet("COSMOS","VERSION")
         pkt.write("PKT_ID", 1)
         pkt.write("COSMOS", "TEST")
@@ -103,16 +103,16 @@ module Cosmos
         pkt.received_time = time
         @psp.write(pkt)
         packet = @psp.read
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'VERSION'
-        packet.identified?.should be_truthy
-        packet.defined?.should be_falsey
+        expect(packet.target_name).to eql 'COSMOS'
+        expect(packet.packet_name).to eql 'VERSION'
+        expect(packet.identified?).to be_truthy
+        expect(packet.defined?).to be_falsey
 
         pkt2 = System.telemetry.update!("COSMOS","VERSION",packet.buffer)
-        pkt2.read('PKT_ID').should eql 1
-        pkt2.read('COSMOS').should eql 'TEST'
-        pkt2.identified?.should be_truthy
-        pkt2.defined?.should be_truthy
+        expect(pkt2.read('PKT_ID')).to eql 1
+        expect(pkt2.read('COSMOS')).to eql 'TEST'
+        expect(pkt2.identified?).to be_truthy
+        expect(pkt2.defined?).to be_truthy
       end
     end
 

data/spec/streams/serial_stream_spec.rb

@@ -15,46 +15,46 @@ module Cosmos
 
   describe SerialStream do
     describe "initialize" do
-      it "should complain if neither a read or write port given" do
+      it "complains if neither a read or write port given" do
         expect { SerialStream.new(nil,nil,9600,:EVEN,1,nil,nil) }.to raise_error("Either a write port or read port must be given")
       end
     end
 
     describe "connected?" do
-      it "should be connected when initialized" do
+      it "is connected when initialized" do
         driver = double("driver")
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
+        expect(ss.connected?).to be_truthy
       end
     end
 
     describe "read" do
-      it "should raise an error if no read port given" do
+      it "raises an error if no read port given" do
         driver = double("driver")
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
         expect { ss.read }.to raise_error("Attempt to read from write only stream")
       end
 
-      it "should call read from the driver" do
+      it "calls read from the driver" do
         driver = double("driver")
         expect(driver).to receive(:read).and_return 'test'
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
-        ss.read.should eql 'test'
+        expect(ss.read).to eql 'test'
       end
     end
 
     describe "write" do
-      it "should raise an error if no write port given" do
+      it "raises an error if no write port given" do
         driver = double("driver")
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
         expect { ss.write('') }.to raise_error("Attempt to write to read only stream")
       end
 
-      it "should call write from the driver" do
+      it "calls write from the driver" do
         driver = double("driver")
         expect(driver).to receive(:write).with('test')
         expect(SerialDriver).to receive(:new).and_return(driver)
@@ -64,44 +64,44 @@ module Cosmos
     end
 
     describe "disconnect" do
-      it "should close the write driver" do
+      it "closes the write driver" do
         driver = double("driver")
         expect(driver).to receive(:closed?).and_return(false)
         expect(driver).to receive(:close)
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
+        expect(ss.connected?).to be_truthy
         ss.disconnect
-        ss.connected?.should be_falsey
+        expect(ss.connected?).to be_falsey
       end
 
-      it "should close the read driver" do
+      it "closes the read driver" do
         driver = double("driver")
         expect(driver).to receive(:closed?).and_return(false)
         expect(driver).to receive(:close)
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
+        expect(ss.connected?).to be_truthy
         ss.disconnect
-        ss.connected?.should be_falsey
+        expect(ss.connected?).to be_falsey
       end
 
-      it "shouldn't close the driver twice" do
+      it "does not close the driver twice" do
         driver = double("driver")
         expect(driver).to receive(:closed?).and_return(false, true)
         expect(driver).to receive(:close).once
         expect(SerialDriver).to receive(:new).and_return(driver)
         ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
+        expect(ss.connected?).to be_truthy
         ss.disconnect
-        ss.connected?.should be_falsey
+        expect(ss.connected?).to be_falsey
         ss.disconnect
-        ss.connected?.should be_falsey
+        expect(ss.connected?).to be_falsey
       end
     end
 
     describe "connect" do
-      it "should support a connect method that does nothing" do
+      it "supports a connect method that does nothing" do
         driver = double("driver")
         expect(driver).to receive(:closed?).and_return(false)
         expect(driver).to receive(:close).once