teuton 3.2.1 → 3.4.0

data/docs/learn/32-event-zero.md

@@ -0,0 +1,127 @@
+[<<back](../../README.md)
+
+# Event: scores to zero
+
+We are going to create an event that triggers when the last target fails, and which sets all the scores for the targets already evaluated to zero.
+
+```ruby
+event on: :last_target, when: failed do
+  scores_to_zero
+end
+```
+
+## Example
+
+In this example, we have 4 targets, all of which will function correctly except for target 3.
+
+```ruby
+group "Events: scores_to_zero" do
+  target "Target 1: ok"
+  run "id root"
+  expect_ok
+
+  target "Target 2: ok"
+  run "id root"
+  expect_ok
+
+  target "Target 3: fail"
+  run "id vader"
+  expect_ok
+
+  event on: :last_target, when: :failed do
+    scores_to_zero
+  end
+
+  target "Target 4: ok"
+  run "id root"
+  expect_ok
+end
+```
+
+The event, before target 3, is defined to trigger the `scores_to_zero` action when target fails.
+
+The action resets the values ​​of all already-evaluated targets to zero.
+
+## Report output
+
+```
+$ teuton examples/32-event-zero
+
+ ☰ CASE RESULTS
+┌──────┬──────────┬───────┬───────┐
+│ CASE │ MEMBERS  │ GRADE │ STATE │
+│ 01   │ TOCHANGE │ 25.0  │ ?     │
+└──────┴──────────┴───────┴───────┘
+```
+
+Process:
+* target 1 is Ok.
+* target 2 is Ok.
+* target 3 fails so the `scores_to_zero` action is triggered. Targets 1 and 2 are reset to zero.
+* target 4 is Ok.
+
+```
+$ cat var/32-event-zero/case-01.txt 
+
+ ⚒ CONFIGURATION
+┌────────────────┬────────────────────────────────────┐
+│ tt_config_path │ examples/32-event-zero/config.yaml │
+│ tt_members     │ TOCHANGE                           │
+│ tt_script_path │ examples/32-event-zero/start.rb    │
+│ tt_sequence    │ false                              │
+│ tt_skip        │ false                              │
+└────────────────┴────────────────────────────────────┘
+
+ 🛈 LOGS
+   [16:27:47]  INFO| Event[0] triggered because target[3] failed
+   [16:27:47]  INFO| Scores READJUSTED!
+
+ ☰ GROUPS
+ ▶ Events: scores_to_zero
+   ✔ 01 (0.0/1.0)   ┌──
+        Description │ Target 1: ok (SCORE TO ZERO)
+        Command     │ id root
+        Output      │ uid=0(root) gid=0(root) grupos=0(root)
+        Duration    │ 0.002 (local)
+        Alterations │ Read exit code
+        Expected    │ 0
+        Result      │ 0
+   ✔ 02 (0.0/1.0)   ├──
+        Description │ Target 2: ok (SCORE TO ZERO)
+        Command     │ id root
+        Output      │ uid=0(root) gid=0(root) grupos=0(root)
+        Duration    │ 0.001 (local)
+        Alterations │ Read exit code
+        Expected    │ 0
+        Result      │ 0
+   ✖ 03 (0.0/1.0)   ├──
+        Description │ Target 3: fail (SCORE TO ZERO)
+        Command     │ id vader
+        Output      │ id: «vader»: no existe ese usuario
+        Duration    │ 0.002 (local)
+        Alterations │ Read exit code
+        Expected    │ 0
+        Result      │ 1
+   ✔ 04 (1.0/1.0)   ├──
+        Description │ Target 4: ok
+        Command     │ id root
+        Output      │ uid=0(root) gid=0(root) grupos=0(root)
+        Duration    │ 0.001 (local)
+        Alterations │ Read exit code
+        Expected    │ 0
+        Result      │ 0
+                    └──
+ 🗹 RESULTS
+┌──────────────┬───────────────────────────┐
+│ unique_fault │ 0                         │
+│ case_id      │ 01                        │
+│ start_time   │ 2026-10-30 16:27:47 +0000 │
+│ finish_time  │ 2026-10-30 16:27:47 +0000 │
+│ duration     │ 0.006894103               │
+│ max_weight   │ 4.0                       │
+│ good_weight  │ 3.0                       │
+│ fail_weight  │ 1.0                       │
+│ fail_counter │ 1                         │
+│ grade        │ 25                        │
+└──────────────┴───────────────────────────┘
+```

data/docs/more.md

@@ -9,7 +9,10 @@
 
 # Videos
 
-> By now there are no English videos. We are sorry!
+> By now there are no English videos. Sorry!
+
+Teuton v3.0:
+* [RubySur Agosto 2026 - Test de Infraestructura Teuton](https://www.youtube.com/live/JW4T3cTyG5A?si=bt356lypKlrr_YLK)
 
 Teuton v2.1:
 * [Apuntes FP Informática - I Congreso Virtual - Mayo 2020](https://youtu.be/RxIV26BAoGo)

data/lib/teuton/case/{action.rb → action/action.rb}

@@ -1,30 +1,38 @@
 class Case
   class Action
     attr_reader :id
-    attr_accessor :groupname, :description, :weight, :asset,
-      :command, :encoding, :host, :exec, :conn_type, :duration,
-      :result, :output, :alterations, :expected, :check
+    attr_accessor :groupname, :description, :weight,
+      :command, :encoding, :host, :exec,
+      :conn_type, :duration,
+      :result, :output,
+      :alterations, :expected, :check
+    attr_writer :score
 
-    def initialize
-      @id = 0
+    def initialize(id = 1)
+      @id = id
       @groupname = nil
       @description = "No description!"
       @weight = 1.0
+      @check = false
+      @score = nil
     end
 
-    def next
-      @id += 1
-      self
+    def score
+      return @score unless @score.nil?
+      return 0.0 if @check == false
+
+      @weight
     end
 
     def to_h
       {
         id: id,
-        groupname: groupname, description: description, weight: weight, asset: asset,
+        groupname: groupname, description: description, weight: weight,
         command: command, encoding: encoding, host: host, exec: exec,
         conn_type: conn_type, duration: duration,
         result: result, output: output,
-        alterations: alterations, expected: expected, check: check
+        alterations: alterations, expected: expected, check: check,
+        score: score
       }
     end
   end

data/lib/teuton/case/action/manager.rb

@@ -0,0 +1,198 @@
+require_relative "action"
+
+class Case
+  class ActionManager
+    AVAILABLE = [
+      %i[last_target failed now],
+      %i[last_target passed now],
+      %i[every_target failed eachtime],
+      %i[every_target passed eachtime],
+      %i[all_targets failed atend],
+      %i[all_targets passed atend]
+    ].freeze
+    attr_reader :actions, :events, :current_action
+    attr_writer :log
+
+    def initialize
+      @current_action = nil
+      @actions = []
+      @events = []
+      @stopped = false
+      @log = nil
+    end
+
+    def check_event(args)
+      object = args[:on]
+      condition = args[:when]
+      options = AVAILABLE.select { |obj, cond| obj == object && cond == condition }
+      if options.empty?
+        Logger.warn "Unkown! Event on: #{object}, when: #{condition}"
+        return false
+      elsif options.count > 1
+        Logger.warn "More than one definition! Event on: #{object}, when: #{condition}"
+      end
+      true
+    end
+
+    def add_event(args, block)
+      return unless check_event(args)
+
+      object = args[:on]
+      condition = args[:when]
+      if object == :last_target
+        trigger_on_last_target(args, block)
+      elsif object == :all_targets
+        trigger_on_all_targets(args, block)
+      else
+        id = events.count
+        events << {id: id, args: args, block: block, type: :eachtime}
+        log "Register (sinde target #{last_action.id}) event on: #{object} , when: #{condition}"
+      end
+    end
+
+    def close(report)
+      trigger_events!
+      @current_action = nil
+
+      # Calculate final values
+      @grade = @max_weight = @good_weight = @fails_weight = @fail_counter = 0
+      @history = ""
+
+      @actions.each do |action|
+        @max_weight += action.weight if action.weight.positive?
+
+        if action.check
+          @good_weight += action.weight
+          @history += Settings.letter[:good]
+        else
+          @fails_weight += action.weight
+          @fail_counter += 1
+          @history += Settings.letter[:fail]
+        end
+      end
+
+      report.lines += @actions.map(&:to_h)
+      report.history = @history
+
+      report.tail[:max_weight] = @max_weight
+      report.tail[:good_weight] = @good_weight
+      report.tail[:fail_weight] = @fails_weight
+      report.tail[:fail_counter] = @fail_counter
+      report.tail[:grade] = calculate_grade(report)
+    end
+
+    def last_action
+      @actions.last
+    end
+
+    def next_action
+      if @current_action.nil?
+        @current_action = Action.new(1)
+        return @current_action
+      end
+
+      @actions << @current_action
+      @current_action = Action.new(last_action.id + 1)
+      @current_action.groupname = last_action.groupname
+      @current_action.description = last_action.description
+      @current_action
+    end
+
+    def current_score
+      current_good_weight = @actions.sum(&:score)
+      value = current_good_weight.to_f / @max_weight
+      value = 0.0 if value.nan?
+      value
+    end
+
+    def stopped?
+      @stopped
+    end
+
+    def scores_to_zero
+      @actions.each do |action|
+        action.score = 0.0
+        action.description << " (SCORE TO ZERO)"
+      end
+      log("Scores set to ZERO!")
+    end
+
+    def stop
+      @stopped = true
+      log("Test STOPPED!")
+    end
+
+    def to_h
+      @actions.map { _1.to_h }
+    end
+
+    def trigger_events!
+      @events.each do |event|
+        # TODO: Do something if type == :eachtime
+      end
+
+      return unless @stopped
+
+      @current_action.description = "TEST STOPPED!"
+      @current_action.command = ""
+      @current_action.exec = ""
+      @current_action.conn_type = "?"
+      @current_action.duration = "?"
+      @current_action.result = ""
+      @current_action.output = ""
+      @current_action.alterations = ""
+      @current_action.expected = ""
+      @current_action.check = false
+      @current_action.score = 0.0
+    end
+
+    private
+
+    def log(...)
+      return if @log.nil?
+
+      @log.call(...)
+    end
+
+    def calculate_grade(report)
+      current_good_weight = @actions.sum(&:score)
+      current_score = current_good_weight.to_f / @max_weight
+      current_score = 0.0 if current_score.nan?
+
+      @grade = (100.0 * current_score).round
+
+      @grade = 0.0 if report.tail[:unique_fault].positive?
+      @grade
+    end
+
+    def trigger_on_last_target(args, block)
+      do_ok = last_action.check && args[:when] == :is_ok
+      do_failed = !last_action.check && args[:when] == :failed
+      unless do_ok || do_failed
+        id = events.count
+        events << {id: id, args: args, block: block, status: :cancelled}
+        log "Event[#{id}] cancelled because target[#{last_action.id}] #{args[:when]}"
+      end
+      id = events.count
+      events << {id: id, args: args, block: block, status: :triggered}
+      log "Event[#{id}] triggered because target[#{last_action.id}] #{args[:when]}"
+      instance_exec(**args, &block) if block
+    end
+
+    def trigger_on_all_targets(args, block)
+      all_targets_passed = @actions.map { _1.check }.all?
+      do_all_passed = all_targets_passed && args[:when] == :is_ok
+      all_targets_failed = @actions.map { !_1.check }.all?
+      do_all_failed = all_targets_failed && args[:when] == :failed
+      unless do_all_passed || do_all_failed
+        id = events.count
+        events << {id: id, args: args, block: block, status: :cancelled}
+        log "Event[#{id}] cancelled. Not all_targets[1, #{last_action.id}] #{args[:when]}"
+      end
+      id = events.count
+      events << {id: id, args: args, block: block, status: :triggered}
+      log "Event[#{id}] triggered. All_targets[1, #{last_action.id}] #{args[:when]}"
+      instance_exec(**args, &block) if block
+    end
+  end
+end

data/lib/teuton/case/case.rb

@@ -4,7 +4,8 @@ require_relative "../utils/project"
 require_relative "../utils/verbose"
 require_relative "../report/report"
 require_relative "dsl/all"
-require_relative "action"
+# require_relative "action/action"
+require_relative "action/manager"
 require_relative "config"
 require_relative "close"
 # require_relative "builtin/main"
@@ -16,12 +17,11 @@ class Case
   include DSL
   include Verbose
 
-  # Updated by ExecuteManager
+  # INFO: Used by ExecuteManager
   attr_accessor :action, :result, :sessions, :conn_status
-  # Readed by ExecuteManager
-  attr_reader :id, :config, :uniques, :skip
+  attr_reader :id, :config, :uniques, :skip, :action_manager
 
-  @current_case_id = "00" # First case ID value
+  @current_case_id = Project.value[:base_case_id]
 
   def self.next_id
     @current_case_id = @current_case_id.next
@@ -32,12 +32,9 @@ class Case
       local: config,
       global: Project.value[:global]
     )
-    @groups = Project.value[:groups]
     @id = Case.next_id
-
-    # Define Case Report
+    @groups = Project.value[:groups]
     @report = Report.new(@id)
-    @report.output_dir = Project.value[:output_dir]
 
     # Default configuration
     @skip = false
@@ -46,13 +43,14 @@ class Case
       @skip = true
       @skip = false if Project.value[:options]["case"].include? @id.to_i
     end
-    @verbose = Project.value[:verbose]
-
     @tempdir = File.join(Project.value[:output_dir], "tmp", @id.to_s)
+    @verbose = Project.value[:verbose]
 
     @unique_values = {}
     @result = Result.new
-    @action = Action.new
+    @action_manager = ActionManager.new
+    @action_manager.log = method(:log)
+    @action = @action_manager.next_action
     @uniques = []
     @sessions = {} # Store opened sessions for this case
     @conn_status = {}
@@ -65,7 +63,6 @@ class Case
   end
 
   def filename
-    # called from: close_main_report
     @report.filename
   end
 
@@ -73,6 +70,11 @@ class Case
     return 0.0 if skip
 
     @report.tail[:grade]
+    # @action_manager.score
+  end
+
+  def last_action
+    @action_manager.actions.last
   end
 
   def members

data/lib/teuton/case/close.rb

@@ -3,25 +3,25 @@
 class Case
   def close(uniques)
     # Invoked from check_cases!
+    @action_manager.close(@report)
 
     fails = 0
-    uniques.each do |key|
-      next unless uniques[key].include?(id) && uniques[key].count > 1
+    uniques.each_pair do |key, values|
+      next unless values&.include?(id) && (values&.count&.> 1)
 
       fails += 1
-      log_unique_message(key, uniques[key])
+      log_unique_message(key, values)
     end
     @report.tail[:unique_fault] = fails
-    @report.close
   end
 
   private
 
   def log_unique_message(key, value)
-    log("UNIQUE:", :error)
+    log("UNIQUE:", :warn)
     begin
-      log("   ├── Value     => #{key}", :error)
-      log("   └── Conflicts => #{value}", :error)
+      log("  ├── Value     => #{key}", :warn)
+      log("  └── Conflicts => #{value}", :warn)
     rescue => e
       log(key, :error)
       log(e.to_s, :error)

data/lib/teuton/case/dsl/all.rb

@@ -1,3 +1,4 @@
+require_relative "event"
 require_relative "expect"
 require_relative "getset"
 require_relative "host"

data/lib/teuton/case/dsl/event.rb

@@ -0,0 +1,5 @@
+module DSL
+  def event(**args, &block)
+    @action_manager.add_event(args, block)
+  end
+end

data/lib/teuton/case/dsl/expect.rb

@@ -15,12 +15,11 @@ module DSL
     elsif input.instance_of?(String) || input.instance_of?(Regexp) || input.instance_of?(Array)
       expect_any input
     else
-      puts Rainbow("[ERROR] Case expect TypeError: <expect #{input} (#{input.class})>").bright.red
+      Logger.warn "Case expect TypeError: <expect #{input} (#{input.class})>"
     end
   end
 
   def expect2(cond, args = {})
-    @action.next
     if @result.exitcode.negative?
       # When exitcode is less than zero, it is because there has been
       # an error in the remote connection (SSH or Telnet)
@@ -33,8 +32,11 @@ module DSL
 
     @action.alterations = @result.alterations
     @action.expected = (args[:expected] || @result.expected)
-    @report.lines << @action.to_h
-    weight(1.0)
+
+    @action_manager.trigger_events!
+    ## @report.lines << @action.to_h
+    @action = @action_manager.next_action
+    # TODO: weight(1.0)
 
     c = Settings.letter[:fail]
     c = Settings.letter[:good] if cond

data/lib/teuton/case/dsl/log.rb

@@ -1,19 +1,20 @@
 require "rainbow"
 
 module DSL
-  ##
-  # Record log message
-  # @param text (String)
-  # @param type (Symbol) Values :info, :warn or :error
+  # type => :info, :warn or :error
   def log(text = "", type = :info)
     s = " INFO"
-    s = Rainbow("WARN!").color(:yellow) if type == :warn
-    s = Rainbow("ERROR").bg(:red) if type == :error
+    s = " WARN" if type == :warn
+    s = "ERROR" if type == :error
     t = Time.now
     f = format("%<hour>02d:%<min>02d:%<sec>02d", {hour: t.hour, min: t.min, sec: t.sec})
-    msg = "[#{f}] #{s}: #{text}"
+    msg = "[#{f}] #{s}| #{text}"
     msg = "[#{f}] #{text}" if s == ""
-    @report.lines << msg
+
+    colored_msg = msg
+    colored_msg = Rainbow(msg).yellow.bright if type == :warn
+    colored_msg = Rainbow(msg).bg(:red) if type == :error
+
+    @report.lines << colored_msg
   end
-  # alias_method :msg, :log
 end

data/lib/teuton/case/dsl/macro.rb

@@ -13,7 +13,7 @@ module DSL
     unless macros[name]
       msg = "Unknown DSL keyword '#{name}'"
       log(msg, :error)
-      Logger.warn("Warn: #{msg}")
+      Logger.warn(msg)
       return
     end
     input.each_pair { |k, v| set(k, v) }

data/lib/teuton/case/dsl/run.rb

@@ -4,31 +4,26 @@ require_relative "../execute/execute_manager"
 
 module DSL
   ##
-  # DSL run and goto
-  # run: It's the same as goto :localhost
+  # DSL run
   # @param command (String)
   # @param args (Hash)
   def run(command, args = {})
-    args[:exec] = command.to_s
-    host = args[:on] || :localhost
-    goto(host, args)
-  end
+    @action.command = command.to_s
+    @action.host = args[:on] || :localhost
+    @action.encoding = args[:encoding] || "UTF-8"
 
-  # Run command from the host identify as "host"
-  # goto :host1, execute: "command"
-  def goto(host = :localhost, args = {})
     @result.reset
-    args[:on] = host unless args[:on]
-    @action.command = args[:execute].to_s if args[:execute]
-    @action.command = args[:exec].to_s if args[:exec]
-    @action.encoding = args[:encoding] || "UTF-8"
 
-    ExecuteManager.new(self).call(host)
+    ExecuteManager.new(self).call(@action.host)
     @action.output = if @result.content.size < 2
       @result.value.clone
     else
       "(#{@result.content.size} lines)"
     end
   end
-  alias_method :on, :goto
+
+  def goto(...)
+    Logger.warn "Keyword DSL deprecated! <goto>"
+    run(...)
+  end
 end

data/lib/teuton/case/dsl/target.rb

@@ -2,17 +2,24 @@
 
 # DSL#target
 module DSL
-  def readme(_text)
+  def doc(_text)
     # Usefull when running.
     # It's works only with "teuton reamde" command action.
   end
 
+  def readme(...)
+    Logger.warn("Keyword deprecated: Replace 'readme' by 'doc'.")
+    doc(...)
+  end
+
   def target(desc, args = {})
     @action.description = desc.to_s
-    @action.asset = args[:asset].to_s if args[:asset]
     w = args[:weight] || 1.0
     weight(w)
   end
 
-  alias_method :goal, :target # DEPRECATE
+  def goal(...)
+    Logger.warn("Keyword deprecated: Replace 'goal' by 'target'.")
+    target(...)
+  end
 end

data/lib/teuton/case/play.rb

@@ -12,7 +12,7 @@ class Case
     fill_report(start_time, Time.now)
     close_opened_sessions
   end
-  alias_method :start, :play
+  # alias_method :start, :play
 
   private