cosmos 3.2.1 → 3.3.0

data/spec/conversions/conversion_spec.rb

@@ -16,14 +16,14 @@ module Cosmos
   describe Conversion do
 
     describe "call" do
-      it "should raise an exception" do
+      it "raises an exception" do
         expect { Conversion.new.call(0, 0, 0) }.to raise_error("call method must be defined by subclass")
       end
     end
 
     describe "to_s" do
-      it "should return a String" do
-        Conversion.new.to_s.should eql "Conversion"
+      it "returns a String" do
+        expect(Conversion.new.to_s).to eql "Conversion"
       end
     end
   end

data/spec/conversions/generic_conversion_spec.rb

@@ -16,28 +16,28 @@ module Cosmos
   describe GenericConversion do
 
     describe "initialize" do
-      it "should take code_to_eval, converted_type and converted_bit_size" do
+      it "takes code_to_eval, converted_type and converted_bit_size" do
         gc = GenericConversion.new("10 / 2",:UINT,8)
-        gc.code_to_eval.should eql "10 / 2"
-        gc.converted_type.should eql :UINT
-        gc.converted_bit_size.should eql 8
+        expect(gc.code_to_eval).to eql "10 / 2"
+        expect(gc.converted_type).to eql :UINT
+        expect(gc.converted_bit_size).to eql 8
       end
 
-      it "should complain about invalid converted_type" do
+      it "complains about invalid converted_type" do
         expect { GenericConversion.new("",:MINE,8) }.to raise_error("Invalid type MINE")
       end
     end
 
     describe "call" do
-      it "should call the code to eval and return the result" do
+      it "calls the code to eval and return the result" do
         gc = GenericConversion.new("10 / 2",:UINT,8)
-        gc.call(0,0,0).should eql 5
+        expect(gc.call(0,0,0)).to eql 5
       end
     end
 
     describe "to_s" do
-      it "should return the code to eval" do
-        GenericConversion.new("10 / 2").to_s.should eql "10 / 2"
+      it "returns the code to eval" do
+        expect(GenericConversion.new("10 / 2").to_s).to eql "10 / 2"
       end
     end
   end

data/spec/conversions/new_packet_log_conversion_spec.rb

@@ -17,21 +17,21 @@ module Cosmos
   describe NewPacketLogConversion do
 
     describe "call" do
-      it "should return the value given and call start_logging" do
+      it "returns the value given and call start_logging" do
         cmd_tlm_server = double("CmdTlmServer", :packet_logging => '')
         allow(CmdTlmServer).to receive(:instance).and_return(cmd_tlm_server)
         expect(cmd_tlm_server).to receive(:start_logging).with('ALL')
         conversion = NewPacketLogConversion.new('ALL')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
-        conversion.call(5,packet,packet.buffer).should eql 5
+        expect(conversion.call(5,packet,packet.buffer)).to eql 5
       end
     end
 
     describe "to_s" do
-      it "should return the conversion and packet_log_writer_name" do
+      it "returns the conversion and packet_log_writer_name" do
         conversion = NewPacketLogConversion.new('BOB')
-        conversion.to_s.should eql "NewPacketLogConversion (BOB)"
+        expect(conversion.to_s).to eql "NewPacketLogConversion (BOB)"
       end
     end
   end

data/spec/conversions/polynomial_conversion_spec.rb

@@ -16,23 +16,23 @@ module Cosmos
   describe PolynomialConversion do
 
     describe "initialize" do
-      it "should take a coefficents array" do
+      it "takes a coefficents array" do
         gc = PolynomialConversion.new([1,2,3])
-        gc.converted_type.should eql :FLOAT
-        gc.converted_bit_size.should eql 64
+        expect(gc.converted_type).to eql :FLOAT
+        expect(gc.converted_bit_size).to eql 64
       end
     end
 
     describe "call" do
-      it "should call the code to eval and return the result" do
+      it "calls the code to eval and return the result" do
         gc = PolynomialConversion.new([1,2,3])
-        gc.call(1,nil,nil).should eql 6.0
+        expect(gc.call(1,nil,nil)).to eql 6.0
       end
     end
 
     describe "to_s" do
-      it "should return the equation" do
-        PolynomialConversion.new([1,2,3]).to_s.should eql "1.0 + 2.0x + 3.0x^2"
+      it "returns the equation" do
+        expect(PolynomialConversion.new([1,2,3]).to_s).to eql "1.0 + 2.0x + 3.0x^2"
       end
     end
   end

data/spec/conversions/processor_conversion_spec.rb

@@ -16,28 +16,28 @@ module Cosmos
   describe PolynomialConversion do
 
     describe "initialize" do
-      it "should take processor_name, result_name, converted_type, and converted_bit_size" do
+      it "takes processor_name, result_name, converted_type, and converted_bit_size" do
         c = ProcessorConversion.new('TEST', 'TEST', 'FLOAT', '64')
-        c.instance_variable_get("@processor_name").should eql 'TEST'
-        c.instance_variable_get("@result_name").should eql :TEST
-        c.converted_type.should eql :FLOAT
-        c.converted_bit_size.should eql 64
+        expect(c.instance_variable_get("@processor_name")).to eql 'TEST'
+        expect(c.instance_variable_get("@result_name")).to eql :TEST
+        expect(c.converted_type).to eql :FLOAT
+        expect(c.converted_bit_size).to eql 64
       end
     end
 
     describe "call" do
-      it "should retrieve the result from the processor" do
+      it "retrieves the result from the processor" do
         c = ProcessorConversion.new('TEST', 'TEST', 'FLOAT', '64')
         packet = Packet.new("tgt","pkt")
         packet.append_item('ITEM1', 64, :FLOAT)
         packet.processors['TEST'] = double("processor", :results => {:TEST => 6.0})
-        c.call(1,packet,nil).should eql 6.0
+        expect(c.call(1,packet,nil)).to eql 6.0
       end
     end
 
     describe "to_s" do
-      it "should return the equation" do
-        ProcessorConversion.new('TEST1', 'TEST2', 'FLOAT', '64').to_s.should eql "ProcessorConversion TEST1 TEST2"
+      it "returns the equation" do
+        expect(ProcessorConversion.new('TEST1', 'TEST2', 'FLOAT', '64').to_s).to eql "ProcessorConversion TEST1 TEST2"
       end
     end
   end

data/spec/conversions/received_count_conversion_spec.rb

@@ -17,25 +17,25 @@ module Cosmos
   describe ReceivedCountConversion do
 
     describe "initialize" do
-      it "should initialize converted_type and converted_bit_size" do
+      it "initializes converted_type and converted_bit_size" do
         gc = ReceivedCountConversion.new()
-        gc.converted_type.should eql :UINT
-        gc.converted_bit_size.should eql 32
+        expect(gc.converted_type).to eql :UINT
+        expect(gc.converted_bit_size).to eql 32
       end
     end
 
     describe "call" do
-      it "should call the code to eval and return the result" do
+      it "calls the code to eval and return the result" do
         gc = ReceivedCountConversion.new()
         packet = Packet.new("TGT","PKT")
         packet.received_count = 100
-        gc.call(nil,packet,nil).should eql 100
+        expect(gc.call(nil,packet,nil)).to eql 100
       end
     end
 
     describe "to_s" do
-      it "should return the class" do
-        ReceivedCountConversion.new().to_s.should eql "ReceivedCountConversion"
+      it "returns the class" do
+        expect(ReceivedCountConversion.new().to_s).to eql "ReceivedCountConversion"
       end
     end
   end

data/spec/conversions/received_time_formatted_conversion_spec.rb

@@ -17,31 +17,31 @@ module Cosmos
   describe ReceivedTimeFormattedConversion do
 
     describe "initialize" do
-      it "should initialize converted_type and converted_bit_size" do
+      it "initializes converted_type and converted_bit_size" do
         gc = ReceivedTimeFormattedConversion.new()
-        gc.converted_type.should eql :STRING
-        gc.converted_bit_size.should eql 0
+        expect(gc.converted_type).to eql :STRING
+        expect(gc.converted_bit_size).to eql 0
       end
     end
 
     describe "call" do
-      it "should return the formatted packet time" do
+      it "returns the formatted packet time" do
         gc = ReceivedTimeFormattedConversion.new()
         packet = Packet.new("TGT","PKT")
         packet.received_time = Time.new(2020,1,31,12,15,30)
-        gc.call(nil,packet,nil).should eql "2020/01/31 12:15:30.000"
+        expect(gc.call(nil,packet,nil)).to eql "2020/01/31 12:15:30.000"
       end
 
-      it "should return a string if packet time isn't set" do
+      it "returns a string if packet time isn't set" do
         gc = ReceivedTimeFormattedConversion.new()
         packet = Packet.new("TGT","PKT")
-        gc.call(nil,packet,nil).should eql "No Packet Received Time"
+        expect(gc.call(nil,packet,nil)).to eql "No Packet Received Time"
       end
     end
 
     describe "to_s" do
-      it "should return the class" do
-        ReceivedTimeFormattedConversion.new().to_s.should eql "ReceivedTimeFormattedConversion"
+      it "returns the class" do
+        expect(ReceivedTimeFormattedConversion.new().to_s).to eql "ReceivedTimeFormattedConversion"
       end
     end
   end

data/spec/conversions/received_time_seconds_conversion_spec.rb

@@ -17,32 +17,32 @@ module Cosmos
   describe ReceivedTimeSecondsConversion do
 
     describe "initialize" do
-      it "should initialize converted_type and converted_bit_size" do
+      it "initializes converted_type and converted_bit_size" do
         gc = ReceivedTimeSecondsConversion.new()
-        gc.converted_type.should eql :FLOAT
-        gc.converted_bit_size.should eql 64
+        expect(gc.converted_type).to eql :FLOAT
+        expect(gc.converted_bit_size).to eql 64
       end
     end
 
     describe "call" do
-      it "should return the formatted packet time" do
+      it "returns the formatted packet time" do
         gc = ReceivedTimeSecondsConversion.new()
         packet = Packet.new("TGT","PKT")
         time = Time.new(2020,1,31,12,15,30)
         packet.received_time = time
-        gc.call(nil,packet,nil).should eql time.to_f
+        expect(gc.call(nil,packet,nil)).to eql time.to_f
       end
 
-      it "should return 0.0 if packet time isn't set" do
+      it "returns 0.0 if packet time isn't set" do
         gc = ReceivedTimeSecondsConversion.new()
         packet = Packet.new("TGT","PKT")
-        gc.call(nil,packet,nil).should eql 0.0
+        expect(gc.call(nil,packet,nil)).to eql 0.0
       end
     end
 
     describe "to_s" do
-      it "should return the class" do
-        ReceivedTimeSecondsConversion.new().to_s.should eql "ReceivedTimeSecondsConversion"
+      it "returns the class" do
+        expect(ReceivedTimeSecondsConversion.new().to_s).to eql "ReceivedTimeSecondsConversion"
       end
     end
   end

data/spec/conversions/segmented_polynomial_conversion_spec.rb

@@ -16,34 +16,34 @@ module Cosmos
   describe SegmentedPolynomialConversion do
 
     describe "initialize" do
-      it "should initialize converted_type and converted_bit_size" do
+      it "initializes converted_type and converted_bit_size" do
         gc = SegmentedPolynomialConversion.new()
-        gc.converted_type.should eql :FLOAT
-        gc.converted_bit_size.should eql 64
+        expect(gc.converted_type).to eql :FLOAT
+        expect(gc.converted_bit_size).to eql 64
       end
     end
 
     describe "call" do
-      it "should perform the conversion and return the result" do
+      it "performs the conversion and return the result" do
         gc = SegmentedPolynomialConversion.new()
         gc.add_segment(10, 1,2)
         gc.add_segment(5,  2,2)
         gc.add_segment(15, 3,2)
-        gc.call(1,nil,nil).should eql 4.0
-        gc.call(5,nil,nil).should eql 12.0
-        gc.call(11,nil,nil).should eql 23.0
-        gc.call(20,nil,nil).should eql 43.0
+        expect(gc.call(1,nil,nil)).to eql 4.0
+        expect(gc.call(5,nil,nil)).to eql 12.0
+        expect(gc.call(11,nil,nil)).to eql 23.0
+        expect(gc.call(20,nil,nil)).to eql 43.0
       end
     end
 
     describe "to_s" do
-      it "should return the equations" do
-        SegmentedPolynomialConversion.new().to_s.should eql ""
+      it "returns the equations" do
+        expect(SegmentedPolynomialConversion.new().to_s).to eql ""
         gc = SegmentedPolynomialConversion.new()
         gc.add_segment(10, 1)
         gc.add_segment(5,  2,2)
         gc.add_segment(15, 3,2,3)
-        gc.to_s.should eql "Lower Bound: 15 Polynomial: 3 + 2x + 3x^2\nLower Bound: 10 Polynomial: 1\nLower Bound: 5 Polynomial: 2 + 2x"
+        expect(gc.to_s).to eql "Lower Bound: 15 Polynomial: 3 + 2x + 3x^2\nLower Bound: 10 Polynomial: 1\nLower Bound: 5 Polynomial: 2 + 2x"
       end
     end
   end

data/spec/conversions/unix_time_formatted_conversion_spec.rb

@@ -17,39 +17,39 @@ module Cosmos
   describe UnixTimeFormattedConversion do
 
     describe "initialize" do
-      it "should initialize converted_type and converted_bit_size" do
+      it "initializes converted_type and converted_bit_size" do
         gc = UnixTimeFormattedConversion.new('TIME')
-        gc.converted_type.should eql :STRING
-        gc.converted_bit_size.should eql 0
+        expect(gc.converted_type).to eql :STRING
+        expect(gc.converted_bit_size).to eql 0
       end
     end
 
     describe "call" do
-      it "should return the formatted packet time based on seconds" do
+      it "returns the formatted packet time based on seconds" do
         gc = UnixTimeFormattedConversion.new('TIME')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
         packet.write("TIME",Time.new(2020,1,31,12,15,30).to_f)
-        gc.call(nil,packet,packet.buffer).should eql "2020/01/31 12:15:30.000"
+        expect(gc.call(nil,packet,packet.buffer)).to eql "2020/01/31 12:15:30.000"
       end
 
-      it "should return the formatted packet time based on seconds and microseconds" do
+      it "returns the formatted packet time based on seconds and microseconds" do
         gc = UnixTimeFormattedConversion.new('TIME','TIME_US')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
         packet.write("TIME",Time.new(2020,1,31,12,15,30).to_f)
         packet.append_item("TIME_US",32,:UINT)
         packet.write("TIME_US",500000)
-        gc.call(nil,packet,packet.buffer).should eql "2020/01/31 12:15:30.500"
+        expect(gc.call(nil,packet,packet.buffer)).to eql "2020/01/31 12:15:30.500"
       end
 
-      it "should complain if the seconds item doesn't exist" do
+      it "complains if the seconds item doesn't exist" do
         gc = UnixTimeFormattedConversion.new('TIME')
         packet = Packet.new("TGT","PKT")
         expect { gc.call(nil,packet,packet.buffer) }.to raise_error("Packet item 'TGT PKT TIME' does not exist")
       end
 
-      it "should complain if the microseconds item doesn't exist" do
+      it "complains if the microseconds item doesn't exist" do
         gc = UnixTimeFormattedConversion.new('TIME','TIME_US')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
@@ -59,14 +59,14 @@ module Cosmos
     end
 
     describe "to_s" do
-      it "should return the seconds conversion" do
+      it "returns the seconds conversion" do
         gc = UnixTimeFormattedConversion.new('TIME')
-        gc.to_s.should eql "Time.at(packet.read('TIME', :RAW, buffer), 0).formatted"
+        expect(gc.to_s).to eql "Time.at(packet.read('TIME', :RAW, buffer), 0).formatted"
       end
 
-      it "should return the microseconds conversion" do
+      it "returns the microseconds conversion" do
         gc = UnixTimeFormattedConversion.new('TIME','TIME_US')
-        gc.to_s.should eql "Time.at(packet.read('TIME', :RAW, buffer), packet.read('TIME_US', :RAW, buffer)).formatted"
+        expect(gc.to_s).to eql "Time.at(packet.read('TIME', :RAW, buffer), packet.read('TIME_US', :RAW, buffer)).formatted"
       end
     end
   end

data/spec/conversions/unix_time_seconds_conversion_spec.rb

@@ -17,24 +17,24 @@ module Cosmos
   describe UnixTimeSecondsConversion do
 
     describe "initialize" do
-      it "should initialize converted_type and converted_bit_size" do
+      it "initializes converted_type and converted_bit_size" do
         gc = UnixTimeSecondsConversion.new('TIME')
-        gc.converted_type.should eql :FLOAT
-        gc.converted_bit_size.should eql 64
+        expect(gc.converted_type).to eql :FLOAT
+        expect(gc.converted_bit_size).to eql 64
       end
     end
 
     describe "call" do
-      it "should return the formatted packet time based on seconds" do
+      it "returns the formatted packet time based on seconds" do
         gc = UnixTimeSecondsConversion.new('TIME')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
         time = Time.new(2020,1,31,12,15,30).to_f
         packet.write("TIME",time)
-        gc.call(nil,packet,packet.buffer).should eql time
+        expect(gc.call(nil,packet,packet.buffer)).to eql time
       end
 
-      it "should return the formatted packet time based on seconds and microseconds" do
+      it "returns the formatted packet time based on seconds and microseconds" do
         gc = UnixTimeSecondsConversion.new('TIME','TIME_US')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
@@ -42,16 +42,16 @@ module Cosmos
         packet.write("TIME",time)
         packet.append_item("TIME_US",32,:UINT)
         packet.write("TIME_US",500000)
-        gc.call(nil,packet,packet.buffer).should eql time + 0.5
+        expect(gc.call(nil,packet,packet.buffer)).to eql time + 0.5
       end
 
-      it "should complain if the seconds item doesn't exist" do
+      it "complains if the seconds item doesn't exist" do
         gc = UnixTimeSecondsConversion.new('TIME')
         packet = Packet.new("TGT","PKT")
         expect { gc.call(nil,packet,packet.buffer) }.to raise_error("Packet item 'TGT PKT TIME' does not exist")
       end
 
-      it "should complain if the microseconds item doesn't exist" do
+      it "complains if the microseconds item doesn't exist" do
         gc = UnixTimeSecondsConversion.new('TIME','TIME_US')
         packet = Packet.new("TGT","PKT")
         packet.append_item("TIME",32,:UINT)
@@ -61,14 +61,14 @@ module Cosmos
     end
 
     describe "to_s" do
-      it "should return the seconds conversion" do
+      it "returns the seconds conversion" do
         gc = UnixTimeSecondsConversion.new('TIME')
-        gc.to_s.should eql "Time.at(packet.read('TIME', :RAW, buffer), 0).to_f"
+        expect(gc.to_s).to eql "Time.at(packet.read('TIME', :RAW, buffer), 0).to_f"
       end
 
-      it "should return the microseconds conversion" do
+      it "returns the microseconds conversion" do
         gc = UnixTimeSecondsConversion.new('TIME','TIME_US')
-        gc.to_s.should eql "Time.at(packet.read('TIME', :RAW, buffer), packet.read('TIME_US', :RAW, buffer)).to_f"
+        expect(gc.to_s).to eql "Time.at(packet.read('TIME', :RAW, buffer), packet.read('TIME_US', :RAW, buffer)).to_f"
       end
     end
   end