teuton 2.8.0 → 2.9.1

data/docs/learn/26-expect_sequence.md

@@ -0,0 +1,79 @@
+[<<back](README.md)
+
+# DSL: expect_sequence
+
+Evaluate the occurrence of a certain sequence that takes place in different lines of the output.
+
+> Example files at [examples/26-expect_sequence](../../examples/26-expect_sequence)
+
+## Description
+
+In the classic target/run/expect, the expect statement works by locating lines from the output of the previous command that meet certain criteria.
+
+We can even (using regular expressions) detect if there is any line in the output where a certain sequence appears.
+
+
+```ruby
+# Example:
+#   expect with regular expression to detect [a, b, c] sequence
+#   within a line
+
+expect /a.*?b.*?c/
+```
+
+> Regular expressions are very powerful but they are also complex to use.
+
+To evaluate the occurrence of a certain sequence that takes place in different lines of the output we will use the new "expect_sequence" instruction.
+
+
+```ruby
+# Example:
+#   expect_sequence to detect [a, b, c] sequence
+
+expect_sequence do
+  find "a"
+  find "b"
+  find "c"
+end
+```
+
+> NOTE: expect_sequence can be useful for evaluating iptables firewall configurations where permission assignment order is relevant.
+
+## Evaluating different sequences
+
+* **Simple sequence**. Validate sequences where the elements are in order. Use `find` statement to find each element of the sequence.
+
+```ruby
+# Examples: [A,B,C], [A,s,B,s,C], [x,A,B,s,C,x], etc.
+
+expect_sequence do
+  find "A"
+  find "B"
+  find "C"
+end
+```
+
+* **Strict sequence**. validate sequences where the elements are in strict consecutive order. First use `find` to find an element in the sequence and then `next_to` for the next element in strict order.
+
+```ruby
+# Examples: [A,B,C], [x,A,B,C,x], etc.
+
+expect_sequence do
+  find "A"
+  next_to "B"
+  next_to "C"
+end
+```
+
+* **Strict sequence with jumps**. Use `ignore N` to indicate that there are N lines between 2 elements of the sequence.
+
+```ruby
+# Examples: [A,B,s,s,C], [x,A,B,s,s,C,x], etc.
+
+expect_sequence do
+  find "A"
+  next_to "B"
+  ignore 2
+  next_to "C"
+end
+```

data/docs/learn/27-run_script.md

@@ -0,0 +1,91 @@
+[<<back](README.md)
+
+# DSL: run_script
+
+You know the classic sequence `target/run/expect`, but sometimes you need to run our own script files on the remote computer. So you have to:
+
+1. Upload a copy of the script file to the remote host
+2. and then run it on remote host
+
+**run_script** upload and execute your own local script on remote host.
+
+> Example files at [examples/27-run_file](../../examples/27-run_script)
+
+## Example scripts
+
+Suppose we have the following files:
+```
+example
+├── config.yaml
+├── show.sh
+└── start.rb
+```
+
+Contents of the `show.sh` script:
+```bash
+#!/usr/bin/env bash
+MESSAGE=$1
+echo $MESSAGE
+exit 0
+```
+
+## Usage examples
+
+`run_script` is the DSL keyword in charge of uploading the script to the remote computer and executing it. When invoking run_script we have two styles: compact or separate components. Let's see
+
+**Compact invocation**: The "command" to execute contains the interpreter, the script, and the arguments.
+
+```ruby
+target "Mode 1: Upload script and execute on remote host"
+run_script "bash show.sh Hello", on: :host1
+expect "Hello"
+```
+
+**Separate components**: pass the name of the script, the interpreter in charge of processing it and its arguments through separate parameters.
+
+```ruby
+target "Mode 2: Upload script and execute on remote host"
+run_script "show.sh", shell: "bash", args: "Hello", on: :host1
+expect "Hello"
+```
+
+Or setting shell default value:
+
+```ruby
+set(:shell, "bash")
+
+target "Mode 2: Upload script and execute on remote host"
+run_script "show.sh", args: "Hello", on: :host1
+expect "Hello"
+```
+
+## Running example
+
+```
+------------------------------------
+Started at 2023-07-23 13:46:11 +0100
+....uu..u.u.u.uu..u.!F!F!F!F
+Finished in 30.457 seconds
+------------------------------------
+
+CASE RESULTS
++------+-----------+-------+-------+
+| CASE | MEMBERS   | GRADE | STATE |
+| 01   | Localhost | 100.0 | ✔     |
+| 02   | Remote1   | 100.0 | ✔     |
+| 03   | Remote2   | 100.0 | ✔     |
+| 04   | Remote3   | 0.0   | ?     |
++------+-----------+-------+-------+
+
+CONN ERRORS
++------+---------+-------+------------------+
+| CASE | MEMBERS | HOST  | ERROR            |
+| 04   | Remote3 | host1 | host_unreachable |
++------+---------+-------+------------------+
+```
+
+Meaning of progress symbols:
+* `.`: check ok
+* `F`: check fail
+* `!`: connection fail
+* `u`: upload ok

data/docs/learn/28-upload.md

@@ -0,0 +1,55 @@
+[<<back](README.md)
+
+# DSL: upload
+
+`upload` is a dsl instruction, whose purpose is to upload files to the remote host.
+
+```ruby
+  upload "FILENAME", to: :host1
+```
+
+* `upload "FILENAME"`, upload local file to remote.
+* `to: :host1`, specifies remote host.
+
+> Example files at [examples/28-upload](../../examples/28-upload)
+
+## Other options
+
+* Upload "LOCALDIR/FILENAME" to default remote dir into remote host:
+
+```ruby
+  upload "LOCALDIR/FILENAME", to: :host1
+```
+
+* Upload "LOCALDIR/FILENAME" to remote dir into remote host:
+
+```ruby
+  upload "LOCALDIR/FILENAME", remotedir: "REMOTEDIR", to: :host1
+```
+
+* Upload several local files from "LOCALDIR" to default remote dir into host:
+
+```ruby
+  upload "LOCALDIR/*", to: :host1
+```
+
+* Upload several local files from "LOCALDIR" to remote host:
+
+```ruby
+  upload "LOCALDIR/*", remotedir: "REMOTEDIR", to: :host1
+```
+
+## Example
+
+```ruby
+  target "Upload file and then run it"
+  upload "script/show.sh", remotedir: "sh", to: :host1
+  run "bash sh/show.sh HelloWorld", on: :host1
+  expect "HelloWorld"
+```
+
+Example steps:
+1. Describe target.
+2. Upload local file to remote host.
+3. Run script using Bash on remote host.
+4. Evaluate script output.

data/docs/learn/README.md

@@ -28,20 +28,9 @@ Learn how write your own Teuton tests:
 1. [RESULT object](22-result.md)
 1. [Test code](23-test-code.md)
 1. [Test SQL and database](24-test-sql.md)
+1. [expect vs result](25-expect-result.md) TODO
+1. [EXPECT_SEQUENCE](26-expect_sequence.md)
+1. [RUN_SCRIPT](27-run_script.md)
+1. [UPLOAD](28-upload.md)
 
 Mores examples at [teuton-tests](https://github.com/dvarrui/teuton-tests) GitHub repository.
-
-# Videos
-
-By now there are no English videos. We are sorry!
-But if you want to see Spanish videos, here you are:
-
-Teuton (v2.0):
-* [ES - CHAPI19: Charla Teuton](https://youtu.be/KFWQDfNAFxI?t=12221)
-* [ES - CHAPI19: Teuton demo](https://github.com/dvarrui/proyectos-de-ejemplo/tree/master/charlas/teuton)
-
-Sysadmingame (Teuton v1.0)
-* [Sysadmingame (1 de 3): Instalación del programa](https://youtu.be/dnyMq9_KDco)
-* [Sysadmingame (2 de 3): Crear un caso simple](https://youtu.be/0e2g5Izvc6c)
-* [Sysadmingame (3 de 3): Crear un caso complejo](https://youtu.be/ebEK6OXH8kQ)
-* [CHAPI16 - Charla sysadmingame](https://youtu.be/cNJaB5xzHHQ)

data/docs/videos.md

@@ -7,14 +7,20 @@
 
 # Videos
 
-Teuton:
+> By now there are no English videos. We are sorry!
+
+Teuton v2.1:
 * [Apuntes FP Informática - I Congreso Virtual - Mayo 2020](https://youtu.be/RxIV26BAoGo)
-* [Teuton Software 2.1 - Tutorial - Oct 2020](https://youtu.be/cyBN-rOYQeY)
+* [Teuton Software 2.1 - Tutorial - Abr 2020](https://youtu.be/cyBN-rOYQeY)
 
-Teuton en el 2016 se llamaba "sysadmingame".
-* ES -[CHAPI16 - Presentación sysadmingame chapi16 - Abril 2016](https://youtu.be/cNJaB5xzHHQ)
-* sysadmingame:
-    1. [Instalación del programa](https://youtu.be/dnyMq9_KDco)
-    2. [Crear un caso simple](https://youtu.be/0e2g5Izvc6c)
-    3. [Crear un caso complejo](https://youtu.be/ebEK6OXH8kQ)
+Teuton v2.0:
+* [ES - CHAPI19: Charla Teuton](https://youtu.be/KFWQDfNAFxI?t=12221)
+* [ES - CHAPI19: Teuton demo](https://github.com/dvarrui/proyectos-de-ejemplo/tree/master/charlas/teuton)
 
+Sysadmingame (Teuton v1.0):
+* [Sysadmingame (1 de 3): Instalación del programa](https://youtu.be/dnyMq9_KDco)
+* [Sysadmingame (2 de 3): Crear un caso simple](https://youtu.be/0e2g5Izvc6c)
+* [Sysadmingame (3 de 3): Crear un caso complejo](https://youtu.be/ebEK6OXH8kQ)
+
+Sysadmingame: En el 2016 el proyecto se llamaba "sysadmingame".
+* ES -[CHAPI16 - Presentación sysadmingame chapi16 - Abril 2016](https://youtu.be/cNJaB5xzHHQ)

data/lib/teuton/case/case.rb

@@ -2,13 +2,14 @@
 
 require_relative "../utils/project"
 require_relative "../utils/verbose"
-require_relative "../utils/result/result"
 require_relative "../report/report"
 require_relative "dsl/all"
 require_relative "config"
 require_relative "close"
+# require_relative "builtin/main"
+require_relative "host"
 require_relative "play"
-require_relative "builtin/main"
+require_relative "result/result"
 
 class Case
   include DSL

data/lib/teuton/case/config.rb

@@ -2,11 +2,6 @@
 
 require_relative "../utils/project"
 
-# Class Case::Config
-# * get
-# * set
-# * unset
-# * missing_method
 class Case
   class Config
     # This class manage configuration for only one case

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

@@ -1,8 +1,12 @@
 require_relative "expect"
 require_relative "getset"
-require_relative "goto"
+require_relative "host"
 require_relative "log"
 require_relative "macro"
+require_relative "run"
+require_relative "run_script"
 require_relative "send"
 require_relative "target"
 require_relative "unique"
+require_relative "upload"
+require_relative "weight"

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

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
-module DSL
-  # expect, expect2, expect_any, expect_first, expect_last
-  # expect_nothing, expect_none, expect_one
+require_relative "expect_exitcode"
+require_relative "expect_sequence"
 
-  # expect <condition>, :weight => <value>
+module DSL
+  # expect <condition>,
+  #      value: RealValue,
+  #   expected: ExpectedValue,
+  #     weight: float
+  #
   def expect(input, args = {})
     if input.instance_of?(TrueClass) || input.instance_of?(FalseClass)
       expect2(input, args)
     elsif input.instance_of?(String) || input.instance_of?(Regexp) || input.instance_of?(Array)
       expect_any input
     else
-      puts Rainbow("[TypeError] expect #{input} (#{input.class})").red
+      puts Rainbow("[ERROR] Case expect TypeError: expect #{input} (#{input.class})").red
     end
   end
 
@@ -45,30 +49,6 @@ module DSL
     expect2 result.count.gt(0), args
   end
 
-  def expect_exit(value)
-    @result.alterations = "Read exit code"
-    real_value = result.exitcode
-    cond = if value.is_a? Range
-      expect_value = "With range #{value}"
-      value.to_a.include? real_value
-    elsif value.is_a? Array
-      expect_value = "Inside list #{value}"
-      value.include? real_value
-    else
-      expect_value = value
-      (real_value == value.to_i)
-    end
-    expect2 cond, value: real_value, expected: expect_value
-  end
-
-  def expect_fail
-    @result.alterations = "Read exit code"
-    real_value = result.exitcode
-    expect_value = "Greater than 0"
-    cond = (real_value > 0)
-    expect2 cond, value: real_value, expected: expect_value
-  end
-
   def expect_first(input, args = {})
     @result.first
     output = input
@@ -107,18 +87,9 @@ module DSL
     expect2 result.count.eq(1), args
   end
 
-  def expect_ok
-    expect_exit 0
-  end
-
-  def weight(value = nil)
-    # Set weight value for the action
-    if value.nil?
-      @action[:weight]
-    elsif value == :default
-      @action[:weight] = 1.0
-    else
-      @action[:weight] = value.to_f
-    end
+  def expect_sequence(&block)
+    seq = ExpectSequence.new(result.content.dup)
+    cond = seq.is_valid?(&block)
+    expect2 cond, value: seq.real, expected: seq.expected
   end
 end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DSL
+  def expect_exit(value)
+    @result.alterations = "Read exit code"
+    real_value = result.exitcode
+    cond = if value.is_a? Range
+      expect_value = "With range #{value}"
+      value.to_a.include? real_value
+    elsif value.is_a? Array
+      expect_value = "Inside list #{value}"
+      value.include? real_value
+    else
+      expect_value = value
+      (real_value == value.to_i)
+    end
+    expect2 cond, value: real_value, expected: expect_value
+  end
+
+  def expect_fail
+    @result.alterations = "Read exit code"
+    real_value = result.exitcode
+    expect_value = "Greater than 0"
+    cond = (real_value > 0)
+    expect2 cond, value: real_value, expected: expect_value
+  end
+
+  def expect_ok
+    expect_exit 0
+  end
+end

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

@@ -0,0 +1,173 @@
+class ExpectSequence
+  attr_reader :result
+  attr_reader :states
+
+  def initialize(lines)
+    @lines = lines
+  end
+
+  def is_valid?(&block)
+    @expected = []
+    @states = [
+      {last_index: -1, steps: [], found: []}
+    ]
+    instance_eval(&block)
+    @result = find_best_state
+    @result[:ok]
+  end
+
+  def expected
+    @expected.join(">")
+  end
+
+  def real
+    # From final result return evaluation progress
+    text = []
+    @result[:steps].each do |step|
+      index = text.size
+      text << if step
+        @expected[index]
+      else
+        "not #{@expected[index]}"
+      end
+    end
+    text.join(">")
+  end
+
+  private
+
+  def find_best_state
+    @states.each do |state|
+      state[:score] = (state[:steps].select { _1 }).size
+      state[:fails] = (state[:steps].select { !_1 }).size
+      state[:ok] = (state[:fails] == 0)
+    end
+    best = @states[0]
+    @states.each { |state| best = state if state[:score] > best[:score] }
+    best
+  end
+
+  def find(value)
+    @expected << "find(#{value})"
+    newstates = []
+    @states.each do |state|
+      last_index = state[:last_index]
+
+      if last_index > (@lines.size - 1)
+        steps = state[:steps].clone
+        steps << false
+        newstates << {
+          last_index: last_index,
+          steps: steps,
+          found: state[:found].clone
+        }
+        next
+      end
+
+      findindexes = get_indexes(value: value, from: last_index)
+      findindexes.each do |findindex|
+        found = state[:found].clone
+        found << findindex
+        steps = state[:steps].clone
+        steps << true
+        newstates << {
+          last_index: findindex,
+          steps: steps,
+          found: found
+        }
+      end
+    end
+    @states = if newstates.size.zero?
+      @states.each { |state| state[:steps] << false }
+    else
+      newstates
+    end
+  end
+
+  def next_to(value)
+    @expected << "next_to(#{value})"
+    newstates = []
+
+    @states.each do |state|
+      last_index = state[:last_index]
+
+      if last_index > (@lines.size - 1)
+        steps = state[:steps].clone
+        steps << false
+        newstates << {
+          last_index: last_index,
+          steps: steps,
+          found: state[:found].clone
+        }
+        next
+      end
+
+      last_index += 1
+      found = state[:found].clone
+      steps = state[:steps].clone
+      line = @lines[last_index]
+      if line.include?(value)
+        found << last_index
+        steps << true
+      else
+        steps << false
+      end
+      newstates << {
+        last_index: last_index,
+        steps: steps,
+        found: found
+      }
+    end
+    @states = if newstates.size.zero?
+      @states.each { |state| state[:steps] << false }
+    else
+      newstates
+    end
+  end
+
+  def ignore(value)
+    @expected << "ignore(#{value})"
+    newstates = []
+    @states.each do |state|
+      last_index = state[:last_index] + value.to_i
+
+      steps = state[:steps].clone
+      steps << !(last_index > (@lines.size - 1))
+
+      newstates << {
+        last_index: last_index,
+        steps: steps,
+        found: state[:found].clone
+      }
+    end
+
+    @states = if newstates.size.zero?
+      @states.each { |state| state[:steps] << false }
+    else
+      newstates
+    end
+  end
+
+  def get_indexes(value:, from:)
+    indexes = []
+
+    @lines.each_with_index do |line, index|
+      next if index < from
+
+      indexes << index if line_include_value?(line: line, value: value)
+    end
+    indexes
+  end
+
+  def line_include_value?(line:, value:)
+    if value.is_a? String
+      return true if line.include? value
+    elsif value.is_a? Regexp
+      return true << index if value.match(line)
+    else
+      puts "[ERROR] expect_sequence #{value.class}"
+      exit 1
+    end
+    false
+  end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# DSL#get and DSL#set
 module DSL
   # Read param option from [running, config or global] Hash data
   def get(option)

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

@@ -0,0 +1,5 @@
+module DSL
+  def get_host(id)
+    Case::Host.new(config).get(id)
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../utils/project"
+require_relative "../../utils/logger"
 
 module DSL
   ##
@@ -10,7 +11,9 @@ module DSL
   def macro(name, input = {})
     macros = Project.value[:macros]
     unless macros[name]
-      log("Macro #{name} not found!", :error)
+      msg = "DSL '#{name}' not found!"
+      log(msg, :error)
+      Logger.error("ERROR #{msg}")
       return
     end
     input.each_pair { |k, v| set(k, v) }
@@ -32,9 +35,10 @@ module DSL
   def method_missing(method, args = {})
     a = method.to_s
     if a.start_with?("_")
-      return instance_eval("get(:#{a[1, a.size - 1]})", __FILE__, __LINE__)
+      return instance_eval("get(:#{a[1, a.size]})", __FILE__, __LINE__)
+    elsif a[0, 6] == "macro_"
+      return macro a[6, a.size], args
     end
-    return macro a[6, a.size], args if a[0, 6] == "macro_"
     macro a, args
   end
 

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

@@ -0,0 +1,35 @@
+require_relative "../../utils/project"
+require_relative "../../utils/verbose"
+
+module DSL
+  def run_script(script, args = {})
+    items = script.split(" ")
+    if items.size == 1
+      shell = args[:shell] || ((get(:shell) != "NODATA") ? get(:shell) : nil)
+      script = "#{shell} #{script}" if shell
+      script = "#{script} #{args[:args]} " if args[:args]
+    end
+
+    items = script.split(" ")
+    if items.size < 1
+      msg = Rainbow("==> [ERROR] run_script: Incorrect command '#{command}'").red
+      verboseln(msg)
+      return
+    end
+
+    host = get_host(args[:on])
+    if host.protocol == "local"
+      items[1] = File.join(Project.value[:project_path], items[1])
+      command = items.join(" ")
+      run(command, args)
+    elsif host.protocol == "ssh"
+      upload items[1], to: host.id
+      items[1] = File.basename(items[1])
+      command = items.join(" ")
+      run(command, args)
+    else
+      msg = Rainbow("==> [ERROR] run_script: Incorrect protocol(#{host.protocol})").red
+      verboseln(msg)
+    end
+  end
+end