cosmos 4.2.4-java → 4.5.0-java

data/spec/packets/telemetry_spec.rb

@@ -114,21 +114,23 @@ module Cosmos
 
       it "returns all items from packet TGT1/PKT1" do
         items = @tlm.items("TGT1","PKT1")
-        expect(items.length).to eql 7
-        expect(items[0].name).to eql "RECEIVED_TIMESECONDS"
-        expect(items[1].name).to eql "RECEIVED_TIMEFORMATTED"
-        expect(items[2].name).to eql "RECEIVED_COUNT"
-        expect(items[3].name).to eql "ITEM1"
-        expect(items[4].name).to eql "ITEM2"
-        expect(items[5].name).to eql "ITEM3"
-        expect(items[6].name).to eql "ITEM4"
+        expect(items.length).to eql 9
+        expect(items[0].name).to eql "PACKET_TIMESECONDS"
+        expect(items[1].name).to eql "PACKET_TIMEFORMATTED"
+        expect(items[2].name).to eql "RECEIVED_TIMESECONDS"
+        expect(items[3].name).to eql "RECEIVED_TIMEFORMATTED"
+        expect(items[4].name).to eql "RECEIVED_COUNT"
+        expect(items[5].name).to eql "ITEM1"
+        expect(items[6].name).to eql "ITEM2"
+        expect(items[7].name).to eql "ITEM3"
+        expect(items[8].name).to eql "ITEM4"
       end
     end
 
     describe "item_names" do
       it "returns all the items for a given target and packet" do
         items = @tlm.item_names("TGT1","PKT1")
-        expect(items).to contain_exactly('RECEIVED_TIMEFORMATTED','RECEIVED_TIMESECONDS','RECEIVED_COUNT','ITEM1','ITEM2','ITEM3','ITEM4')
+        expect(items).to contain_exactly('PACKET_TIMEFORMATTED', 'PACKET_TIMESECONDS', 'RECEIVED_TIMEFORMATTED','RECEIVED_TIMESECONDS','RECEIVED_COUNT','ITEM1','ITEM2','ITEM3','ITEM4')
 
         items = @tlm.item_names("TGT1","LATEST")
         expect(items).to contain_exactly('ITEM1','ITEM2','ITEM3','ITEM4')
@@ -255,6 +257,29 @@ module Cosmos
         expect(pkt.item3).to eql 6.0
         expect(pkt.item4).to eql 8.0
       end
+      
+      it "works in unique id mode and not" do
+        System.targets["TGT1"] = Target.new("TGT1")
+        target = System.targets["TGT1"]
+        buffer = "\x01\x02\x03\x04"
+        target.tlm_unique_id_mode = false
+        pkt = @tlm.identify!(buffer,["TGT1"])
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 6.0
+        expect(pkt.item4).to eql 8.0
+        buffer = "\x01\x02\x01\x02"
+        target.tlm_unique_id_mode = true
+        @tlm.identify!(buffer,["TGT1"])
+        pkt = @tlm.packet("TGT1","PKT1")
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 2.0
+        expect(pkt.item4).to eql 4.0        
+        target.tlm_unique_id_mode = false
+      end      
 
       it "returns nil with unknown targets given" do
         buffer = "\x01\x02\x03\x04"
@@ -571,6 +596,34 @@ module Cosmos
       end
     end
 
+    describe "all_item_strings" do
+      it "returns hidden TGT,PKT,ITEMs in the system" do
+        @tlm.packet("TGT1","PKT1").hidden = true
+        @tlm.packet("TGT1","PKT2").disabled = true
+        default = @tlm.all_item_strings() # Return only those not hidden or disabled
+        strings = @tlm.all_item_strings(true) # Return everything, even hidden & disabled
+        expect(default).to_not eq strings
+        # Spot check the default
+        expect(default).to include("TGT2 PKT1 ITEM1")
+        expect(default).to include("TGT2 PKT1 ITEM2")
+        expect(default).to_not include("TGT1 PKT1 ITEM1") # hidden
+        expect(default).to_not include("TGT1 PKT2 ITEM1") # disabled
+
+        items = {}
+        # Built from the before(:each) section
+        items['TGT1 PKT1'] = %w(ITEM1 ITEM2 ITEM3 ITEM4)
+        items['TGT1 PKT2'] = %w(ITEM1 ITEM2)
+        items['TGT2 PKT1'] = %w(ITEM1 ITEM2)
+        items.each do |tgt_pkt, items|
+          Packet::RESERVED_ITEM_NAMES.each do |item|
+            expect(strings).to include("#{tgt_pkt} #{item}")
+          end
+          items.each do |item|
+            expect(strings).to include("#{tgt_pkt} #{item}")
+          end
+        end
+      end
+    end
+
   end
 end
-

data/spec/script/extract_spec.rb

@@ -148,6 +148,10 @@ module Cosmos
         expect(extract_fields_from_check_text("TARGET PACKET ITEM < 5")).to eql(['TARGET', 'PACKET', 'ITEM', '< 5'])
       end
 
+      it "should support target packet items named the same" do
+        expect(extract_fields_from_check_text("TEST TEST TEST == 5")).to eql(['TEST', 'TEST', 'TEST', '== 5'])
+      end
+
       it "should complain about trying to do an = comparison" do
         expect { extract_fields_from_check_text("TARGET PACKET ITEM = 5") }.to raise_error(/ERROR: Use/)
       end
@@ -160,4 +164,3 @@ module Cosmos
 
   end
 end
-

data/spec/script/script_spec.rb

@@ -67,9 +67,8 @@ module Cosmos
         expect { get_limits_groups() }.to raise_error(DRb::DRbConnError)
         expect { set_limits_set("DEFAULT") }.to raise_error(DRb::DRbConnError)
         ignore = []
-        ignore << %w(INST HEALTH_STATUS TEMP1)
-        ignore << %w(INST HEALTH_STATUS TEMP2)
-        ignore << %w(INST HEALTH_STATUS GROUND2STATUS)
+        ignore << %w(SYSTEM META COMPUTER)
+        ignore << %w(SYSTEM META VERSION)
         expect { get_overall_limits_state(ignore) }.to raise_error(DRb::DRbConnError)
 
         clear_disconnected_targets()

data/spec/script/scripting_spec.rb

@@ -36,7 +36,7 @@ module Cosmos
     describe "play_wav_file" do
       it "plays a wav file if Qt is available" do
         module Qt
-          def self.execute_in_main_thread(bool); yield; end
+          def self.execute_in_main_thread(bool = true); yield; end
           class CoreApplication; def self.instance; true; end; end;
           class Sound; def self.isAvailable; true; end; end
         end
@@ -670,6 +670,7 @@ module Cosmos
         class ScriptRunnerFrame; def self.instance; true; end; end
         allow(ScriptRunnerFrame).to receive_message_chain(:instance, :pause?).and_return(true)
         expect(ScriptRunnerFrame).to receive_message_chain(:instance, :perform_pause)
+        expect(ScriptRunnerFrame).to receive_message_chain(:instance, :active_script_highlight)
         cosmos_script_sleep(0.1)
       end
     end

data/spec/script/tools_spec.rb

@@ -101,7 +101,6 @@ module Cosmos
         start_new_scriptrunner_message_log
         disable_instrumentation { }
         set_stdout_max_lines(1000)
-        insert_return
         step_mode
         run_mode
         show_backtrace

data/spec/streams/tcpip_socket_stream_spec.rb

@@ -57,82 +57,87 @@ module Cosmos
         ss = TcpipSocketStream.new('write',nil,nil,nil)
         ss.connect
         expect { ss.read }.to raise_error("Attempt to read from write only stream")
+        ss.disconnect
       end
 
       it "calls read_nonblock from the socket" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
-            sleep 0.1
-            client.write "test"
-            client.close
-          end
+          client = server.accept    # Wait for a client to connect
+          sleep 0.1
+          client.write "test"
+          client.close
         end
+        sleep 0.1
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,nil)
         expect(ss.read_nonblock).to eql ''
         sleep 0.2
         expect(ss.read_nonblock).to eql 'test'
+        thread.join
         Cosmos.close_socket(socket)
         Cosmos.close_socket(server)
-        thread.kill
         sleep 0.1
+        ss.disconnect
       end
 
       it "handles socket blocking exceptions" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
-            sleep 0.2
-            client.write "test"
-            client.close
-          end
+          client = server.accept    # Wait for a client to connect
+          sleep 0.2
+          client.write "test"
+          client.close
         end
+        sleep 0.1
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,nil)
         expect(ss.read).to eql 'test'
+        thread.join
         Cosmos.close_socket(socket)
         Cosmos.close_socket(server)
-        thread.kill
         sleep 0.1
+        ss.disconnect
       end
 
       it "handles socket timeouts" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
-            sleep 0.2
-            client.close
-          end
+          client = server.accept    # Wait for a client to connect
+          sleep 0.2
+          client.close
         end
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,0.1)
         expect { ss.read }.to raise_error(Timeout::Error)
+        thread.join
         sleep 0.2
         Cosmos.close_socket(socket)
         Cosmos.close_socket(server)
-        thread.kill
+        ss.disconnect
         sleep 0.1
       end
 
       it "handles socket connection reset exceptions" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
+          client = server.accept    # Wait for a client to connect
+          sleep 0.2
+          begin
             client.close
+          rescue IOError
+            # Closing the socket causes an IOError
           end
         end
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,5)
+        sleep 0.1 # Allow the server thread to accept
         # Close the socket before trying to read from it
         Cosmos.close_socket(socket)
         expect(ss.read).to eql ''
         Cosmos.close_socket(server)
-        thread.kill
+        thread.join
+        ss.disconnect
         sleep 0.1
       end
     end
@@ -142,6 +147,7 @@ module Cosmos
         ss = TcpipSocketStream.new(nil,'read',nil,nil)
         ss.connect
         expect { ss.write('test') }.to raise_error("Attempt to write to read only stream")
+        ss.disconnect
       end
 
       it "calls write from the driver" do
@@ -151,6 +157,7 @@ module Cosmos
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         ss.write('test')
+        ss.disconnect
       end
 
       it "handles socket blocking exceptions" do
@@ -169,6 +176,7 @@ module Cosmos
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         ss.write('test')
+        ss.disconnect
       end
 
       it "handles socket timeouts" do
@@ -178,6 +186,7 @@ module Cosmos
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         expect { ss.write('test') }.to raise_error(Timeout::Error)
+        ss.disconnect
       end
     end
 
@@ -217,10 +226,6 @@ module Cosmos
         expect(ss.connected?).to be false
       end
     end
-
   end
-
   end # TEMP for Jruby
-
 end
-

data/spec/system/system_spec.rb

@@ -45,7 +45,7 @@ module Cosmos
     describe "instance" do
       it "creates default ports" do
         # Don't check the actual port numbers but just that they exist
-        expect(System.ports.keys).to eql %w(CTS_API TLMVIEWER_API CTS_PREIDENTIFIED CTS_CMD_ROUTER REPLAY_API REPLAY_PREIDENTIFIED REPLAY_CMD_ROUTER DART_DECOM DART_STREAM)
+        expect(System.ports.keys).to eql %w(CTS_API TLMVIEWER_API CTS_PREIDENTIFIED CTS_CMD_ROUTER REPLAY_API REPLAY_PREIDENTIFIED REPLAY_CMD_ROUTER DART_STREAM DART_DECOM DART_MASTER)
       end
 
       it "creates default paths" do
@@ -263,7 +263,7 @@ module Cosmos
       end
 
       describe "packets and System.packets" do
-        it "calculates MD5s across all the target files" do
+        it "calculates hash strings across all the target files" do
           capture_io do |stdout|
             # This line actually does the work of reading the configuration
             expect(System.telemetry.target_names).to eql ['INST', 'SYSTEM']
@@ -349,7 +349,7 @@ module Cosmos
           # Try loading something that doesn't exist
           # It should fail and reload the original configuration
           name, err = System.load_configuration("BLAH")
-          expect(err).to eql nil
+          expect(err.message).to eql "Unable to find configuration: BLAH"
           expect(name).to eql original_config_name
 
           # Now load the second configuration. It shouldn't have the most
@@ -488,6 +488,8 @@ module Cosmos
           tf.close
           FileUtils.mkdir_p(File.join(@config_targets, 'TGT'))
           System.instance.process_file(tf.path)
+          expect(System.targets.key?('TGT')).to be true
+          expect(System.targets.key?('SYSTEM')).to be true
           tf.unlink
         end
 
@@ -701,6 +703,114 @@ module Cosmos
         end
       end
 
+      context "with ALLOW_ROUTER_COMMANDING" do
+        it "takes 0 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ROUTER_COMMANDING BLAH TRUE")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ALLOW_ROUTER_COMMANDING./)
+          tf.unlink
+        end
+
+        it "allows router commanding" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ROUTER_COMMANDING")
+          tf.close
+          expect(System.allow_router_commanding).to be false
+          System.instance.process_file(tf.path)
+          expect(System.allow_router_commanding).to be true
+          tf.unlink
+        end
+
+        it "it disallows router commanding if not present" do
+          tf = Tempfile.new('unittest')
+
+          tf.close
+          expect(System.allow_router_commanding).to be false
+          System.instance.process_file(tf.path)
+          expect(System.allow_router_commanding).to be false
+          tf.unlink
+        end
+      end
+
+      context "with X_CSRF_TOKEN" do
+        it "takes 1 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("X_CSRF_TOKEN")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for X_CSRF_TOKEN./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("X_CSRF_TOKEN localhost true")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for X_CSRF_TOKEN./)
+          tf.unlink
+        end
+
+        it "updates the CSRF token" do
+          tf = Tempfile.new('unittest')
+          tf.puts("X_CSRF_TOKEN ExtraSpecial")
+          tf.close
+          expect(System.x_csrf_token).to eql "SuperSecret"
+          System.instance.process_file(tf.path)
+          expect(System.x_csrf_token).to eql "ExtraSpecial"
+          tf.unlink
+        end
+      end
+
+      context "with ALLOW_HOST" do
+        it "takes 1 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_HOST")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ALLOW_HOST./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_HOST localhost true")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ALLOW_HOST./)
+          tf.unlink
+        end
+
+        it "adds to allowed hosts" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_HOST 1.2.3.4:8888")
+          tf.close
+          expect(System.allowed_hosts).to_not include("1.2.3.4:8888")
+          System.instance.process_file(tf.path)
+          expect(System.allowed_hosts).to include("1.2.3.4:8888")
+          tf.unlink
+        end
+      end
+
+      context "with ALLOW_ORIGIN" do
+        it "takes 1 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ORIGIN")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ALLOW_ORIGIN./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ORIGIN localhost true")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ALLOW_ORIGIN./)
+          tf.unlink
+        end
+
+        it "adds to allowed origins" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ORIGIN 1.2.3.4:8888")
+          tf.close
+          expect(System.allowed_origins).to_not include("1.2.3.4:8888")
+          System.instance.process_file(tf.path)
+          expect(System.allowed_origins).to include("1.2.3.4:8888")
+          tf.unlink
+        end
+      end
+
       context "with ALLOW_ACCESS" do
         it "takes 1 parameters" do
           tf = Tempfile.new('unittest')
@@ -870,12 +980,85 @@ module Cosmos
           tf.puts("ADD_MD5_FILE #{File.expand_path(md5f.path)}")
           tf.close
           System.instance.process_file(tf.path)
-          expect(System.additional_md5_files.include?(File.expand_path(md5f.path))).to be true
+          expect(System.additional_hashing_files.include?(File.expand_path(md5f.path))).to be true
           md5f.close
           md5f.unlink
           tf.unlink
         end
       end
+
+      context "with ADD_HASH_FILE" do
+        it "takes 1 parameter" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ADD_HASH_FILE./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE 1 2")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ADD_HASH_FILE./)
+          tf.unlink
+        end
+
+        it "complains about missing files" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE missing_file")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(/Missing expected file: missing_file/)
+          tf.unlink
+        end
+
+        it "adds a file to the hashing sum calculation" do
+          hashf = Tempfile.new('hash_file')
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE #{File.expand_path(hashf.path)}")
+          tf.close
+          System.instance.process_file(tf.path)
+          expect(System.additional_hashing_files.include?(File.expand_path(hashf.path))).to be true
+          hashf.close
+          hashf.unlink
+          tf.unlink
+        end
+      end
+
+      context "with HASHING_ALGORITHM" do
+        it "takes 1 parameter" do
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for HASHING_ALGORITHM./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM 1 2")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for HASHING_ALGORITHM./)
+          tf.unlink
+        end
+
+        it "complains about invalid algorithms" do
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM BAD")
+          tf.close
+          expect(Logger).to receive(:error) do |msg|
+            expect(msg).to eql "Unrecognized hashing algorithm: BAD, using default algorithm MD5"
+          end
+          System.instance.process_file(tf.path)
+          expect(System.hashing_algorithm).to eql 'MD5'
+          tf.unlink
+        end
+
+        it "sets the hashing algorithm" do
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM SHA256")
+          tf.close
+          System.instance.process_file(tf.path)
+          expect(System.hashing_algorithm).to eql 'SHA256'
+          tf.unlink
+        end
+      end
     end
 
     describe "Cosmos.write_exception_file" do