openc3 5.0.6

data/lib/openc3/script/suite_results.rb

@@ -0,0 +1,196 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  class SuiteResults
+    attr_accessor :metadata
+
+    def initialize
+      @report = nil
+      @context = nil
+      @start_time = nil
+      @stop_time = nil
+      @results = nil
+      @settings = nil
+      @metadata = nil
+    end
+
+    def start(test_type, test_suite_class, test_class = nil, test_case = nil, settings = nil)
+      @results = []
+      @start_time = Time.now.sys
+      @settings = settings
+      @report = []
+
+      if test_case
+        # Executing a single test case
+        @context = "#{test_suite_class.name}:#{test_class.name}:#{test_case} #{test_type}"
+      elsif test_class
+        # Executing an entire test
+        @context = "#{test_suite_class.name}:#{test_class.name} #{test_type}"
+      else
+        # Executing a test suite
+        @context = "#{test_suite_class.name} #{test_type}"
+      end
+
+      header()
+    end
+
+    # process_result can handle an array of OpenC3TestResult objects
+    # or a single OpenC3TestResult object
+    def process_result(results)
+      openc3_lib = Regexp.new(File.join(OpenC3::PATH, 'lib'))
+      # If we were passed an array we concat it to the results global
+      if results.is_a? Array
+        @results.concat(results)
+      # A single result is appended and then turned into an array
+      else
+        @results << results
+        results = [results]
+      end
+      # Process all the results (may be just one)
+      results.each do |result|
+        self.puts("#{result.group}:#{result.script}:#{result.result}")
+        if result.message
+          result.message.each_line do |line|
+            if /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/.match?(line)
+              line.chomp!
+              line = line.inspect.remove_quotes
+            end
+            @report << '  ' + line.strip
+          end
+        end
+        if result.exceptions
+          @report << "  Exceptions:"
+          result.exceptions.each_with_index do |error, index|
+            error.formatted().each_line do |line|
+              next if /in run_text/.match?(line)
+              next if /running_script.rb/.match?(line)
+              next if line&.match?(openc3_lib)
+
+              if /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/.match?(line)
+                line.chomp!
+                line = line.inspect.remove_quotes
+              end
+              @report << '    ' + line.strip
+            end
+            @report << '' if index != (result.exceptions.length - 1)
+          end
+        end
+      end
+    end
+
+    def complete
+      @stop_time = Time.now.sys
+      footer()
+    end
+
+    def report
+      @report.join("\n")
+    end
+
+    def header
+      @report << "--- Test Report ---"
+      # @report << ''
+      # if @metadata
+      #   begin
+      #     items = get_tlm_packet('SYSTEM', 'META')
+      #     @report << ''
+      #     @report << "Metadata:"
+      #     items.each do |item_name, item_value, _|
+      #       next if SetTlmDialog::IGNORED_ITEMS.include?(item_name)
+      #       @report << "#{item_name} = #{item_value}"
+      #     end
+      #   rescue DRb::DRbConnError
+      #     # Oh well
+      #   end
+      # end
+      if @settings
+        @report << ''
+        @report << "Settings:"
+        @settings.each { |setting_name, setting_value| @report << "#{setting_name} = #{setting_value}" }
+      end
+      @report << ''
+      @report << "Results:"
+      self.puts "Executing #{@context}"
+    end
+
+    def footer
+      self.puts "Completed #{@context}"
+
+      @report << ''
+      @report << "--- Test Summary ---"
+      @report << ''
+
+      pass_count = 0
+      skip_count = 0
+      fail_count = 0
+      stopped    = false
+      @results.each do |result|
+        if result.result == :PASS
+          pass_count += 1
+        elsif result.result == :SKIP
+          skip_count += 1
+        elsif result.result == :FAIL
+          fail_count += 1
+        end
+
+        if result.stopped
+          stopped = true
+        end
+      end
+      run_time = Time.format_seconds(@stop_time - @start_time)
+      run_time << " (#{@stop_time - @start_time} seconds)" if @stop_time - @start_time > 60
+      @report << "Run Time: #{run_time}"
+      @report << "Total Tests: #{@results.length}"
+      @report << "Pass: #{pass_count}"
+      @report << "Skip: #{skip_count}"
+      @report << "Fail: #{fail_count}"
+      @report << ''
+      if stopped
+        @report << '*** Test was stopped prematurely ***'
+        @report << ''
+      end
+    end
+
+    def write(string)
+      @report << Time.now.sys.formatted + ': ' + string
+    end
+
+    def puts(string)
+      @report << Time.now.sys.formatted + ': ' + string
+    end
+
+    # def collect_metadata(parent = nil)
+    #   success = true
+    #   if @metadata
+    #     Qt.execute_in_main_thread(true) do
+    #       begin
+    #         success = SetTlmDialog.execute(parent, 'Enter Test Metadata', 'Start Test', 'Cancel Test', 'SYSTEM', 'META')
+    #       rescue DRb::DRbConnError
+    #         success = false
+    #         Qt::MessageBox.critical(parent, 'Error', 'Error Connecting to Command and Telemetry Server')
+    #       rescue Exception => err
+    #         OpenC3.handle_fatal_exception(err)
+    #       end
+    #     end
+    #   end
+    #   success
+    # end
+  end
+end

data/lib/openc3/script/suite_runner.rb

@@ -0,0 +1,217 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/script/suite'
+require 'openc3/script/suite_results'
+require 'openc3/tools/test_runner/test'
+
+module OpenC3
+  # Placeholder for all Groups discovered without assigned Suites
+  class UnassignedSuite < Suite
+  end
+
+  class SuiteRunner
+    @@suites = []
+    @@settings = {}
+    @@suite_results = nil
+
+    def self.settings
+      @@settings
+    end
+
+    def self.settings=(settings)
+      @@settings = settings
+    end
+
+    def self.suite_results
+      @@suite_results
+    end
+
+    def self.execute(result_string, suite_class, group_class = nil, script = nil)
+      @@suite_results = SuiteResults.new
+      @@suites.each do |suite|
+        if suite.class == suite_class
+          @@suite_results.start(result_string, suite_class, group_class, script, @@settings)
+          loop do
+            yield(suite)
+            break if not @@settings['Loop'] or (ScriptStatus.instance.fail_count > 0 and @@settings['Break Loop On Error'])
+          end
+          break
+        end
+      end
+    end
+
+    def self.start(suite_class, group_class = nil, script = nil)
+      result = []
+      execute('', suite_class, group_class, script) do |suite|
+        if script
+          result = suite.run_script(group_class, script)
+          @@suite_results.process_result(result)
+          raise StopScript if (result.exceptions and Group.abort_on_exception) or result.stopped
+        elsif group_class
+          suite.run_group(group_class) { |current_result| @@suite_results.process_result(current_result); raise StopScript if current_result.stopped }
+        else
+          suite.run { |current_result| @@suite_results.process_result(current_result); raise StopScript if current_result.stopped }
+        end
+      end
+    end
+
+    def self.setup(suite_class, group_class = nil)
+      execute('Manual Setup', suite_class, group_class) do |suite|
+        if group_class
+          result = suite.run_group_setup(group_class)
+        else
+          result = suite.run_setup
+        end
+        if result
+          @@suite_results.process_result(result)
+          raise StopScript if result.stopped
+        end
+      end
+    end
+
+    def self.teardown(suite_class, group_class = nil)
+      execute('Manual Teardown', suite_class, group_class) do |suite|
+        if group_class
+          result = suite.run_group_teardown(group_class)
+        else
+          result = suite.run_teardown
+        end
+        if result
+          @@suite_results.process_result(result)
+          raise StopScript if result.stopped
+        end
+      end
+    end
+
+    # Convert the OpenStruct structure to a simple hash
+    # TODO: Maybe just use hashes right from the beginning?
+    def self.open_struct_to_hash(object)
+      hash = object.to_h
+      hash.each do |key1, val1|
+        if val1.is_a?(Hash)
+          val1.each do |key2, val2|
+            if val2.is_a?(OpenStruct)
+              hash[key1][key2] = val2.to_h
+            end
+          end
+        end
+      end
+      hash
+    end
+
+    # Build list of Suites and Groups
+    def self.build_suites
+      @@suites = []
+      # @@suites = @@suites.select { |my_suite| my_suite.name == 'CustomSuite' }
+      suites = {}
+      groups = []
+      ObjectSpace.each_object(Class) do |object|
+        # If we inherit from Suite but aren't the deprecated TestSuite
+        if object < Suite && object != TestSuite
+          # Ensure they didn't override name for some reason
+          if object.instance_methods(false).include?(:name)
+            raise FatalError.new("#{object} redefined the 'name' method. Delete the 'name' method and try again.")
+          end
+
+          # ObjectSpace.each_object appears to yield objects in the reverse
+          # order that they were parsed by the interpreter so push each
+          # Suite object to the front of the array to order as encountered
+          @@suites.unshift(object.new)
+        end
+        # If we inherit from Group but aren't the deprecated Test
+        if object < Group && object != Test
+          # Ensure they didn't override self.name for some reason
+          if object.methods(false).include?(:name)
+            raise FatalError.new("#{object} redefined the 'self.name' method. Delete the 'self.name' method and try again.")
+          end
+
+          groups << object
+        end
+      end
+      # Raise error if no suites or groups
+      if @@suites.empty? || groups.empty?
+        return "No Suite or no Group classes found"
+      end
+
+      # Create Suite for unassigned Groups
+      @@suites.each do |suite|
+        groups_to_delete = []
+        groups.each { |group| groups_to_delete << group if suite.scripts[group] }
+        groups_to_delete.each { |group| groups.delete(group) }
+      end
+      if groups.empty?
+        @@suites = @@suites.select { |suite| suite.class != UnassignedSuite }
+      else
+        unassigned_suite = @@suites.select { |suite| suite.class == UnassignedSuite }[0]
+        groups.each { |group| unassigned_suite.add_group(group) }
+      end
+
+      @@suites.each do |suite|
+        cur_suite = OpenStruct.new(:setup => false, :teardown => false, :groups => {})
+        cur_suite.setup = true if suite.class.method_defined?(:setup)
+        cur_suite.teardown = true if suite.class.method_defined?(:teardown)
+
+        suite.plans.each do |type, group_class, script|
+          case type
+          when :GROUP
+            cur_suite.groups[group_class.name] ||=
+              OpenStruct.new(:setup => false, :teardown => false, :scripts => [])
+            cur_suite.groups[group_class.name].scripts.concat(group_class.scripts)
+            cur_suite.groups[group_class.name].scripts.uniq!
+            cur_suite.groups[group_class.name].setup = true if group_class.method_defined?(:setup)
+            cur_suite.groups[group_class.name].teardown = true if group_class.method_defined?(:teardown)
+          when :SCRIPT
+            cur_suite.groups[group_class.name] ||=
+              OpenStruct.new(:setup => false, :teardown => false, :scripts => [])
+            # Explicitly check for this method and raise an error if it does not exist
+            if group_class.method_defined?(script.intern)
+              cur_suite.groups[group_class.name].scripts << script
+              cur_suite.groups[group_class.name].scripts.uniq!
+            else
+              raise "#{group_class} does not have a #{script} method defined."
+            end
+            cur_suite.groups[group_class.name].setup = true if group_class.method_defined?(:setup)
+            cur_suite.groups[group_class.name].teardown = true if group_class.method_defined?(:teardown)
+          when :GROUP_SETUP
+            cur_suite.groups[group_class.name] ||=
+              OpenStruct.new(:setup => false, :teardown => false, :scripts => [])
+            # Explicitly check for the setup method and raise an error if it does not exist
+            if group_class.method_defined?(:setup)
+              cur_suite.groups[group_class.name].setup = true
+            else
+              raise "#{group_class} does not have a setup method defined."
+            end
+          when :GROUP_TEARDOWN
+            cur_suite.groups[group_class.name] ||=
+              OpenStruct.new(:setup => false, :teardown => false, :scripts => [])
+            # Explicitly check for the teardown method and raise an error if it does not exist
+            if group_class.method_defined?(:teardown)
+              cur_suite.groups[group_class.name].teardown = true
+            else
+              raise "#{group_class} does not have a teardown method defined."
+            end
+          end
+        end
+        suites[suite.name.split('::')[-1]] = open_struct_to_hash(cur_suite) unless suite.name == 'CustomSuite'
+      end
+      return suites
+    end
+  end
+end

data/lib/openc3/script.rb

@@ -0,0 +1,21 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/script/script'
+include OpenC3::Script

data/lib/openc3/streams/serial_stream.rb

@@ -0,0 +1,167 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'thread' # For Mutex
+require 'openc3/streams/stream'
+require 'openc3/config/config_parser'
+require 'openc3/io/serial_driver'
+
+module OpenC3
+  # Stream that reads and writes to serial ports by using {SerialDriver}.
+  class SerialStream < Stream
+    # @param write_port_name [String] The name of the serial port to write.
+    #   Pass nil if the stream is to be read only. On Windows the port name
+    #   is typically 'COMX' where X can be any port number. On UNIX the port
+    #   name is typically a device such as '/dev/ttyS0'.
+    # @param read_port_name [String] The name of the serial port to read.
+    #   Pass nil if the stream is to be read only. On Windows the port name
+    #   is typically 'COMX' where X can be any port number. On UNIX the port
+    #   name is typically a device such as '/dev/ttyS0'.
+    # @param baud_rate [Integer] The serial port baud rate
+    # @param parity [Symbol] Must be :NONE, :EVEN, or :ODD
+    # @param stop_bits [Integer] Number of stop bits. Must be 1 or 2.
+    # @param write_timeout [Integer] Number of seconds to wait for the write to
+    #   complete. Pass nil to create no timeout. The {SerialDriver} will
+    #   continously try to send the data until it has been sent or an error
+    #   occurs.
+    # @param read_timeout [Integer] Number of seconds to wait for the read to
+    #   complete. Pass nil to create no timeout. The {SerialDriver} will
+    #   continously try to read data until it has received data or an error
+    #   occurs.
+    # @param flow_control [Symbol] Currently supported :NONE and :RTSCTS (default :NONE)
+    # @param data_bits [Integer] Number of data bits (default 8)
+    def initialize(write_port_name,
+                   read_port_name,
+                   baud_rate,
+                   parity,
+                   stop_bits,
+                   write_timeout,
+                   read_timeout,
+                   flow_control = :NONE,
+                   data_bits = 8)
+      super()
+
+      # The SerialDriver class will validate the parameters
+      @write_port_name = ConfigParser.handle_nil(write_port_name)
+      @read_port_name  = ConfigParser.handle_nil(read_port_name)
+      @baud_rate       = Integer(baud_rate)
+      @parity          = parity
+      @stop_bits       = stop_bits.to_i
+      @write_timeout   = ConfigParser.handle_nil(write_timeout)
+      @write_timeout   = @write_timeout.to_f if @write_timeout
+      @read_timeout    = ConfigParser.handle_nil(read_timeout)
+      @read_timeout    = @read_timeout.to_f if @read_timeout
+      @flow_control    = flow_control.to_s.intern
+      @data_bits       = data_bits.to_i
+
+      if @write_port_name
+        @write_serial_port = SerialDriver.new(@write_port_name,
+                                              @baud_rate,
+                                              @parity,
+                                              @stop_bits,
+                                              @write_timeout,
+                                              @read_timeout,
+                                              @flow_control,
+                                              @data_bits)
+      else
+        @write_serial_port = nil
+      end
+      if @read_port_name
+        if @read_port_name == @write_port_name
+          @read_serial_port = @write_serial_port
+        else
+          @read_serial_port = SerialDriver.new(@read_port_name,
+                                               @baud_rate,
+                                               @parity,
+                                               @stop_bits,
+                                               @write_timeout,
+                                               @read_timeout,
+                                               @flow_control,
+                                               @data_bits)
+        end
+      else
+        @read_serial_port = nil
+      end
+      if @read_serial_port.nil? && @write_serial_port.nil?
+        raise "Either a write port or read port must be given"
+      end
+
+      # We 'connect' when we create the stream
+      @connected = true
+
+      # Mutex on write is needed to protect from commands coming in from more
+      # than one tool
+      @write_mutex = Mutex.new
+    end
+
+    # @return [String] Returns a binary string of data from the serial port
+    def read
+      raise "Attempt to read from write only stream" unless @read_serial_port
+
+      # No read mutex is needed because reads happen serially
+      @read_serial_port.read
+    end
+
+    # @return [String] Returns a binary string of data from the serial port without blocking
+    def read_nonblock
+      raise "Attempt to read from write only stream" unless @read_serial_port
+
+      # No read mutex is needed because reads happen serially
+      @read_serial_port.read_nonblock
+    end
+
+    # @param data [String] A binary string of data to write to the serial port
+    def write(data)
+      raise "Attempt to write to read only stream" unless @write_serial_port
+
+      @write_mutex.synchronize do
+        @write_serial_port.write(data)
+      end
+    end
+
+    # Connect the stream
+    def connect
+      # N/A - Serial streams 'connect' on creation
+    end
+
+    # @return [Boolean] Whether the serial stream is connected to the serial
+    #   port
+    def connected?
+      @connected
+    end
+
+    # Disconnect by closing the serial ports
+    def disconnect
+      if @connected
+        begin
+          @write_serial_port.close if @write_serial_port && !@write_serial_port.closed?
+        rescue IOError
+          # Ignore
+        end
+
+        begin
+          @read_serial_port.close if @read_serial_port && !@read_serial_port.closed?
+        rescue IOError
+          # Ignore
+        end
+        @connected = false
+      end
+    end
+  end # class SerialStream
+end

data/lib/openc3/streams/stream.rb

@@ -0,0 +1,63 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  # Class that implments the following methods: read, write(data),
+  # connect, connected? and disconnect. Streams are simply data sources which
+  # {Protocol} classes read and write to. This separation of concerns
+  # allows Streams to simply focus on getting and sending raw data while the
+  # higher level processing occurs in {Protocol}.
+  class Stream
+    # Expected to return any amount of data on success, or a blank string on
+    # closed/EOF, and may raise Timeout::Error, or other errors
+    def read
+      raise "read not defined by Stream"
+    end
+
+    # Expected to always return immediately with data if available or an empty string.
+    # Should not raise errors
+    def read_nonblock
+      raise "read_nonblock not defined by Stream"
+    end
+
+    # Expected to write complete set of data.  May raise Timeout::Error
+    # or other errors.
+    #
+    # @param data [String] Binary data to write to the stream
+    def write(data)
+      raise "write not defined by Stream"
+    end
+
+    # Connects the stream
+    def connect
+      raise "connect not defined by Stream"
+    end
+
+    # @return [Boolean] true if connected or false otherwise
+    def connected?
+      raise "connected? not defined by Stream"
+    end
+
+    # Disconnects the stream
+    # Note that streams are not designed to be reconnected and must be recreated
+    def disconnect
+      raise "disconnect not defined by Stream"
+    end
+  end # class Stream
+end