cosmos 4.4.1 → 4.5.2

data/lib/cosmos/version.rb

@@ -1,12 +1,12 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '4.4.1'
+COSMOS_VERSION = '4.5.2'
 module Cosmos
   module Version
     MAJOR = '4'
-    MINOR = '4'
-    PATCH = '1'
-    BUILD = 'f8e9c89b2d7fcd0c558806ff6c9dd59d167786e4'
+    MINOR = '5'
+    PATCH = '2'
+    BUILD = 'a516d4699e4de74066155c12194c9286adcde9ea'
   end
-  VERSION = '4.4.1'
+  VERSION = '4.5.2'
 end

data/make_gems.sh

@@ -1,7 +1,7 @@
 # export VERSION= before running this
 git checkout master
 git pull
-rbenv global 2.4.4
+rbenv global 2.5.9
 rake release VERSION=$VERSION
 rake commit_release VERSION=$VERSION
 mv *.gem ~/share/.

data/spec/core_ext/class_spec.rb

@@ -31,6 +31,60 @@ describe Class do
       my = MyClass.new
       expect(MyClass.test).to eql "Test"
       expect(my.test).to eql "Test"
+      # No accessor methods are created
+      expect { my.test = "Blah" }.to raise_error(NoMethodError)
+    end
+
+    it "does not allow arbitrary code" do
+      expect {
+        class MyClass
+          instance_attr_reader "test;puts 'HI'"
+        end
+      }.to raise_error(ArgumentError)
+
+      expect {
+        class MyClass
+          instance_attr_reader "test\nputs 'HI'"
+        end
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "instance_attr_accessor" do
+    it "adds instance attribute readers for class variables" do
+      class MyClass
+        instance_attr_accessor :test
+        @@instance = nil
+        def self.instance
+          @@instance ||= self.new
+          return @@instance
+        end
+        def initialize
+          @test = "Test"
+          @@instance = self
+        end
+      end
+
+      my = MyClass.new
+      expect(MyClass.test).to eql "Test"
+      expect(my.test).to eql "Test"
+      my.test = "Blah"
+      expect(MyClass.test).to eql "Blah"
+      expect(my.test).to eql "Blah"
+    end
+
+    it "does not allow arbitrary code" do
+      expect {
+        class MyClass
+          instance_attr_accessor "test;puts 'HI'"
+        end
+      }.to raise_error(ArgumentError)
+
+      expect {
+        class MyClass
+          instance_attr_accessor "test\nputs 'HI'"
+        end
+      }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/core_ext/time_spec.rb

@@ -183,6 +183,10 @@ describe Time do
       expect(parts[1]).to eql ccsds_ms
       expect(parts[2]).to be_within(50).of(ccsds_us)
     end
+
+    it "maintains precision" do
+      expect(Time.ccsds2sec(22766, 65115943, 552).round(6)).to eql(1967047515.943552)
+    end
   end
 
   describe "Time.yds2mdy" do

data/spec/gui/qt_spec.rb

@@ -8,7 +8,7 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-if RUBY_ENGINE == 'ruby'
+if RUBY_ENGINE == 'ruby' && !ENV['GITHUB_ACTIONS']
   require 'spec_helper'
   require 'cosmos/gui/qt'
 

data/spec/gui/utilities/script_module_gui_spec.rb

@@ -8,7 +8,7 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-if RUBY_ENGINE == 'ruby'
+if RUBY_ENGINE == 'ruby' && !ENV['CI']
   require 'spec_helper'
   require 'cosmos/gui/qt'
   require 'cosmos/script'

data/spec/interfaces/linc_interface_spec.rb

@@ -179,7 +179,7 @@ module Cosmos
         it "warns if an error code is set" do
           allow_any_instance_of(TcpipClientStream).to receive(:read).and_return @handshake.buffer(false)
           expect(Logger).to receive(:warn) do |msg|
-            expect(msg).to eql "Warning sending command (12345): BAD"
+            expect(msg).to eql "LincInterface: Warning sending command (12345): BAD"
           end
           t = Thread.new do
             sleep 0.1

data/spec/interfaces/serial_interface_spec.rb

@@ -9,14 +9,11 @@
 # attribution addendums as found in the LICENSE.txt
 
 if RUBY_ENGINE == 'ruby' or Gem.win_platform?
-
   require 'spec_helper'
   require 'cosmos/interfaces/serial_interface'
 
   module Cosmos
-
-    describe SerialInterface do
-
+    describe SerialInterface, :if => `change port /query 2>&1` !~ /No serial ports/ do
       describe "initialize" do
         it "initializes the instance variables" do
           i = SerialInterface.new('COM1','COM1','9600','NONE','1','0','0','burst')
@@ -66,5 +63,4 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
       end
     end
   end
-
 end

data/spec/io/json_drb_rack_spec.rb

@@ -0,0 +1,166 @@
+  # encoding: ascii-8bit
+
+  # Copyright 2014 Ball Aerospace & Technologies Corp.
+  # All Rights Reserved.
+  #
+  # This program is free software; you can modify and/or redistribute it
+  # under the terms of the GNU General Public License
+  # as published by the Free Software Foundation; version 3 with
+  # attribution addendums as found in the LICENSE.txt
+
+  require 'spec_helper'
+  require 'cosmos/io/json_drb_rack'
+
+  module Cosmos
+
+    describe JsonDrbRack do
+      before(:each) do
+        @env = {
+          "GATEWAY_INTERFACE" => "CGI/1.1",
+          "PATH_INFO" => "/index.html",
+          "QUERY_STRING" => "",
+          "REMOTE_ADDR" => "::1",
+          "REMOTE_HOST" => "localhost",
+          "REQUEST_METHOD" => "POST",
+          "REQUEST_URI" => "http://localhost:3000/index.html",
+          "SCRIPT_NAME" => "",
+          "SERVER_NAME" => "localhost",
+          "SERVER_PORT" => "3000",
+          "SERVER_PROTOCOL" => "HTTP/1.1",
+          "SERVER_SOFTWARE" => "WEBrick/1.3.1 (Ruby/2.0.0/2013-11-22)",
+          "HTTP_HOST" => "127.0.0.1:7777",
+          "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:26.0) Gecko/20100101 Firefox/26.0",
+          "HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          "HTTP_ACCEPT_LANGUAGE" => "zh-tw,zh;q=0.8,en-us;q=0.5,en;q=0.3",
+          "HTTP_ACCEPT_ENCODING" => "gzip, deflate",
+          "HTTP_COOKIE" => "jsonrpc.session=3iqp3ydRwFyqjcfO0GT2bzUh.bacc2786c7a81df0d0e950bec8fa1a9b1ba0bb61",
+          "HTTP_CONNECTION" => "keep-alive",
+          "HTTP_CACHE_CONTROL" => "max-age=0",
+          "rack.version" => [1, 2],
+          "rack.input" => StringIO.new(""),
+          "rack.errors" => nil,
+          "rack.multithread" => true,
+          "rack.multiprocess" => false,
+          "rack.run_once" => false,
+          "rack.url_scheme" => "http",
+          "HTTP_VERSION" => "HTTP/1.1",
+          "REQUEST_PATH" => "/index.html"
+        }
+      end
+
+      class MockDRb
+        class MockDRbAcl
+          def initialize(val = true)
+            @val = val
+          end
+          def allow_addr?(val)
+            return @val
+          end
+        end
+
+        def initialize(val, response_data = "response", error_code = nil)
+          @acl = MockDRbAcl.new(val)
+          @response_data = response_data
+          @error_code = error_code
+        end
+
+        def acl
+          @acl
+        end
+
+        def process_request(request_data, start_time)
+          return @response_data, @error_code
+        end
+      end
+
+      class MockSystem
+        def initialize(token = 'SuperSecret', hosts = ['127.0.0.1:7777'], origins = [])
+          @token = token
+          @hosts = hosts
+          @origins = origins
+        end
+        def x_csrf_token
+          @token
+        end
+        def allowed_hosts
+          @hosts
+        end
+        def allowed_origins
+          @origins
+        end
+      end
+
+      describe "call" do
+        it "supports the drb acl" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(false), MockSystem.new)
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden"]
+        end
+
+        it "handles X-Csrf-Token" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'TryToGuess'
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: Bad X-Csrf-Token: #{@env['HTTP_X_CSRF_TOKEN']}"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Handles Allowed Hosts" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_HOST'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: #{@env['HTTP_HOST']} not in allowed hosts"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess', ['5.6.7.8:7777']))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_HOST'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Handles Allowed Origins" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_ORIGIN'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: #{@env['HTTP_ORIGIN']} not in allowed origins"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess', ['127.0.0.1:7777'], ['3.6.7.8:7777']))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_ORIGIN'] = "3.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Only accepts posts" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env["REQUEST_METHOD"] = "GET"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 405
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Request not allowed"]
+        end
+
+      end
+    end
+  end

data/spec/io/json_rpc_spec.rb

@@ -238,25 +238,25 @@ module Cosmos
 
       it "reports an error if there is no 'result' or 'error' key" do
         json = JsonRpcResponse.new(10).as_json
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if the version isn't 2.0" do
         json = JsonRpcResponse.new(10).as_json
         json['jsonrpc'] = "1.1"
         json['result'] = "true"
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if there is both a 'result' and 'error' key" do
         json = JsonRpcResponse.new(10).as_json
         json['result'] = "true"
         json['error'] = {"code"=>-1, "message"=>"error"}
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if it is not json" do
-        expect { JsonRpcResponse.from_json(Object.new) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(Object.new) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if the error hash is bad" do
@@ -268,4 +268,3 @@ module Cosmos
 
   end
 end
-

data/spec/io/posix_serial_driver_spec.rb

@@ -0,0 +1,87 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+# NOTE: !ENV['DOCKER'] because of the following error while in container:
+#   Failure/Error: @handle = Kernel.open(port_name, File::RDWR | File::NONBLOCK)
+#   Errno::ENOENT:
+#     No such file or directory @ rb_sysopen - /dev/ttyS0
+#   ./lib/cosmos/io/posix_serial_driver.rb:48:in `initialize'
+
+if RbConfig::CONFIG['target_os'] !~ /mswin|mingw|cygwin/i and RUBY_ENGINE == 'ruby' and !ENV['CI'] and !ENV['DOCKER']
+
+  require 'spec_helper'
+  require 'cosmos/io/posix_serial_driver'
+
+  module Cosmos
+
+    describe PosixSerialDriver do
+      describe "instance" do
+        it "enforces the baud rate to a known value" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',10,:NONE) }.to raise_error(ArgumentError, "Invalid baud rate: 10")
+        end
+
+        it "supports even, odd, or no parity" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:EVEN).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:ODD).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
+        end
+
+        it "supports 1 or 2 stop bits" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,2).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
+        end
+
+        it "supports 5-8 data bits" do
+          (5..8).each do |data_bits|
+            driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,data_bits)
+            handle = driver.instance_variable_get(:@handle)
+            expect(handle.tcgetattr.cflag & Termios::CSIZE).to eq(Termios.const_get("CS#{data_bits}"))
+            driver.close
+          end
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,9) }.to raise_error(ArgumentError, "Invalid data bits: 9")
+        end
+
+        it "sets arbitrary Posix structure elements" do
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,8)
+          handle = driver.instance_variable_get(:@handle)
+          # Verify non of the things we're going to set are already set
+          expect(handle.tcgetattr.iflag & Termios::IGNBRK).to eq(0)
+          expect(handle.tcgetattr.oflag & Termios::OPOST).to eq(0)
+          expect(handle.tcgetattr.cflag & Termios::CLOCAL).to eq(Termios::CLOCAL) # We set this by default
+          expect(handle.tcgetattr.lflag & Termios::ECHO).to eq(0)
+          expect(handle.tcgetattr.cc[Termios::VMIN]).to eq(1)
+          driver.close
+          # When setting a field the "1" is optional. When clearing a field the "0" is required.
+          # Entries in the "cc" special characters field are automatically converted to integers if they are numbers
+          struct = [["iflag", "IGNBRK"], ["oflag", "OPOST", "1"], ["cflag", "CLOCAL", "0"], ["lflag", "ECHO"], ["cc", "VMIN", "2"]]
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,8,struct)
+          handle = driver.instance_variable_get(:@handle)
+          expect(handle.tcgetattr.iflag & Termios::IGNBRK).to eq(Termios::IGNBRK)
+          expect(handle.tcgetattr.oflag & Termios::OPOST).to eq(Termios::OPOST)
+          expect(handle.tcgetattr.cflag & Termios::CLOCAL).to eq(0)
+          expect(handle.tcgetattr.lflag & Termios::ECHO).to eq(Termios::ECHO)
+          expect(handle.tcgetattr.cc[Termios::VMIN]).to eq(2)
+          driver.close
+        end
+      end
+
+      describe "close, closed?" do
+        it "closes the handle" do
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600)
+          expect(driver.closed?).to be false
+          driver.close
+          expect(driver.closed?).to be true
+        end
+      end
+    end
+  end
+end

data/spec/io/win32_serial_driver_spec.rb

@@ -19,7 +19,8 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
       before(:each) do
         allow(Win32).to receive(:create_file).and_return(Object.new)
         state = double("comm_state")
-        allow(state).to receive(:write)
+        @dcb_struct = {}
+        allow(state).to receive(:write) { |key, value| @dcb_struct[key] = value }
         allow(Win32).to receive(:get_comm_state).and_return(state)
         allow(Win32).to receive(:set_comm_state)
         allow(Win32).to receive(:set_comm_timeouts)
@@ -34,12 +35,14 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { Win32SerialDriver.new('COM1',9600,:EVEN) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:ODD) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE) }.to_not raise_error
+          expect(@dcb_struct["Parity"]).to_not be_nil # Simply check that Parity was set
           expect { Win32SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
         end
 
         it "supports 1 or 2 stop bits" do
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,2) }.to_not raise_error
+          expect(@dcb_struct["StopBits"]).to_not be_nil # Simply check that StopBits was set
           expect { Win32SerialDriver.new('COM1',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
         end
 
@@ -49,6 +52,19 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,7) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,9) }.to raise_error(ArgumentError, "Invalid data bits: 9")
+          expect(@dcb_struct["ByteSize"]).to_not be_nil # Simply check that ByteSize was set
+        end
+
+        it "sets arbitrary Windows DCB structure elements" do
+          Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8)
+          expect(@dcb_struct["fOutxDsrFlow"]).to be_nil # This isn't set by default
+          expect(@dcb_struct["Parity"]).to eq(0)
+          # Set a new variable in the Windows DCB struct and override the :NONE parity
+          # We pass them in as strings because that's how they're parsed
+          struct = [["fOutxDsrFlow", "1"], ["Parity", "4"]]
+          Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8,struct)
+          expect(@dcb_struct["fOutxDsrFlow"]).to eq(1)
+          expect(@dcb_struct["Parity"]).to eq(4)
         end
 
         it "calculates the correct timeouts" do

data/spec/packet_logs/packet_log_reader_spec.rb

@@ -23,7 +23,10 @@ module Cosmos
       plw = PacketLogWriter.new(:CMD,nil,true,nil,10000000,nil,false)
       @cmd_packets = []
       pkt = System.commands.packet("SYSTEM","STARTLOGGING").clone
-      pkt.received_time = Time.new(2020,1,31,12,30,15)
+      # Avoid precision errors by rounding to nearest second and then add 1 to ensure
+      # the time is AFTER the initial META packet with the current time
+      @time = Time.now.round + 1
+      pkt.received_time = @time
       pkt.write('label','PKT1')
       plw.write(pkt)
       @cmd_packet_length = pkt.length
@@ -43,7 +46,7 @@ module Cosmos
       plw = PacketLogWriter.new(:TLM,nil,true,nil,10000000,nil,false)
       @tlm_packets = []
       pkt = System.telemetry.packet("SYSTEM","LIMITS_CHANGE").clone
-      pkt.received_time = Time.new(2020,2,1,12,30,15)
+      pkt.received_time = @time
       pkt.write('PACKET','PKT1')
       plw.write(pkt)
       @tlm_packet_length = pkt.length
@@ -203,7 +206,7 @@ module Cosmos
         end
 
         # Corrupt the second config
-        second_config_path = System.instance.send(:find_configuration, second_config_name)
+        second_config_path = System.instance.public_send(:find_configuration, second_config_name)
         md5 = File.basename(second_config_path, '.*')
         Zip::File.open(second_config_path) do |zip|
           zip.file.rename(File.join(md5, 'system.txt'), File.join(md5, 'system2.txt'))
@@ -239,10 +242,11 @@ module Cosmos
         expect(packet_offsets).to eql [PacketLogReader::COSMOS4_HEADER_LENGTH, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + header_length + @cmd_packet_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @cmd_packet_length) * 2]
 
         expect(@plr.open(Dir[File.join(@log_path,"*cmd.bin")][0])).to eql [true, nil]
-        pkt = @plr.read_at_offset(packet_offsets[2])
+        pkt = @plr.read_at_offset(packet_offsets[2]) # Grab the second STARTLOGGING (META is 0)
         expect(pkt.target_name).to eql "SYSTEM"
         expect(pkt.packet_name).to eql "STARTLOGGING"
-        expect(pkt.received_time).to eql Time.new(2020,1,31,12,30,16)
+        expect(pkt.read('LABEL')).to eql "PKT2"
+        expect(pkt.received_time).to eql @time + 1
         @plr.close
       end
 
@@ -257,10 +261,11 @@ module Cosmos
         expect(packet_offsets).to eql [PacketLogReader::COSMOS4_HEADER_LENGTH, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + header_length + @tlm_packet_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @tlm_packet_length) * 2]
 
         expect(@plr.open(Dir[File.join(@log_path,"*tlm.bin")][0])).to eql [true, nil]
-        pkt = @plr.read_at_offset(packet_offsets[2])
+        pkt = @plr.read_at_offset(packet_offsets[2]) # Grab the second LIMITS_CHANGE (META is 0)
         expect(pkt.target_name).to eql "SYSTEM"
         expect(pkt.packet_name).to eql "LIMITS_CHANGE"
-        expect(pkt.received_time).to eql Time.new(2020,2,1,12,30,16)
+        expect(pkt.read('PACKET')).to eql "PKT2"
+        expect(pkt.received_time).to eql @time + 1
         @plr.close
       end
     end
@@ -415,9 +420,8 @@ module Cosmos
       end
 
       it "returns all packets if the start time is before all" do
-        time = Time.new(2000,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, @time) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @cmd_packets[index].target_name
           expect(packet.packet_name).to eql @cmd_packets[index].packet_name
@@ -429,51 +433,48 @@ module Cosmos
       end
 
       it "returns no packets if the start time is after all" do
-        time = Time.new(2030,2,1,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, @time + 100) do |packet|
           index += 1
         end
         expect(index).to eql 0
       end
 
       it "returns all packets after a start time" do
-        time = Time.new(2020,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, time) do |packet|
-          expect(packet.target_name).to eql @cmd_packets[index+1].target_name
-          expect(packet.packet_name).to eql @cmd_packets[index+1].packet_name
-          expect(packet.received_time).to eql @cmd_packets[index+1].received_time
-          expect(packet.read('LABEL')).to eql @cmd_packets[index+1].read('LABEL')
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, @time) do |packet|
+          next if packet.packet_name == 'META'
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        expect(index).to eql 2
+        expect(index).to eql 3
 
-        time = Time.new(2020,2,1,12,30,16)
-        index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, time) do |packet|
-          expect(packet.target_name).to eql @tlm_packets[index+1].target_name
-          expect(packet.packet_name).to eql @tlm_packets[index+1].packet_name
-          expect(packet.received_time).to eql @tlm_packets[index+1].received_time
-          expect(packet.read('PACKET')).to eql @tlm_packets[index+1].read('PACKET')
+        index = 1 # @time + 1
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, @time + 1) do |packet|
+          next if packet.packet_name == 'META'
+          expect(packet.target_name).to eql @tlm_packets[index].target_name
+          expect(packet.packet_name).to eql @tlm_packets[index].packet_name
+          expect(packet.received_time).to eql @tlm_packets[index].received_time
+          expect(packet.read('PACKET')).to eql @tlm_packets[index].read('PACKET')
           index += 1
         end
-        expect(index).to eql 2
+        expect(index).to eql 3
       end
 
       it "returns no packets if the end time is before all" do
-        time = Time.new(2000,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, @time - 10) do |packet|
           index += 1
         end
         expect(index).to eql 0
       end
 
       it "returns all packets if the end time is after all" do
-        time = Time.new(2030,2,1,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, @time + 10) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @cmd_packets[index].target_name
           expect(packet.packet_name).to eql @cmd_packets[index].packet_name
@@ -485,9 +486,8 @@ module Cosmos
       end
 
       it "returns all packets before an end time" do
-        time = Time.new(2020,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, @time) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @cmd_packets[index].target_name
           expect(packet.packet_name).to eql @cmd_packets[index].packet_name
@@ -495,11 +495,10 @@ module Cosmos
           expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        expect(index).to eql 2
+        expect(index).to eql 1
 
-        time = Time.new(2020,2,1,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, @time + 1) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @tlm_packets[index].target_name
           expect(packet.packet_name).to eql @tlm_packets[index].packet_name