cosmos 3.9.2 → 4.0.0

data/spec/streams/serial_stream_spec.rb

@@ -13,105 +13,110 @@ require 'cosmos/streams/serial_stream'
 
 module Cosmos
 
-  describe SerialStream do
-    describe "initialize" 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
+  if RUBY_ENGINE == 'ruby' or Gem.win_platform?
 
-    describe "connected?" 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)
-        expect(ss.connected?).to be true
+    describe SerialStream do
+      describe "initialize" 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
-    end
 
-    describe "read" 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")
+      describe "connected?" 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)
+          expect(ss.connected?).to be true
+        end
       end
 
-      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)
-        expect(ss.read).to eql 'test'
-      end
-    end
+      describe "read" 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
 
-    describe "write" 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")
+        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)
+          expect(ss.read).to eql 'test'
+        end
       end
 
-      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)
-        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
-        ss.write('test')
-      end
-    end
+      describe "write" 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
 
-    describe "disconnect" 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)
-        expect(ss.connected?).to be true
-        ss.disconnect
-        expect(ss.connected?).to be false
+        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)
+          ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
+          ss.write('test')
+        end
       end
 
-      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)
-        expect(ss.connected?).to be true
-        ss.disconnect
-        expect(ss.connected?).to be false
-      end
+      describe "disconnect" 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)
+          expect(ss.connected?).to be true
+          ss.disconnect
+          expect(ss.connected?).to be false
+        end
+
+        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)
+          expect(ss.connected?).to be true
+          ss.disconnect
+          expect(ss.connected?).to be false
+        end
 
-      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)
-        expect(ss.connected?).to be true
-        ss.disconnect
-        expect(ss.connected?).to be false
-        ss.disconnect
-        expect(ss.connected?).to be false
+        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)
+          expect(ss.connected?).to be true
+          ss.disconnect
+          expect(ss.connected?).to be false
+          ss.disconnect
+          expect(ss.connected?).to be false
+        end
       end
-    end
 
-    describe "connect" 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
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
-        expect{ss.connect}.to_not raise_error
-        ss.disconnect
+      describe "connect" 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
+          expect(SerialDriver).to receive(:new).and_return(driver)
+          ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
+          expect{ss.connect}.to_not raise_error
+          ss.disconnect
+        end
       end
+
     end
 
   end
+
 end
 

data/spec/streams/tcpip_client_stream_spec.rb

@@ -15,11 +15,19 @@ module Cosmos
 
   describe TcpipClientStream do
     before(:all) do
-      addr = Socket.pack_sockaddr_in(8888, Socket::INADDR_ANY)
-      @listen_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      addr = Socket.pack_sockaddr_in(8888, "0.0.0.0")
+      if RUBY_ENGINE == 'ruby'
+        @listen_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      else
+        @listen_socket = ServerSocket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      end
       @listen_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1) unless Kernel.is_windows?
-      @listen_socket.bind(addr)
-      @listen_socket.listen(5)
+      if RUBY_ENGINE == 'ruby'
+        @listen_socket.bind(addr)
+        @listen_socket.listen(5)
+      else
+        @listen_socket.bind(addr, 5)
+      end
     end
 
     after(:all) do

data/spec/streams/tcpip_socket_stream_spec.rb

@@ -14,6 +14,8 @@ require 'socket'
 
 module Cosmos
 
+  if RUBY_ENGINE == 'ruby' # For some reason this test causes uncatchable exceptions in Jruby when run with other tests - Skip for now
+
   describe TcpipSocketStream do
     describe "initialize, connected?" do
       it "is not be connected when initialized" do
@@ -217,5 +219,8 @@ module Cosmos
     end
 
   end
+
+  end # TEMP for Jruby
+
 end
 

data/spec/system/system_spec.rb

@@ -48,30 +48,32 @@ module Cosmos
 
       it "creates default paths" do
         # Don't check the actual paths but just that they exist
-        expect(System.paths.keys).to eql %w(LOGS TMP SAVED_CONFIG TABLES HANDBOOKS PROCEDURES)
+        expect(System.paths.keys).to eql %w(LOGS TMP SAVED_CONFIG TABLES HANDBOOKS PROCEDURES SEQUENCES)
       end
     end
 
     describe "System.commands" do
-      it "is empty" do
-        expect(System.commands.target_names).to eql []
+      it "is just SYSTEM" do
+        expect(System.commands.target_names).to eql ['SYSTEM']
       end
 
       it "logs errors saving the configuration" do
-        # Force a reload of the configuration
-        System.class_eval('@@instance = nil')
-
-        capture_io do |stdout|
-          allow(FileUtils).to receive(:mkdir_p) { raise "Error" }
-          expect(System.commands.target_names).to eql []
-          expect(stdout.string).to match "Problem saving configuration"
-        end
+       # Write the system.txt file to auto declare targets
+       File.open(@config_file, 'w') { |file| file.puts "AUTO_DECLARE_TARGETS" }
+       # Force a reload of the configuration
+       System.class_eval('@@instance = nil')
+       capture_io do |stdout|
+         allow(FileUtils).to receive(:cp_r) { raise "Error" }
+         System.commands
+         expect(stdout.string).to match "Problem saving configuration"
+       end
+       File.open(@config_file, 'w') { |file| file.puts "# Comment" }
       end
     end
 
     describe "System.telemetry" do
-      it "is empty" do
-        expect(System.telemetry.target_names).to eql []
+      it "is just SYSTEM" do
+        expect(System.telemetry.target_names).to eql ['SYSTEM']
       end
     end
 
@@ -89,6 +91,7 @@ module Cosmos
 
       describe "System.clear_counters" do
         it "clears the target, command and telemetry counters" do
+          expect(System.targets.length).to be > 0
           System.targets.each do |name, tgt|
             tgt.cmd_cnt = 100
             tgt.tlm_cnt = 100
@@ -119,8 +122,8 @@ module Cosmos
         it "calculates MD5s 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 ['COSMOS','INST','META']
-            expect(System.commands.target_names).to eql ['COSMOS','INST','META']
+            expect(System.telemetry.target_names).to eql ['INST', 'SYSTEM']
+            expect(System.commands.target_names).to eql ['INST', 'SYSTEM']
 
             expect(stdout.string).to match "Marshal file does not exist"
 
@@ -129,8 +132,8 @@ module Cosmos
             # Reset the instance variable so it will read the new configuration
             System.class_eval('@@instance = nil')
             # This line actually does the work of reading the configuration
-            expect(System.telemetry.target_names).to eql ['COSMOS','INST','META']
-            expect(System.commands.target_names).to eql ['COSMOS','INST','META']
+            expect(System.telemetry.target_names).to eql ['INST', 'SYSTEM']
+            expect(System.commands.target_names).to eql ['INST', 'SYSTEM']
 
             expect(stdout.string).to match "Marshal load success"
           end
@@ -149,53 +152,53 @@ module Cosmos
 
       describe "load_configuration" do
         after(:all) do
-          File.delete(File.join(@config_targets,'COSMOS','cmd_tlm','test1_tlm.txt'))
-          File.delete(File.join(@config_targets,'COSMOS','cmd_tlm','test2_tlm.txt'))
+          File.delete(File.join(@config_targets,'SYSTEM','cmd_tlm','test1_tlm.txt'))
+          File.delete(File.join(@config_targets,'SYSTEM','cmd_tlm','test2_tlm.txt'))
         end
 
         it "loads the initial configuration" do
           System.load_configuration
-          expect(System.commands.target_names).to eql ['COSMOS','INST','META']
-          expect(System.telemetry.target_names).to eql ['COSMOS','INST','META']
+          expect(System.commands.target_names).to eql ['INST', 'SYSTEM']
+          expect(System.telemetry.target_names).to eql ['INST', 'SYSTEM']
         end
 
         it "loads a named configuration" do
           File.open(@config_file,'w') do |file|
-            file.puts "DECLARE_TARGET COSMOS"
-            file.puts "DECLARE_TARGET COSMOS OVERRIDE"
+            file.puts "DECLARE_TARGET INST OVERRIDE"
+            file.puts "DECLARE_TARGET SYSTEM"
           end
 
           # Load the original configuration
           original_config_name, err = System.load_configuration
           expect(err).to eql nil
-          expect(System.telemetry.target_names).to eql %w(COSMOS OVERRIDE)
-          original_pkts = System.telemetry.packets('COSMOS').keys
+          expect(System.telemetry.target_names).to eql %w(OVERRIDE SYSTEM)
+          original_pkts = System.telemetry.packets('SYSTEM').keys
 
           # Create a new configuration by writing another telemetry file
-          File.open(File.join(@config_targets,'COSMOS','cmd_tlm','test1_tlm.txt'),'w') do |file|
-            file.puts "TELEMETRY COSMOS TEST1 BIG_ENDIAN"
+          File.open(File.join(@config_targets,'SYSTEM','cmd_tlm','test1_tlm.txt'),'w') do |file|
+            file.puts "TELEMETRY SYSTEM TEST1 BIG_ENDIAN"
             file.puts "  APPEND_ITEM DATA 240 STRING"
           end
           System.instance.process_file(@config_file)
           # Verify the new telemetry packet is there
-          expect(System.telemetry.packets('COSMOS').keys).to include "TEST1"
+          expect(System.telemetry.packets('SYSTEM').keys).to include "TEST1"
           second_config_name = System.configuration_name
 
           # Now load the original configuration
           name, err = System.load_configuration(original_config_name)
           expect(err).to eql nil
           expect(original_config_name).to eql name
-          expect(System.telemetry.packets('COSMOS').keys).not_to include "TEST1"
+          expect(System.telemetry.packets('SYSTEM').keys).not_to include "TEST1"
 
           # Create yet another configuration by writing another telemetry file
-          File.open(File.join(@config_targets,'COSMOS','cmd_tlm','test2_tlm.txt'),'w') do |file|
-            file.puts "TELEMETRY COSMOS TEST2 BIG_ENDIAN"
+          File.open(File.join(@config_targets,'SYSTEM','cmd_tlm','test2_tlm.txt'),'w') do |file|
+            file.puts "TELEMETRY SYSTEM TEST2 BIG_ENDIAN"
             file.puts "  APPEND_ITEM DATA 240 STRING"
           end
           System.instance.process_file(@config_file)
           names = []
           # Verify the new telemetry packet is there as well as the second one
-          expect(System.telemetry.packets('COSMOS').keys).to include("TEST1", "TEST2")
+          expect(System.telemetry.packets('SYSTEM').keys).to include("TEST1", "TEST2")
           third_config_name = System.configuration_name
 
           # Try loading something that doesn't exist
@@ -207,8 +210,8 @@ module Cosmos
           # Now load the second configuration. It shouldn't have the most
           # recently defined telemetry packet.
           System.load_configuration(second_config_name)
-          expect(System.telemetry.packets('COSMOS').keys).to include "TEST1"
-          expect(System.telemetry.packets('COSMOS').keys).not_to include "TEST2"
+          expect(System.telemetry.packets('SYSTEM').keys).to include "TEST1"
+          expect(System.telemetry.packets('SYSTEM').keys).not_to include "TEST2"
 
           # Now remove system.txt from the third configuration and try to load it again to cause an error
           third_config_path = System.instance.send(:find_configuration, third_config_name)
@@ -442,7 +445,7 @@ module Cosmos
       end
 
       context "with DEFAULT_PACKET_LOG_WRITER" do
-        it "takes 1 parameters" do
+        it "takes 1 or more parameters" do
           tf = Tempfile.new('unittest')
           tf.puts("DEFAULT_PACKET_LOG_WRITER")
           tf.close
@@ -450,9 +453,11 @@ module Cosmos
           tf.unlink
 
           tf = Tempfile.new('unittest')
-          tf.puts("DEFAULT_PACKET_LOG_WRITER my_nonexistent_class TRUE")
+          tf.puts("DEFAULT_PACKET_LOG_WRITER packet_log_writer.rb nil false")
           tf.close
-          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for DEFAULT_PACKET_LOG_WRITER./)
+          System.instance.process_file(tf.path)
+          expect(System.default_packet_log_writer).to eql PacketLogWriter
+          expect(System.default_packet_log_writer_params).to eql ["nil", "false"]
           tf.unlink
         end
 
@@ -481,7 +486,7 @@ module Cosmos
       end
 
       context "with DEFAULT_PACKET_LOG_READER" do
-        it "takes 1 parameters" do
+        it "takes 1 or more parameters" do
           tf = Tempfile.new('unittest')
           tf.puts("DEFAULT_PACKET_LOG_READER")
           tf.close
@@ -489,9 +494,11 @@ module Cosmos
           tf.unlink
 
           tf = Tempfile.new('unittest')
-          tf.puts("DEFAULT_PACKET_LOG_READER my_nonexistent_class TRUE")
+          tf.puts("DEFAULT_PACKET_LOG_READER packet_log_reader.rb nil false")
           tf.close
-          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for DEFAULT_PACKET_LOG_READER./)
+          System.instance.process_file(tf.path)
+          expect(System.default_packet_log_reader).to eql PacketLogReader
+          expect(System.default_packet_log_reader_params).to eql ["nil", "false"]
           tf.unlink
         end
 
@@ -635,28 +642,38 @@ module Cosmos
         end
       end
 
-      context "with CMD_TLM_VERSION" do
+      context "with ADD_MD5_FILE" do
         it "takes 1 parameters" do
           tf = Tempfile.new('unittest')
-          tf.puts("CMD_TLM_VERSION")
+          tf.puts("ADD_MD5_FILE")
           tf.close
-          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for CMD_TLM_VERSION./)
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ADD_MD5_FILE./)
           tf.unlink
 
           tf = Tempfile.new('unittest')
-          tf.puts("CMD_TLM_VERSION 1 2")
+          tf.puts("ADD_MD5_FILE 1 2")
           tf.close
-          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for CMD_TLM_VERSION./)
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ADD_MD5_FILE./)
           tf.unlink
         end
 
-        it "sets the command and telemetry version" do
+        it "complains about missing files" do
           tf = Tempfile.new('unittest')
-          tf.puts("CMD_TLM_VERSION 2.1")
+          tf.puts("ADD_MD5_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 MD5 calculation" do
+          md5f = Tempfile.new('md5_file')
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_MD5_FILE #{File.expand_path(md5f.path)}")
           tf.close
-          expect(System.cmd_tlm_version).to be_nil
           System.instance.process_file(tf.path)
-          expect(System.cmd_tlm_version).to eql "2.1"
+          expect(System.additional_md5_files.include?(File.expand_path(md5f.path))).to be true
+          md5f.close
+          md5f.unlink
           tf.unlink
         end
       end
@@ -680,4 +697,3 @@ module Cosmos
     end
   end
 end
-