teuton 2.4.0 → 2.4.2

data/docs/learn/11-export.md

@@ -0,0 +1,35 @@
+[<< back](README.md)
+
+# Export
+
+* [export](../dsl/export.md) keyword generate reports into diferents formats:
+
+Example
+```ruby
+play do
+  show
+  export format: :txt
+  export format: :html
+  export format: :json
+end
+```
+
+* `show`, show process on screen.
+* `export format: :txt`, create reports with `txt` format.
+* `export format: :html`, create reports with `html` format.
+* `export format: :json`, create reports with `json` format.
+
+Firs run `teuton examples/11-export`, then we have:
+
+```
+❯ tree var/11-export
+
+var/11-export
+├── case-01.html
+├── case-01.json
+├── case-01.txt
+├── moodle.csv
+├── resume.html
+├── resume.json
+└── resume.txt
+```

data/docs/learn/{09-preserve.md → 12-preserve.md}

@@ -23,7 +23,7 @@ end
 
 ## Result
 
-Example, executing `teuton run example/learn-09-preserve` twice:
+Example, executing `teuton run example/09-preserve` twice:
 
 ```
 var

data/docs/learn/13-feedback.md

@@ -0,0 +1,49 @@
+[<< back](README.md)
+
+# Feedback
+
+Exporting with false feedback option `export feedback: false`, hide some items from output reports. Hiden items: command, alterations, expected and result.
+
+> More information about [export](../dsl/execution/export.md) keyword.
+
+Example
+
+```ruby
+play do
+  show
+  export feedback: false
+  export format: "html", feedback: false
+end
+```
+
+## Description
+
+Every time teuton is run, all cases are evaluated and when exporting the results, by default, all the information collected during the evaluation process is logged.
+
+Each "target" contains the following fields:
+
+* Identification: id, description
+* Evaluation result: check(true/false)
+* Punctuation: score, weight
+* Check process: conn_type, command, duration, alterations, expected, result
+
+Some of these fields should always be visible, such as: id, description, check, score, and weight. And others, more related to the process that perform teuton for verification can be hidden using the "feedback: false" parameter.
+
+With "feedback: false" the fields are hidden: command, alterations, expected and result.
+
+
+## Results
+
+Executing `teuton run examples/13-feedback`, we get this output:
+
+```
+GROUPS
+- Preserve output reports
+    01 (1.0/1.0)
+        Description : Exits user david
+        Command     : ********
+        Duration    : 0.002 (local)
+        Alterations : *******************
+        Expected    : ************** (String)
+        Result      : ******** (String)
+```

data/docs/learn/14-moodle_id.md

@@ -0,0 +1,24 @@
+[<< back](README.md)
+
+# Moodle
+
+As a teacher, probably you are using Moodle platform. So, you want to upload the results of the evaluation carried out by Teuton into Moodle.
+
+Teuton generates a file called `moodle.csv` with the grades of each student into CSV format. This file is suitable to import into Moodle platform.
+
+## tt_moodle_id
+
+Add a new field called `tt_moodle_id` to each case in "config.yaml". Fill it with the student's identification (For example, the email registered on the Moodle, or ID number, etc.).
+
+Example:
+
+```
+global:
+cases:
+- tt_members: Darth Vader
+  tt_moodle_id: vader@starwars.com
+- tt_members: Obiwan Kenobi
+  tt_moodle_id: obiwan@starwars.com
+```
+
+Now, when running test "moodle.csv" will be generated with all student grades.

data/docs/learn/{08-readme.md → 15-readme.md}

@@ -4,10 +4,6 @@
 
 Create README files (with test instructions) from our test definition.
 
-1. [Definition section](#definition-section)
-2. [Execute command](#execute-command)
-3. [Result](#result)
-
 ## Definition section
 
 Take a look at our test definition section (Group):
@@ -35,23 +31,23 @@ There exists some `readme` instructions after `group` and `target` lines.
 To generate automatically a README file from previous test, execute this:
 
 ```
-teuton readme example/08-readme > example/08-readme/README.md
+teuton readme example/15-readme > example/15-readme/README.md
 ```
 
 ## Result
 
-**Let's see the output**: Content of `example/08-readme/README.md` file.
+**Let's see the output**: Content of `example/15-readme/README.md` file.
 
 ---
-# 08-readme
+
+# 15-readme
 
 ## Customize readme output
 
-This is our README example.
+This is our readme example.
 And here we'll see how to use readme keyword
 
 Go to [LOCALHOST](#required-hosts) host, and do next:
 * Create user david.
     * Help: you can use 'useradd' command to create users.
     * Remember: Only root is permitted to create new users.
----

data/docs/learn/{13-include.md → 16-include.md}

@@ -1,11 +1,9 @@
 [<< back](README.md)
 
-# Example: 13-include
+# include
 
 Use `tt-include` to include several config files into your main config file.
 
-## Explanation
-
 Until now, all the examples we have seen use one configuration file (`config.yaml`) that contain all the parameters required by the test. It is possible to save configuration distributed among several files.
 
 Suppose we have the following file structure.

data/docs/learn/{07-log.md → 18-log.md}

@@ -1,33 +1,27 @@
 [<< back](README.md)
 
-# Example: 07-log
+# 18-log
 
-Let's learn how to create log messages.
+* `log TEXT`, save TEXT into output report.
 
-1. [Definition section](#definition-section)
-2. [Run test](#execution-section)
-3. [Result](#result)
+Example
 
-## Definition section
-
-Test definition section (Group):
 ```ruby
 group "Learning about log messages" do
-  log 'Using log messages...'
+  log "Using log messages."
 
   target "Create user david"
-  run    "id david"
+  run "id david"
+  log result.value
   expect "david"
 
-  log 'Problem detected!', :error
+  log "Problem detected!", :error
+  log "This is a warning", :warn
+  log "Hi, there!", :info
 end
 ```
 
-> In this example, localhost's OS must be GNU/Linux (any other compatible OS) because the command used is `id david`.
-
-## Result
-
-**Let's see example**: Content of `var/07-log/case-01.txt` file.
+Content of `var/18-log/case-01.txt` file.
 
 ```
 CONFIGURATION
@@ -35,12 +29,15 @@ CONFIGURATION
 | tt_members  | anonymous |
 | tt_sequence | false     |
 | tt_skip     | false     |
-| tt_testname | 07-log    |
+| tt_testname | 18-log    |
 +-------------+-----------+
 
 LOGS
-    [13:45:02] : Using log messages...
-    [13:45:02] ERROR: Problem detected!
+    [09:14:22]  INFO: Using log messages.
+    [09:14:22]  INFO: uid=1000(david) gid=1000(david) grupos=495(cdrom),493(disk),487(video),474(wheel),464(wireshark),459(docker),456(vboxusers),1000(david)
+    [09:14:22] ERROR: Problem detected!
+    [09:14:22] WARN!: This is a warning
+    [09:14:22]  INFO: Hi, there!
 
 GROUPS
 - Learning about log messages
@@ -55,9 +52,9 @@ GROUPS
 RESULTS
 +--------------+---------------------------+
 | case_id      | 01                        |
-| start_time   | 2022-12-24 13:45:02 +0000 |
-| finish_time  | 2022-12-24 13:45:02 +0000 |
-| duration     | 0.001900685               |
+| start_time   | 2023-01-26 09:14:22 +0000 |
+| finish_time  | 2023-01-26 09:14:22 +0000 |
+| duration     | 0.002012326               |
 | unique_fault | 0                         |
 | max_weight   | 1.0                       |
 | good_weight  | 1.0                       |
@@ -65,4 +62,3 @@ RESULTS
 | fail_counter | 0                         |
 | grade        | 100                       |
 +--------------+---------------------------+
-```

data/docs/learn/{12-get_vars.md → 19-read_vars.md}

@@ -1,10 +1,10 @@
 [<< back](README.md)
 
-# Example: 12-get_vars
+# Read vars
 
-To read the variables from the configuration file we already have the `get` statement. Example, to read `dirname` we do `get(:dirname)`.
+To get paramm values from the configuration file we already have the `get` statement. Example, to read `dirname` we do `get(:dirname)`.
 
-**Example 1:** Using `get` to read vars.
+**Example 1:** Using `get` to get values.
 
 ```ruby
   # "get(:dirname)" reads dirname var from config file

data/docs/learn/20-macros.md

@@ -0,0 +1,49 @@
+[<< back](README.md)
+
+# Macros
+
+Macros is a technique to make it easier to write and reuse code.
+
+**Example**
+
+* We start from a set of repeated targets.
+
+```ruby
+target "Exist user fran"
+run "id fran"
+expect_one "root"
+
+target "Exist user root"
+run "id root"
+expect_one "root"
+
+target "Exist user david"
+run "id david"
+expect_one "david"
+```
+
+* Define a macro with the repeated block:
+
+```ruby
+define_macro "user_exists", :name do
+  target "Exist user #{get(:name)}"
+  run "id #{get(:name)}"
+  expect_one get(:name)
+end
+```
+
+* Replace the previous targets with macro calls. There are 3 ways to invoke the macro:
+
+```ruby
+user_exists(name: "fran")
+user_exists(name: "root")
+user_exists(name: "david")
+```
+
+**Notice**: There are 3 ways to invoke the macro:
+
+```ruby
+user_exists(name: "fran")
+macro "user_exists", name: "fran"
+macro_user_exists(name: "fran")
+```

data/docs/learn/{10-result.md → 22-result.md}

@@ -1,6 +1,6 @@
 [<< back](README.md)
 
-# Example: 10-result
+# result
 
 Sometimes it can be useful to look at the information returned by the "run" command. For this we use the **"result" object**.
 
@@ -20,11 +20,11 @@ end
 
 **Example 2:** When we are debugging our test and we want to see the content of the "result" object on the screen, we will use `result.debug`.
 
-```
+```ruby
 group "Checking users" do
   users = ["root", "vader"]
 
-  users.each do |name|
+  for name in users do
     target "Exists username #{name}"
     run "id #{name}"
     result.debug

data/docs/learn/23-test-code.md

@@ -0,0 +1,54 @@
+[<<back](README.md)
+
+# Test code
+
+Let's test code using teuton.
+
+**Example:**
+
+* Ask students to make a program that performs addition and multiplication.
+* Define targets `sum` and `mul`:
+
+```ruby
+# File: start.rb
+group "Test code example" do
+  # Reading filepath from config file
+  filepath = "./#{get(:folder)}/#{get(:filename)}"
+
+  target "Sum"
+  run "#{filepath} 3 4"
+  expect [ "Sum", "7" ] # Using Array/List of required items
+
+  target "Mul"
+  run "#{filepath} 3 4"
+  expect /Mul\s+=\s+12/ # Using a regular expresion
+end
+```
+
+* Define config params:
+
+```yaml
+# File: config.yaml
+---
+global:
+  folder: examples/23-test-code/code
+cases:
+- tt_members: student_1
+  filename: math_1.py
+- tt_members: student_2
+  filename: math_2b.py
+```
+
+* Put students files into `code` folder.
+* Now run Teuton test:
+
+```
+❯ teuton examples/23-test-code
+
+CASE RESULTS
++------+-----------+-------+-------+
+| CASE | MEMBERS   | GRADE | STATE |
+| 01   | student_1 | 100.0 | ✔     |
+| 02   | student_2 | 100.0 | ✔     |
++------+-----------+-------+-------+
+```

data/docs/learn/24-test-sql.md

@@ -0,0 +1,69 @@
+[<<back](README.md)
+
+# Test SQL and database
+
+**Exercise**
+
+* Ask students to make a Sqlite Database. Create a table called `characters` with `name` varchar, and `rol` varchar.
+* Database example:
+
+```
+❯ sqlite3 examples/24-test-sql/database_01.db
+
+sqlite> .schema characters
+CREATE TABLE characters ( name varchar(255), rol varchar(255));
+
+sqlite> select * from characters;
+Obiwan|Jedi
+```
+
+* Query example:
+
+```
+❯ cat examples/24-test-sql/query_01.sql
+
+select * from characters where rol='Jedi';
+```
+
+**Teuton test**
+
+* Define targets:
+
+```ruby
+group "Test SQL and database" do
+  database = "#{get(:folder)}/#{get(:database)}"
+  query = "#{get(:folder)}/#{get(:query)}"
+
+  target "Database schema"
+  run "sqlite3 #{database} '.schema characters'"
+  expect "name varchar", "rol varchar"
+
+  target "Query Jedi"
+  run "sqlite3 #{database} '.read #{query}'"
+  expect "Obiwan", "Jedi"
+end
+```
+
+* Configure params:
+
+```yaml
+---
+global:
+  folder: examples/24-test-sql
+cases:
+- tt_members: student_1_name
+  database: database_01.db
+  query: query_01.sql
+```
+
+**Test output**
+
+```
+❯ teuton examples/24-test-sql                                   
+
+CASE RESULTS
++------+----------------+-------+-------+
+| CASE | MEMBERS        | GRADE | STATE |
+| 01   | student_1_name | 100.0 | ✔     |
++------+----------------+-------+-------+
+```

data/docs/learn/README.md

@@ -1,37 +1,35 @@
-
 [<< back](../../README.md)
 
-* [Learning](#learning)
-* [Examples](#examples)
-* [Videos](#videos)
-
-# Learning
-
-Learn how to use Teuton language to write your own tests:
-- [01 - Target](01-target.md)
-- [02 - Config file](02-config.md)
-- [03 - Remote hosts](03-remote_hosts.md)
-- [04 - Create new test](04-new_test.md)
-- [05 - Use](05-use.md)
-- [06 - Debug](06-debug.md)
-- [07 - Log](07-log.md)
-- [08 - Readme](08-readme.md)
-- [09 - Preserve](09-preserve.md)
-- [10 - Result object](10-result.md)
-- [11 - Moodle ID](11-moodle_id.md)
-- [12 - Get vars](12-get_vars.md)
-- [13 - Include](13-include.md)
-- [14 - Alias](14-alias.md)
-- 15 - Macros
-- [16 - Exit codes](16-exit_codes.md)
-- [Videos](videos.md)
-
-# Examples
-
-More examples
-* Let's see examples at [teuton-tests](https://github.com/dvarrui/teuton-tests) GitHub repository.
-* Ask us by email at `teuton.software@protonmail.com`.
-* [ES - CHAPI19: Teuton demo](https://github.com/dvarrui/proyectos-de-ejemplo/tree/master/charlas/teuton)
+# Learn
+
+Learn how write your own Teuton tests:
+
+1. [Creating NEW test](01-cmd_new.md)
+1. [Evaluating TARGET](02-target.md)
+1. [Checking REMOTE HOSTS](03-remote_hosts.md)
+1. [Reading CONFIG file](04-config.md)
+1. [Using several files](05-use.md)
+1. [CHECK test syntax](06-cmd_check.md)
+1. [Target WEIGHT](07-target_weight.md)
+1. [UNIQUE values](08-unique_values.md)
+1. [SEND report copies to remote hosts](09-send.md)
+1. [DEBUG results](10-debug.md)
+1. [Export other FORMATS](11-export.md)
+1. [PRESERVE old reports](12-preserve.md)
+1. [Hide FEEDBACK from reports](13-feedback.md)
+1. [MOODLE ID](14-moodle_id.md)
+1. [Build README from test](15-readme.md)
+1. [INCLUDE more configuration files](16-include.md)
+1. [ALIAS](17-alias.md)
+1. [LOG messages](18-log.md)
+1. [Don't get params, just read vars](19-read_vars.md)
+1. [MACROS](20-macros.md)
+1. [Checking exit codes](21-exit_codes.md)
+1. [RESULT object](22-result.md)
+1. [Test code](23-test-code.md)
+1. [Test SQL and database](24-test-sql.md)
+
+Mores examples at [teuton-tests](https://github.com/dvarrui/teuton-tests) GitHub repository.
 
 # Videos
 
@@ -40,6 +38,7 @@ 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)

data/lib/teuton/application.rb

@@ -1,13 +1,10 @@
-# frozen_string_literal: true
-
 require "singleton"
-require_relative "version"
+# require_relative "version"
 require_relative "utils/name_file_finder"
 
-# This Singleton contains application params
 class Application
   include Singleton
-  include Teuton
+  # include Teuton
 
   attr_reader :letter
   attr_reader :running_basedir, :output_basedir

data/lib/teuton/case_manager/case/case.rb

@@ -42,6 +42,7 @@ class Case
 
     # Define Case Report
     @report = Report.new(@id)
+    # TODO: Move folder creation from case to parent classes?
     @report.output_dir = File.join("var", @config.global[:tt_testname])
     ensure_dir @report.output_dir
 
@@ -98,7 +99,7 @@ class Case
     @report.head[:tt_members] || "noname"
   end
 
-  alias skip? skip
+  alias_method :skip?, :skip
 
   private
 

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

@@ -55,7 +55,9 @@ module DSL
   end
 
   def expect_none(input, args = {})
-    if input.instance_of? Array
+    if input.nil?
+      # nothing to do
+    elsif input.instance_of? Array
       input.each { |i| result.find(i) }
     else
       result.find(input)

data/lib/teuton/case_manager/case/dsl/goto.rb

@@ -31,5 +31,5 @@ module DSL
     run_cmd_on(host)
     @action[:duration] = (Time.now - start_time).round(3)
   end
-  alias on goto
+  alias_method :on, :goto
 end

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

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

data/lib/teuton/case_manager/case/dsl/send.rb

@@ -37,10 +37,10 @@ module DSL
       Net::SFTP.start(ip, username, password: password, port: port) do |sftp|
         sftp.upload!(localfilepath, remotefilepath)
       end
-      msg = Rainbow("[ OK  ] #{(get(:tt_members)[0, 15]).ljust(16)} : #{remotefilepath}").green
+      msg = Rainbow("==> File '#{remotefilepath}' of '#{get(:tt_members)}' has been copied").green
       verboseln(msg)
     rescue
-      msg = Rainbow("[ERROR] #{(get(:tt_members)[0, 15]).ljust(16)} : scp #{localfilepath} => #{remotefilepath}").red
+      msg = Rainbow("==> [FAIL] #{get(:tt_members)}: 'scp #{localfilepath}' to #{remotefilepath}").red
       verboseln(msg)
     end
   end

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

@@ -12,5 +12,5 @@ module DSL
     w = args[:weight] || 1.0
     weight(w)
   end
-  alias goal target
+  alias_method :goal, :target
 end