cosmos 3.9.2 → 4.0.0

data/spec/tools/cmd_tlm_server/commanding_spec.rb

@@ -37,25 +37,25 @@ module Cosmos
         config = CmdTlmServerConfig.new(tf.path)
         cmd = Commanding.new(config)
         interfaces = Interfaces.new(config)
-        interfaces.map_target("COSMOS","MY_INT")
+        interfaces.map_target("SYSTEM","MY_INT")
         expect(interfaces.all["MY_INT"]).to receive(:write)
         expect(interfaces.all["MY_INT"].packet_log_writer_pairs[0].cmd_log_writer).to receive(:write)
 
         # Grab an existing packet
-        pkt = System.commands.packet('COSMOS','STARTLOGGING')
+        pkt = System.commands.packet('SYSTEM','STARTLOGGING')
         # Restore defaults so it can be identified
         pkt.restore_defaults
         # Set the target_name to nil to make it "unidentified"
         pkt.target_name = nil
 
-        count = System.targets['COSMOS'].cmd_cnt
-        cmd.send_command_to_target('COSMOS', pkt)
-        # Verify the COSMOS STARTLOGGING packet has been updated
-        expect(System.commands.packet("COSMOS","STARTLOGGING").buffer).to eql pkt.buffer
+        count = System.targets['SYSTEM'].cmd_cnt
+        cmd.send_command_to_target('SYSTEM', pkt)
+        # Verify the SYSTEM STARTLOGGING packet has been updated
+        expect(System.commands.packet("SYSTEM","STARTLOGGING").buffer).to eql pkt.buffer
         # Verify the target count didn't get updated
-        expect(System.targets['COSMOS'].cmd_cnt).to eq count
+        expect(System.targets['SYSTEM'].cmd_cnt).to eq count
         # Restore target name
-        pkt.target_name = 'COSMOS'
+        pkt.target_name = 'SYSTEM'
         tf.unlink
       end
 
@@ -66,18 +66,18 @@ module Cosmos
         config = CmdTlmServerConfig.new(tf.path)
         cmd = Commanding.new(config)
         interfaces = Interfaces.new(config)
-        interfaces.map_target("COSMOS","MY_INT")
+        interfaces.map_target("SYSTEM","MY_INT")
         expect(interfaces.all["MY_INT"]).to receive(:write)
         expect(interfaces.all["MY_INT"].packet_log_writer_pairs[0].cmd_log_writer).to receive(:write)
 
         # Grab an existing packet
-        pkt = System.commands.packet('COSMOS','STARTLOGGING')
+        pkt = System.commands.packet('SYSTEM','STARTLOGGING')
 
-        count = System.targets['COSMOS'].cmd_cnt
-        cmd.send_command_to_target('COSMOS', pkt)
-        # Verify the COSMOS STARTLOGGING packet has been updated
-        expect(System.commands.packet("COSMOS","STARTLOGGING").buffer).to eql pkt.buffer
-        expect(System.targets['COSMOS'].cmd_cnt).to eq count + 1
+        count = System.targets['SYSTEM'].cmd_cnt
+        cmd.send_command_to_target('SYSTEM', pkt)
+        # Verify the SYSTEM STARTLOGGING packet has been updated
+        expect(System.commands.packet("SYSTEM","STARTLOGGING").buffer).to eql pkt.buffer
+        expect(System.targets['SYSTEM'].cmd_cnt).to eq count + 1
         tf.unlink
       end
 
@@ -93,18 +93,18 @@ module Cosmos
         config = CmdTlmServerConfig.new(tf.path)
         cmd = Commanding.new(config)
         interfaces = Interfaces.new(config)
-        interfaces.map_target("COSMOS","MY_INT")
+        interfaces.map_target("SYSTEM","MY_INT")
         expect(interfaces.all["MY_INT"]).to receive(:write)
         expect(interfaces.all["MY_INT"].packet_log_writer_pairs[0].cmd_log_writer).to receive(:write)
 
         # Grab an existing packet
-        pkt = System.commands.packet('COSMOS','STARTLOGGING')
+        pkt = System.commands.packet('SYSTEM','STARTLOGGING')
         # Mess up the opcode so it won't be identifyable
         pkt.write('OPCODE',100)
         # Set the target_name to nil to make it "unidentified"
         pkt.target_name = nil
 
-        cmd.send_command_to_target('COSMOS', pkt)
+        cmd.send_command_to_target('SYSTEM', pkt)
         # Verify the unknown packet has been updated
         expect(System.commands.packet("UNKNOWN","UNKNOWN").buffer).to eql pkt.buffer
         tf.unlink

data/spec/tools/cmd_tlm_server/interface_thread_spec.rb

@@ -59,10 +59,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
 
           expect(stdout.string).to match "Connection Failed: RuntimeError : ConnectError"
         end
@@ -74,8 +82,8 @@ module Cosmos
           allow(@interface).to receive(:connect) { raise "ConnectError" }
           # Make the reconnect_delay be slightly longer than half of 0.1 which is
           # how long the test is waiting after calling start. This allows us to
-          # create see the error twice.
-          @interface.reconnect_delay = 0.06
+          # see the error twice.
+          @interface.reconnect_delay = 0.15
           thread = InterfaceThread.new(@interface)
           error_count = 0
           thread.connection_failed_callback = Proc.new do |error|
@@ -83,11 +91,19 @@ module Cosmos
             error_count += 1
           end
           thread.start
-          sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          sleep 0.2
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
           expect(error_count).to eql 2
 
           expect(stdout.string).not_to match "Connection Failed: ConnectError"
@@ -99,10 +115,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
 
           expect(stdout.string).to match "Connection Success"
         end
@@ -117,10 +141,18 @@ module Cosmos
           end
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
           expect(callback_called).to be true
 
           expect(stdout.string).not_to match "Connection Success"
@@ -137,10 +169,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
 
           expect(stdout.string).to match "Connection Lost"
         end
@@ -159,10 +199,18 @@ module Cosmos
           sleep 1
           # Since we set auto_reconnect to false we shouldn't see the interface
           # thread because it will be killed
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
           expect(callback_called).to be true
 
           expect(stdout.string).not_to match "Connection Lost"
@@ -175,11 +223,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
-
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
           expect(stdout.string).to match "ReadError"
         end
       end
@@ -194,10 +249,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
 
           expect(stdout.string).to match "ECONNRESET"
         end
@@ -241,10 +304,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
 
           expect(stdout.string).to match "Unknown 2 byte packet"
         end
@@ -258,10 +329,19 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
           expect(stdout.string).to match "Received unknown identified telemetry: BOB SMITH"
         end
       end
@@ -277,10 +357,18 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          expect(Thread.list.length).to eql(2)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(2)
+          else
+            expect(Thread.list.length).to eql(3)
+          end
           thread.stop
           sleep 0.2
-          expect(Thread.list.length).to eql(1)
+          if RUBY_ENGINE == 'ruby'
+            expect(Thread.list.length).to eql(1)
+          else
+            expect(Thread.list.length).to eql(2)
+          end
 
           expect(stdout.string).to match "Problem writing to router"
         end
@@ -294,13 +382,20 @@ module Cosmos
         threads = Thread.list.length
         thread.start
         sleep 0.1
-        expect(Thread.list.length).to eql(2)
+        if RUBY_ENGINE == 'ruby'
+          expect(Thread.list.length).to eql(2)
+        else
+          expect(Thread.list.length).to eql(3)
+        end
         thread.stop
         sleep 0.2
-        expect(Thread.list.length).to eql(1)
+        if RUBY_ENGINE == 'ruby'
+          expect(Thread.list.length).to eql(1)
+        else
+          expect(Thread.list.length).to eql(2)
+        end
       end
 
     end
   end
 end
-

data/spec/tools/cmd_tlm_server/interfaces_spec.rb

@@ -77,8 +77,8 @@ module Cosmos
         tf.puts 'INTERFACE MY_INT interface.rb'
         tf.close
         interfaces = Interfaces.new(CmdTlmServerConfig.new(tf.path))
-        interfaces.map_target("COSMOS","MY_INT")
-        expect(System.targets["COSMOS"].interface.name).to eql "MY_INT"
+        interfaces.map_target("SYSTEM","MY_INT")
+        expect(System.targets["SYSTEM"].interface.name).to eql "MY_INT"
         tf.unlink
       end
     end

data/spec/tools/cmd_tlm_server/limits_groups_background_task_spec.rb

@@ -0,0 +1,145 @@
+# 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'
+require 'cosmos/tools/cmd_tlm_server/limits_groups_background_task'
+
+module Cosmos
+  describe LimitsGroupsBackgroundTask do
+    before(:each) do
+      (1..4).each do |i|
+        System.telemetry.packet("INST","HEALTH_STATUS").get_item("TEMP#{i}").limits.enabled = true
+      end
+    end
+
+    describe "initialize" do
+      it "initializes local variables" do
+        b1 = LimitsGroupsBackgroundTask.new
+        expect(b1.name).to eq "Limits Groups"
+        expect(b1.thread).to be_nil
+        expect(b1.status).to eq ''
+        expect(b1.stopped).to eq false
+        expect(b1.groups).to eq %w(FIRST SECOND)
+      end
+    end
+
+    describe "call" do
+      it "raises an error if the group is not defined" do
+        class MyLimitsGroups1 < LimitsGroupsBackgroundTask
+          def check_blah
+          end
+        end
+        expect { MyLimitsGroups1.new.call }.to raise_error(/check_blah doesn't match a group name/)
+      end
+
+      it "requires a floating point delay parameter" do
+        class MyLimitsGroups1 < LimitsGroupsBackgroundTask
+        end
+        expect { MyLimitsGroups1.new("HI") }.to raise_error(/invalid value for Float/)
+      end
+
+      it "delays before processing the groups" do
+        class MyLimitsGroups2 < LimitsGroupsBackgroundTask
+          attr_accessor :called
+          def check_first
+            @called = Time.now
+          end
+        end
+        my = MyLimitsGroups2.new(2.1)
+        thread = Thread.new do
+          my.call
+        end
+        sleep 2.2
+        expect(Time.now - my.called).to be < 0.15
+        Cosmos.kill_thread(self, thread)
+      end
+
+      it "processes the check methods at 1Hz" do
+        class MyLimitsGroups3 < LimitsGroupsBackgroundTask
+          attr_accessor :first_count, :second_count, :on_logic, :off_logic
+          def initialize
+            super()
+            @first_count = 0
+            @second_count = 0
+            @on_logic = false
+            @off_logic = false
+            @on = Proc.new { @on_logic = true }
+            @off = Proc.new { @off_logic = true }
+          end
+          def check_first
+            @first_count += 1
+            process_group(2, @on, @off) do
+              @first_count <= 4 ? true : false
+            end
+          end
+          def check_second
+            @second_count += 1
+            process_group { false } # Never enable
+          end
+        end
+        my = MyLimitsGroups3.new
+        thread = Thread.new do
+          my.call
+        end
+        sleep 0.1
+        p = System.telemetry.packet("INST","HEALTH_STATUS")
+        # First group is enabled
+        expect(p.get_item("TEMP1").limits.enabled).to be true
+        expect(p.get_item("TEMP3").limits.enabled).to be true
+        # Second group is disabled
+        expect(p.get_item("TEMP2").limits.enabled).to be false
+        expect(p.get_item("TEMP4").limits.enabled).to be false
+        expect(my.on_logic).to be false
+        expect(my.off_logic).to be false
+        # Things not in a group are enabled
+        expect(p.get_item("GROUND1STATUS").limits.enabled).to be true
+        expect(p.get_item("GROUND2STATUS").limits.enabled).to be true
+
+        sleep 3.1 # Allow the logic to enable
+        expect(p.get_item("TEMP1").limits.enabled).to be true
+        expect(p.get_item("TEMP3").limits.enabled).to be true
+        expect(p.get_item("TEMP2").limits.enabled).to be false
+        expect(p.get_item("TEMP4").limits.enabled).to be false
+        expect(my.on_logic).to be true # on logic was called
+        expect(my.off_logic).to be false # off logic not yet called
+
+        sleep 2.1 # Allow the logic to disable
+        expect(p.get_item("TEMP1").limits.enabled).to be false
+        expect(p.get_item("TEMP3").limits.enabled).to be false
+        expect(p.get_item("TEMP2").limits.enabled).to be false
+        expect(p.get_item("TEMP4").limits.enabled).to be false
+        expect(my.on_logic).to be true
+        expect(my.off_logic).to be true # off logic called
+
+        Cosmos.kill_thread(self, thread)
+        expect(my.first_count).to be >= 5
+        expect(my.second_count).to be >= 5
+      end
+
+      it "reports how long it took to process" do
+        class MyLimitsGroups4 < LimitsGroupsBackgroundTask
+          def check_first
+            sleep 0.2
+          end
+        end
+
+        Thread.abort_on_exception = true
+        my = MyLimitsGroups4.new
+        thread = Thread.new do
+          my.call
+        end
+        sleep 0.3
+        expect(my.status).to match /Checking groups took 0.\d+/
+        Cosmos.kill_thread(self, thread)
+      end
+    end
+  end
+end