teuton 2.4.0 → 2.4.2

data/docs/learn/02-config.md

@@ -1,121 +0,0 @@
-[<< back](README.md)
-
-# Example: 02-config
-
-* Learn how to use config file.
-* Use params defined into config files.
-* It's good idea save variable data separated into external config file.
-
-1. [Config file](#config-file).
-2. [Definition section](#definition-section).
-3. [Execution section](#execution-section).
-4. [Results](#results).
-
-## Config file
-
-By default, `config.yaml` is our config file. Let's an example:
-
-```yaml
----
-global:
-cases:
-- tt_members: Student-name-1
-  username: root
-- tt_members: Student-name-2
-  username: vargas
-```
-
-## Definition section
-
-By default, `start.rb` it's our main execution file.
-
-```ruby
-group "Reading params from config file" do
-
-  target "Create user #{get(:username)}"
-  run "id #{get(:username)}"
-  expect get(:username)
-
-end
-```
-
-In this section we define targets using keywords: target, run, expect and get.
-
-* **get** keyword is used to read params from configuracion file. It's posible personalize tests with diferent values for every case.
-
-> NOTE: In this example, we assume GNU/Linux as localhost's OS.
-
-## Execution section
-
-Main execution block:
-```ruby
-play do
-  show
-  export
-end
-```
-
-Runing this example and see `show` keyword output:
-
-```bash
-> teuton run examples/02-config
-
-CASE RESULTS
-+------+----------------+-------+-------+
-| CASE | MEMBERS        | GRADE | STATE |
-| 01   | Student-name-1 | 100.0 | ✔     |
-| 02   | Student-name-2 | 0.0   | ?     |
-+------+----------------+-------+-------+
-```
-
-## Results
-
-Output reports are saved into `var/02-config/` directory. Detail output report is created for every case.
-
-```
-var/02-config
-├── case-01.txt
-├── case-02.txt
-├── moodle.csv
-└── resume.txt
-```
-
-Let's see `export` keyword output for case 01.
-
-```
-> more var/02-config/case-01.txt
-CONFIGURATION
-+-------------+----------------+
-| tt_members  | Student-name-1 |
-| tt_sequence | false          |
-| tt_skip     | false          |
-| tt_testname | 02-config      |
-| username    | root           |
-+-------------+----------------+
-
-GROUPS
-- Reading params from config file
-    01 (1.0/1.0)
-        Description : Create user root
-        Command     : id root
-        Duration    : 0.002 (local)
-        Alterations : find(root) & count
-        Expected    : Greater than 0 (String)
-        Result      : 1 (Integer)
-
-RESULTS
-+--------------+---------------------------+
-| case_id      | 01                        |
-| start_time   | 2022-12-24 13:33:49 +0000 |
-| finish_time  | 2022-12-24 13:33:49 +0000 |
-| duration     | 0.001777756               |
-| unique_fault | 0                         |
-| max_weight   | 1.0                       |
-| good_weight  | 1.0                       |
-| fail_weight  | 0.0                       |
-| fail_counter | 0                         |
-| grade        | 100                       |
-+--------------+---------------------------+
-```
-
-> **How to choose another config file?** Read this [document](../commands/example_run.md#3-choosing-config-file).

data/docs/learn/04-new_test.md

@@ -1,87 +0,0 @@
-
-[<< back](README.md)
-
-# Example: 04-new_test
-
-Steps:
-1. Create skeleton
-2. Personalize targets
-3. Personalize configuration file
-4. Run the challenge
-
-## STEP 1: Create skeleton
-
-Create skeleton for a new project: `teuton create foo`
-
-```
-> teuton new foo
-
-[INFO] Creating foo project skeleton
-* Create dir        => foo
-* Create file       => foo/config.yaml
-* Create file       => foo/start.rb
-```
-
-> NOTA: It is posible to create these files by hand.
-
-This command will create:
-
-| File/Directory  | Description    |
-| --------------- | -------------- |
-| foo             | Base directory |
-| foo/start.rb    | Main Script    |
-| foo/config.yaml | YAML configuration file |
-
----
-
-## STEP 2: Personalize targets
-
-Write your own targets using the keywords: `target`, `run` and `expect`. Let's see:
-
-```ruby
-group "Create new test" do
-  target "Exist </home/vader> directory"
-  run "file /home/vader", on: :host1
-  expect_none "No such file or directory"
-end
-```
-
-The above example checks if exists '/home/david' directory, into *host1* device.
-
-> Let's see the keywords used:
->
-> * `target "Exist </home/vader> directory"`, Describe the target with our words, so every one could easily understand what we are trying
-to check.
-> * `run "file /home/vader", on: :host1`, : Execute the command into the remote machine (host1).
-> * `  expect_none "No such file or directory"`: Compare command ouput with our expectations.
-
-## STEP 3: Personalize Configfile
-
-Use a YAML file (`foo/config.yaml`) or JSON for your own configurations. In this example, the file contains params used by our challenge (script).
-
-**Example**:
-
-```yaml
----
-:global:
-  :host1_username: root
-:cases:
-- :tt_members: student-name-01
-  :host1_ip: 1.1.1.1
-  :host1_password: root-password-student-01
-- :tt_members: student-name-02
-  :host1_ip: 2.2.2.2
-  :host1_password: root-password-student-02
-```
-
-> The above file configures 2 differents cases with their own params. The script use this information when execute every case.
-
-## STEP 4: run the challenge
-
-Now we only have to run the challenge:
-
-```bash
-> teuton run foo
-```
-
-Output files are saved into `var/foo` directory.

data/docs/learn/06-debug.md

@@ -1,110 +0,0 @@
-
-[<< back](README.md)
-
-# Example: 06-debug
-
-Learn how to:
-* Check test syntax.
-* Debug your tests.
-
-1. [Tree directory](#tree-directory)
-2. [Execution section](#execution-section)
-3. [Check test](#check-test)
-4. [Debug](#debug)
-
-## Tree directory
-
-```
-> tree learn/learn-06-debug
-
-example/learn-06-debug
-├── config.yaml
-├── external.rb
-├── internal.rb
-├── README.md
-└── start.rb
-```
-
-## Execution section
-
-The `start.rb`  is main execution rb file, and uses `external` and `internal` rb files.
-
-Let's see current `start.rb` file:
-
-```ruby
-use 'external'
-use 'internal'
-
-play do
-  show
-  export :format => :colored_text
-end
-```
-
-## Check test
-
-Tests grows and becames huge, with a lot of targets (That isn't a problem). Then, we organize them spliting into several files and invoke `use` keywork from our main rb file to load other files (That's good idea) .
-
-When this happend, sometimes we need to verify or check rb file consistency and syntax, and we will do it with `teuton check PATH/TO/PROJECT/FOLDER`.
-
-Let's see example `teuton check examples/learn-01-target`:
-
-```
-+----------------------------+
-| GROUP: Learn about targets |
-+----------------------------+
-(001) target      Create user david
-      weight      1.0
-      run         'id david' on localhost
-      expect      david (String)
-
-+--------------+-------+
-| DSL Stats    | Count |
-+--------------+-------+
-| Groups       | 1     |
-| Targets      | 1     |
-| Goto         | 1     |
-|  * localhost | 1     |
-| Uniques      | 0     |
-| Logs         | 0     |
-|              |       |
-| Gets         | 0     |
-| Sets         | 0     |
-+--------------+-------+
-+----------------------+
-| Revising CONFIG file |
-+----------------------+
-[WARN] File /home/david/proy/repos/teuton.d/teuton/examples/01-target/config.yaml not found!
-[INFO] Recomended content:
----
-:global:
-:cases:
-- :tt_members: VALUE
-
-```
-
-In this case, Teuton detects that there isn't exist config file, and propose us content for `config.yaml`.
-
-## Debug
-
-Every time we invoke `run` or `goto` keywork, an OS command is executed. The output is showed on screen and saved into **result** internal object.
-
-We could debug it invoking `result.debug` into our tests. Let's see an example from `external.rb` file:
-
-```ruby
-group "Windows: external configuration" do
-
-  target "Localhost: Verify connectivity with #{gett(:windows1_ip)}"
-  run    "ping #{get(:windows1_ip)} -c 1"
-  result.debug
-  expect_one "0% packet loss"
-  result.debug
-
-  target "Localhost: netbios-ssn service working on #{gett(:windows1_ip)}"
-  run    "nmap -Pn #{get(:windows1_ip)}"
-  expect "139/tcp", "open"
-
-end
-```
-
-`result.debug` it's usefull when you are verifying command output captured by Teuton.

data/docs/learn/11-moodle_id.md

@@ -1,19 +0,0 @@
-[<< back](README.md)
-
-# Example: 11-moodle_id
-
-If you are a teacher and are using the Moodle platform, probably you will want to upload the results of the evaluation carried out by Teuton in Moodle.
-
-Teuton generates a file called "moodle.csv" with the grades of each student. Only have to import the file into Moodle.
-
-In the configuration file "config.yaml" add a field called "moodle_id" to each case. Fill it with the student's identification (For example, the email registered on the Moodle).
-
-Example:
-```
-global:
-cases:
-- tt_members: Darth Vader
-  tt_moodle_id: vader@starwars.com
-- tt_members: Obiwan Kenobi
-  tt_moodle_id: obiwan@starwars.com
-```