testomaton 0.2.2__tar.gz → 0.3.5__tar.gz

{testomaton-0.2.2/src/testomaton.egg-info → testomaton-0.3.5}/PKG-INFO

@@ -1,11 +1,12 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: testomaton
-Version: 0.2.2
+Version: 0.3.5
 Summary: Model based combinatorial test data generator
 Home-page: https://bitbucket.org/testify-no/tomato
-Author: Patryk Chamuczyński, Testify AS
-Author-email: p.chamuczynski@testify.no
+Author: Testify AS
+Author-email: tomato@testify.no
 License: GNU Affero General Public License v3 or later (AGPLv3+)
+Project-URL: Changelog, https://bitbucket.org/testify-no/tomato/src/develop/CHANGELOG.md
 Keywords: testing pairwise test_generation
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
@@ -15,13 +16,26 @@ Classifier: Environment :: Console
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Testing
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.6
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: python-sat
 Requires-Dist: pyparsing
 Requires-Dist: pyaml
 Requires-Dist: regex
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Introduction
 Testomaton is a suite of tools for combinatoric testing. It consists of __tomato__ - a combinatoric test generator and two tools used for postprocessing tomato's output - __beaver__ and __jigsaw__.
@@ -62,6 +76,7 @@ Testomaton is a suite of tools for combinatoric testing. It consists of __tomato
     - [Constraints manipulation](#constraints-manipulation)
     - [Filtering parsed elements](#filtering-parsed-elements)
     - [Format of the output](#format-of-the-output)
+  - [Validating models](#validating-models)
   - [Validating tests](#validating-tests)
   - [Using tomato in test code](#using-tomato-in-test-code)
 - [Test postprocessing](#test-postprocessing)
@@ -119,10 +134,10 @@ Jigsaw is a simple .csv manipulation util that can be used to add, remove, repla
 Tomato is the core of the testomaton suite. Simplifying, it reads a model of a test function and generates rows of tests.
 The model is defined in a yaml format and provides the description of what values can be assigned to individual parameters of the function.
 
-                                      ┌───────────────┐
-                                      │ test function │
-                                      └───────┬───────┘
-              ┌───────────────────┬───────────┴──┬────────────────┐
+                                  ┌───────────────┐
+                                  │ test function │
+                                  └───────┬───────┘
+              ┌───────────────────┬───────┴──────┬────────────────┐
               X1                  X2           [...]             Xn                     
       ┌────┬──┴─┬────┐    ┌────┬──┴─┬────┐                ┌────┬──┴─┬────┐  
      x11  x12 [...] x1m  x21  x22 [...] x2m              xn1  xn2 [...] xnm
@@ -379,7 +394,7 @@ A linked parameter is a parameter that is a copy of a global parameter. Linked p
 Linked parameters may link to a structure or to a leaf parameter, but must always link to a parameter that is directly defined as a global parameter.
 It means that a linked parameter may not link to a subparameter of a global structure. 
 Optionally, linked parameters may have `constraints whitelist` or `constraints blacklist` element that defines what constraints of the link shall be considered in the linked parameter.
-Obviously, these fields are mutually exclusive (a parameter cannot have both a whitelist and a blacklist). Elements of the lists are names of the constraints that should be filtered, separated by a comma  (`,`).
+Obviously, these fields are mutually exclusive (a parameter cannot have both a whitelist and a blacklist). Elements of the lists are names or labels of the constraints that should be filtered, separated by a comma  (`,`).
 Note that although a comma is allowed when naming or labelling a constraint (or anything else), using it may have unexpected consequences and make the model not work as intended. Using quotes when defining white and blacklists may help here.
 As mentioned above, parts of structures may also be defined as linked parameters.
 
@@ -543,7 +558,7 @@ functions:
  ```
 In this example, whenever the value of `bad guy` is `Jadis`, the location will always be `White Castle`, unlike like in the previous example when `Jadis` and `Cair Paravel` could coexist. 
 
-Invariants and implications are in fact different forms of the same logic semantics. Using implications is introduced for convenient notation, but in the end all implications may be reduced to invariants, because any expression `"IF A THEN B"` can also be noted as `"NOT A OR B"`
+Invariants and implications are in fact different forms of the same logic semantics. Using implications is introduced for convenient notation, but in the end all implications may be reduced to invariants, because any expression `"IF A THEN B"` can also be noted as `"NOT A OR B"`.
 
 ### Assignments
 Assignments are defining values of output parameters in the tests. The syntax of an assignment is `"IF CONDITION THEN ASSIGNMENTS_LIST"` (or alternatively `"CONDITION => ASSIGNMENT_LIST"`),
@@ -573,14 +588,23 @@ functions:
 It is technically allowed to define two different assignments for the same condition, but the result of such operation are undefined. Tomato will not warn if that happens.
 
 ### Aliases
-Aliases are macros that allow defining short names for long statements used in constraints and assignments. Aliases may be then used by their names in other statements.
+Aliases are macros that allow defining short names for long statements used in constraints and assignments. Aliases may be then used by their names in other statements of all logic elements (aliases, constraints or assignments).
 
 ```yaml
 functions:
 - function: duel
   parameters:
   - parameter: Good guy
-    choices: [Peter, Susan, Edmund, Lucy]
+    parameters:
+    - parameter: name
+      choices: [Peter, Susan, Edmund, Lucy]
+    - parameter: weapon
+      choices: [sword, bow, dagger]
+    logic:
+    - alias: female
+      expression: "'name' IN ['Susan', 'Lucy']"
+    - constraint: sword
+      expression: "IF 'female' THEN 'weapon' IS NOT 'sword'"
   - parameter: Bad guy
     choices: [Jadis, Maugrim]
   - parameter: location
@@ -588,14 +612,18 @@ functions:
   - output parameter: duration
     default value: 5 minutes
   logic:
-  - alias: Lucy against Jadis
-    expression: "'Good guy' IS 'Lucy' AND 'Bad guy' IS 'Jadis'" 
-  - constraint: Lucy against Jadis in Cair Paravel
-    expression: "IF 'Lucy against Jadis' THEN 'location' IS 'Cair Paravel'"
-  - assignment: Lucy against Jadis duel duration
-    expression: "IF 'Lucy against Jadis' THEN 'duration'='10 minutes'"
+  - alias: Cair Paravel
+    expression: "'location' IS 'Cair Paravel'"
+  - alias: Girls against Jadis
+    expression: "'Good guy::female' AND 'Bad guy' IS 'Jadis'"
+  - constraint: Girls against Jadis in Cair Paravel
+    expression: "IF 'Girls against Jadis' THEN 'location' IS 'Cair Paravel'"
+  - assignment: Cair Paravel
+    expression: "IF 'Cair Paravel' THEN 'duration'='10 minutes'"
 ```
 
+An alias may be accessed from higher levels of the hierarchy. In the example above the alias `female` in the structure `Good guy` is accessed from the constraint `sword` within the same structure as well as from the alias `Girls against Jadis` on the function level.
+
 ### Statements
 A _statement_ is a core concept in the model logic. Statements define invariants, coditions and results of implications and conditions of assignments.
 Statements may also be assigned to aliases. Statements are built from _primitive statements_ using logical operations like `AND`, `OR`, `NOT` and grouping those in parentheses.
@@ -745,7 +773,27 @@ The parameter `--coverage` defines percentage of tuples that must be covered.
 
 The way the nwise algorithm works is by building a set of all possible n-tuples that validate the constraints and building tests for individual tuples. It tries to build such a test that covers as many tuples in the set as possible. After the test is constructed, covered tuples are removed from the set. The algorithm repeats until the set of uncovered tuples is empty. 
 
-The working of the algorithm is demonstrated if tomato is used with `--demo-level` parameter 1, 2 or 3.
+The parameter `-T|--tuples-from` allows to define a set of parameters that will be covered by the n-tuples. For the example above, if we generate tests by the command:
+
+```bash
+$ tomato --tuples-from 'good guy','bad guy'
+```
+
+we will get something like this:
+```
+good guy,weapon,bad guy
+Peter,sword,Jadis
+Susan,bow,Jadis
+Peter,dagger,Maugrim
+Lucy,sword,Jadis
+Edmund,bow,Jadis
+Lucy,sword,Maugrim
+Susan,bow,Maugrim
+Edmund,bow,Maugrim
+```
+ In the generated tests, all the combinations of `good guy` and `bad guy` parameters are covered, not necessarily covering the interactions with the remaining parameters. 
+
+The working of the n-wise algorithm is demonstrated if tomato is used with `--demo-level` parameter 1, 2 or 3.
 The higher the value is, the more intermediate info is printed (on the error output) and the longer the algorithm waits on each step.
 
 ### Constraints manipulation
@@ -833,6 +881,9 @@ Then, the following rows will be filled with tests consisting values of choices
 - `--use-choice-names` - choice names will be used instead of values. Nested choices will have `::` between hierarchy levels,
 - `-s|--separator SEPARATOR` - use `SEPARATOR` instead of `,`. May be useful if some of the choices contain `,`.
 
+## Validating models
+If tomato is called to generate tests for an invalid model, it will print the encountered errors and exit with an error code. It is also possible to call tomato only in order to validate the model. This is done with `-v|--validate-model` option. Tomato will check the correctness of the model and quit, without generating tests. If the model is correct, it will print a confirmation message on the error output and quit with `0` exit code. Otherwise it will print all the error messages and quit with a positive exit code.
+
 ## Validating tests 
 Tomato may also be used to validate tests using `-V|--validate-tests [TEST_FILE]` option. This is a useful feature in situations when one wants to define a model having some sample tests.
 Tomato will parse the model, read the tests and print the tests that could be generated from the model unaltered on the standard output.

testomaton-0.2.2/PKG-INFO → testomaton-0.3.5/README.md

@@ -1,28 +1,3 @@
-Metadata-Version: 2.1
-Name: testomaton
-Version: 0.2.2
-Summary: Model based combinatorial test data generator
-Home-page: https://bitbucket.org/testify-no/tomato
-Author: Patryk Chamuczyński, Testify AS
-Author-email: p.chamuczynski@testify.no
-License: GNU Affero General Public License v3 or later (AGPLv3+)
-Keywords: testing pairwise test_generation
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
-Classifier: Operating System :: OS Independent
-Classifier: Environment :: Console
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Testing
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: python-sat
-Requires-Dist: pyparsing
-Requires-Dist: pyaml
-Requires-Dist: regex
-
 # Introduction
 Testomaton is a suite of tools for combinatoric testing. It consists of __tomato__ - a combinatoric test generator and two tools used for postprocessing tomato's output - __beaver__ and __jigsaw__.
 
@@ -62,6 +37,7 @@ Testomaton is a suite of tools for combinatoric testing. It consists of __tomato
     - [Constraints manipulation](#constraints-manipulation)
     - [Filtering parsed elements](#filtering-parsed-elements)
     - [Format of the output](#format-of-the-output)
+  - [Validating models](#validating-models)
   - [Validating tests](#validating-tests)
   - [Using tomato in test code](#using-tomato-in-test-code)
 - [Test postprocessing](#test-postprocessing)
@@ -119,10 +95,10 @@ Jigsaw is a simple .csv manipulation util that can be used to add, remove, repla
 Tomato is the core of the testomaton suite. Simplifying, it reads a model of a test function and generates rows of tests.
 The model is defined in a yaml format and provides the description of what values can be assigned to individual parameters of the function.
 
-                                      ┌───────────────┐
-                                      │ test function │
-                                      └───────┬───────┘
-              ┌───────────────────┬───────────┴──┬────────────────┐
+                                  ┌───────────────┐
+                                  │ test function │
+                                  └───────┬───────┘
+              ┌───────────────────┬───────┴──────┬────────────────┐
               X1                  X2           [...]             Xn                     
       ┌────┬──┴─┬────┐    ┌────┬──┴─┬────┐                ┌────┬──┴─┬────┐  
      x11  x12 [...] x1m  x21  x22 [...] x2m              xn1  xn2 [...] xnm
@@ -379,7 +355,7 @@ A linked parameter is a parameter that is a copy of a global parameter. Linked p
 Linked parameters may link to a structure or to a leaf parameter, but must always link to a parameter that is directly defined as a global parameter.
 It means that a linked parameter may not link to a subparameter of a global structure. 
 Optionally, linked parameters may have `constraints whitelist` or `constraints blacklist` element that defines what constraints of the link shall be considered in the linked parameter.
-Obviously, these fields are mutually exclusive (a parameter cannot have both a whitelist and a blacklist). Elements of the lists are names of the constraints that should be filtered, separated by a comma  (`,`).
+Obviously, these fields are mutually exclusive (a parameter cannot have both a whitelist and a blacklist). Elements of the lists are names or labels of the constraints that should be filtered, separated by a comma  (`,`).
 Note that although a comma is allowed when naming or labelling a constraint (or anything else), using it may have unexpected consequences and make the model not work as intended. Using quotes when defining white and blacklists may help here.
 As mentioned above, parts of structures may also be defined as linked parameters.
 
@@ -543,7 +519,7 @@ functions:
  ```
 In this example, whenever the value of `bad guy` is `Jadis`, the location will always be `White Castle`, unlike like in the previous example when `Jadis` and `Cair Paravel` could coexist. 
 
-Invariants and implications are in fact different forms of the same logic semantics. Using implications is introduced for convenient notation, but in the end all implications may be reduced to invariants, because any expression `"IF A THEN B"` can also be noted as `"NOT A OR B"`
+Invariants and implications are in fact different forms of the same logic semantics. Using implications is introduced for convenient notation, but in the end all implications may be reduced to invariants, because any expression `"IF A THEN B"` can also be noted as `"NOT A OR B"`.
 
 ### Assignments
 Assignments are defining values of output parameters in the tests. The syntax of an assignment is `"IF CONDITION THEN ASSIGNMENTS_LIST"` (or alternatively `"CONDITION => ASSIGNMENT_LIST"`),
@@ -573,14 +549,23 @@ functions:
 It is technically allowed to define two different assignments for the same condition, but the result of such operation are undefined. Tomato will not warn if that happens.
 
 ### Aliases
-Aliases are macros that allow defining short names for long statements used in constraints and assignments. Aliases may be then used by their names in other statements.
+Aliases are macros that allow defining short names for long statements used in constraints and assignments. Aliases may be then used by their names in other statements of all logic elements (aliases, constraints or assignments).
 
 ```yaml
 functions:
 - function: duel
   parameters:
   - parameter: Good guy
-    choices: [Peter, Susan, Edmund, Lucy]
+    parameters:
+    - parameter: name
+      choices: [Peter, Susan, Edmund, Lucy]
+    - parameter: weapon
+      choices: [sword, bow, dagger]
+    logic:
+    - alias: female
+      expression: "'name' IN ['Susan', 'Lucy']"
+    - constraint: sword
+      expression: "IF 'female' THEN 'weapon' IS NOT 'sword'"
   - parameter: Bad guy
     choices: [Jadis, Maugrim]
   - parameter: location
@@ -588,14 +573,18 @@ functions:
   - output parameter: duration
     default value: 5 minutes
   logic:
-  - alias: Lucy against Jadis
-    expression: "'Good guy' IS 'Lucy' AND 'Bad guy' IS 'Jadis'" 
-  - constraint: Lucy against Jadis in Cair Paravel
-    expression: "IF 'Lucy against Jadis' THEN 'location' IS 'Cair Paravel'"
-  - assignment: Lucy against Jadis duel duration
-    expression: "IF 'Lucy against Jadis' THEN 'duration'='10 minutes'"
+  - alias: Cair Paravel
+    expression: "'location' IS 'Cair Paravel'"
+  - alias: Girls against Jadis
+    expression: "'Good guy::female' AND 'Bad guy' IS 'Jadis'"
+  - constraint: Girls against Jadis in Cair Paravel
+    expression: "IF 'Girls against Jadis' THEN 'location' IS 'Cair Paravel'"
+  - assignment: Cair Paravel
+    expression: "IF 'Cair Paravel' THEN 'duration'='10 minutes'"
 ```
 
+An alias may be accessed from higher levels of the hierarchy. In the example above the alias `female` in the structure `Good guy` is accessed from the constraint `sword` within the same structure as well as from the alias `Girls against Jadis` on the function level.
+
 ### Statements
 A _statement_ is a core concept in the model logic. Statements define invariants, coditions and results of implications and conditions of assignments.
 Statements may also be assigned to aliases. Statements are built from _primitive statements_ using logical operations like `AND`, `OR`, `NOT` and grouping those in parentheses.
@@ -745,7 +734,27 @@ The parameter `--coverage` defines percentage of tuples that must be covered.
 
 The way the nwise algorithm works is by building a set of all possible n-tuples that validate the constraints and building tests for individual tuples. It tries to build such a test that covers as many tuples in the set as possible. After the test is constructed, covered tuples are removed from the set. The algorithm repeats until the set of uncovered tuples is empty. 
 
-The working of the algorithm is demonstrated if tomato is used with `--demo-level` parameter 1, 2 or 3.
+The parameter `-T|--tuples-from` allows to define a set of parameters that will be covered by the n-tuples. For the example above, if we generate tests by the command:
+
+```bash
+$ tomato --tuples-from 'good guy','bad guy'
+```
+
+we will get something like this:
+```
+good guy,weapon,bad guy
+Peter,sword,Jadis
+Susan,bow,Jadis
+Peter,dagger,Maugrim
+Lucy,sword,Jadis
+Edmund,bow,Jadis
+Lucy,sword,Maugrim
+Susan,bow,Maugrim
+Edmund,bow,Maugrim
+```
+ In the generated tests, all the combinations of `good guy` and `bad guy` parameters are covered, not necessarily covering the interactions with the remaining parameters. 
+
+The working of the n-wise algorithm is demonstrated if tomato is used with `--demo-level` parameter 1, 2 or 3.
 The higher the value is, the more intermediate info is printed (on the error output) and the longer the algorithm waits on each step.
 
 ### Constraints manipulation
@@ -833,6 +842,9 @@ Then, the following rows will be filled with tests consisting values of choices
 - `--use-choice-names` - choice names will be used instead of values. Nested choices will have `::` between hierarchy levels,
 - `-s|--separator SEPARATOR` - use `SEPARATOR` instead of `,`. May be useful if some of the choices contain `,`.
 
+## Validating models
+If tomato is called to generate tests for an invalid model, it will print the encountered errors and exit with an error code. It is also possible to call tomato only in order to validate the model. This is done with `-v|--validate-model` option. Tomato will check the correctness of the model and quit, without generating tests. If the model is correct, it will print a confirmation message on the error output and quit with `0` exit code. Otherwise it will print all the error messages and quit with a positive exit code.
+
 ## Validating tests 
 Tomato may also be used to validate tests using `-V|--validate-tests [TEST_FILE]` option. This is a useful feature in situations when one wants to define a model having some sample tests.
 Tomato will parse the model, read the tests and print the tests that could be generated from the model unaltered on the standard output.

{testomaton-0.2.2 → testomaton-0.3.5}/setup.py

@@ -1,13 +1,15 @@
 import setuptools
 
 with open("README.md", "r") as fh:
-    long_description = fh.read()
+    readme = fh.read()
+
+long_description = readme 
 
 setuptools.setup(
     name="testomaton", 
-    version="0.2.2",
-    author="Patryk Chamuczyński, Testify AS",
-    author_email="p.chamuczynski@testify.no",
+    version="0.3.5",
+    author="Testify AS",
+    author_email="tomato@testify.no",
     description="Model based combinatorial test data generator",
     long_description_content_type="text/markdown",
     long_description=long_description,
@@ -23,20 +25,31 @@ setuptools.setup(
         "Topic :: Software Development :: Testing",
         "Programming Language :: Python :: 3"
     ],
-    python_requires='>=3.6',
+    python_requires='>=3.7',
     keywords = 'testing pairwise test_generation',
     package_dir = {"": "src",},
+    project_urls = {
+        'Changelog': 'https://bitbucket.org/testify-no/tomato/src/develop/CHANGELOG.md',
+    },
     packages=setuptools.find_packages(where="src"),
-    py_modules=['tomato', 'generator', 'model', 'constraint', 'solver', 'beaver'],
+    py_modules=['tomato', 
+                'generator', 
+                'model', 
+                'constraint', 
+                'solver', 
+                'beaver',
+                'errors',
+                'jigsaw',
+                'validator',],
     install_requires=['python-sat', 
                       'pyparsing',
                       'pyaml',
                       'regex'],
     entry_points={
         'console_scripts':[
-            'tomato=testomaton.tomato:main',
-            'beaver=testomaton.beaver:main',
-            'jigsaw=testomaton.jigsaw:main',
+            'tomato=testomaton.tomato:tomato',
+            'beaver=testomaton.beaver:beaver',
+            'jigsaw=testomaton.jigsaw:jigsaw',
         ]
     },
 )

{testomaton-0.2.2 → testomaton-0.3.5}/src/testomaton/beaver.py

@@ -151,7 +151,7 @@ def evaluate_token(row_id, token, values):
     else:
         return token
         
-def main():
+def beaver():
     args = parse_args()
        
     input_columns = next(read_csv(args.input_file, separator=args.input_separator))
@@ -177,4 +177,4 @@ def main():
         csv_writer.writerow(output)
         
 if __name__ == '__main__':
-    main()
+    beaver()