teuton 2.10.8 → 2.11.0

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

@@ -4,10 +4,20 @@
 
 Let's test code using teuton.
 
-**Example:**
+## Exercise
 
-* Ask students to make a program that performs addition and multiplication.
-* Define targets `sum` and `mul`:
+Ask students to make a program that performs addition and multiplication.
+
+Usage:
+```
+$ examples/23-test-code/code/math_1.py 3 4
+Sum = 7
+Mul = 12
+```
+
+## Example
+
+Define targets `sum` and `mul`:
 
 ```ruby
 # File: start.rb
@@ -25,7 +35,7 @@ group "Test code example" do
 end
 ```
 
-* Define config params:
+Define config params:
 
 ```yaml
 # File: config.yaml
@@ -36,14 +46,14 @@ cases:
 - tt_members: student_1
   filename: math_1.py
 - tt_members: student_2
-  filename: math_2b.py
+  filename: math_2.py
 ```
 
-* Put students files into `code` folder.
+* Copy students files into `code` subfolder.
 * Now run Teuton test:
 
 ```
-❯ teuton examples/23-test-code
+$ teuton examples/23-test-code
 
 CASE RESULTS
 +------+-----------+-------+-------+

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

@@ -1,14 +1,15 @@
 [<<back](README.md)
 
-# Test SQL and database
+# Test SQL and database content
 
-**Exercise**
+## Exercise
 
-* Ask students to make a Sqlite Database. Create a table called `characters` with `name` varchar, and `rol` varchar.
-* Database example:
+* 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
+$ sqlite3 examples/24-test-sql/database_01.db
 
 sqlite> .schema characters
 CREATE TABLE characters ( name varchar(255), rol varchar(255));
@@ -17,20 +18,20 @@ sqlite> select * from characters;
 Obiwan|Jedi
 ```
 
-* Query example:
+* Ask students to create SQL queries inside a file. For example: select all Jedi characters.
 
 ```
-❯ cat examples/24-test-sql/query_01.sql
+$ cat examples/24-test-sql/query_01.sql
 
 select * from characters where rol='Jedi';
 ```
 
-**Teuton test**
+## Teuton test
 
-* Define targets:
+Define targets (start.rb file):
 
 ```ruby
-group "Test SQL and database" do
+group "Test SQL and database content" do
   database = "#{get(:folder)}/#{get(:database)}"
   query = "#{get(:folder)}/#{get(:query)}"
 
@@ -44,26 +45,26 @@ group "Test SQL and database" do
 end
 ```
 
-* Configure params:
+Configure params (config.yaml file):
 
 ```yaml
 ---
 global:
   folder: examples/24-test-sql
 cases:
-- tt_members: student_1_name
+- tt_members: student_1
   database: database_01.db
   query: query_01.sql
 ```
 
-**Test output**
+## Run test
 
 ```
-❯ teuton examples/24-test-sql                                   
+$ teuton examples/24-test-sql                                   
 
 CASE RESULTS
-+------+----------------+-------+-------+
-| CASE | MEMBERS        | GRADE | STATE |
-| 01   | student_1_name | 100.0 | ✔     |
-+------+----------------+-------+-------+
++------+-----------+-------+-------+
+| CASE | MEMBERS   | GRADE | STATE |
+| 01   | student_1 | 100.0 | ✔     |
++------+-----------+-------+-------+
 ```

data/docs/learn/25-expect-result.md

@@ -21,6 +21,7 @@
 | expect_exit NUMBER | Exit code is NUMBER |
 | expect_ok          | Exit code 0 |
 | expect_fail        | Exit code > 0 |
+| expect_sequence    | Validates sequences |
 
 > Learn more about [expect](../dsl/expect.md)
 

data/docs/learn/26-expect_sequence.md

@@ -23,8 +23,7 @@ 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.
-
+To evaluate the occurrence of a certain sequence that takes place in different lines of the output we use the "expect_sequence" instruction.
 
 ```ruby
 # Example:
@@ -37,11 +36,13 @@ expect_sequence do
 end
 ```
 
-> NOTE: expect_sequence can be useful for evaluating iptables firewall configurations where permission assignment order is relevant.
+> NOTE: `expect_sequence` can be useful for evaluating iptables firewall configurations where permission assignment order is relevant.
+
+## Usage
 
-## Evaluating different sequences
+### Simple sequence
 
-* **Simple sequence**. Validate sequences where the elements are in order. Use `find` statement to find each element of the 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.
@@ -53,7 +54,9 @@ expect_sequence do
 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.
+### 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.
@@ -65,7 +68,9 @@ expect_sequence do
 end
 ```
 
-* **Strict sequence with jumps**. Use `ignore N` to indicate that there are N lines between 2 elements of the sequence.
+### 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.

data/docs/learn/27-run_script.md

@@ -11,7 +11,7 @@ You know the classic sequence `target/run/expect`, but sometimes you need to run
 
 > Example files at [examples/27-run_file](../../examples/27-run_script)
 
-## Example scripts
+## Example files
 
 Suppose we have the following files:
 ```
@@ -29,11 +29,13 @@ echo $MESSAGE
 exit 0
 ```
 
-## Usage examples
+## Usage
 
 `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.
+### Compact invocation
+
+The "command" string executed contains the interpreter, the script, and the arguments. Example: `"bash show.sh Hello"`.
 
 ```ruby
 target "Mode 1: Upload script and execute on remote host"
@@ -41,7 +43,9 @@ 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.
+### Separate components
+
+Pass the script name, interpreter, and its arguments using separate parameters.
 
 ```ruby
 target "Mode 2: Upload script and execute on remote host"
@@ -49,12 +53,14 @@ run_script "show.sh", shell: "bash", args: "Hello", on: :host1
 expect "Hello"
 ```
 
+### Separate components and defaut shell
+
 Or setting shell default value:
 
 ```ruby
 set(:shell, "bash")
 
-target "Mode 2: Upload script and execute on remote host"
+target "Mode 3: Upload script and execute on remote host"
 run_script "show.sh", args: "Hello", on: :host1
 expect "Hello"
 ```