bigtesty 0.1.0__tar.gz

bigtesty-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mazlum Tosun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bigtesty-0.1.0/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.1
+Name: bigtesty
+Version: 0.1.0
+Summary: BigTesty is an integration testing framework for BigQuery
+Home-page: https://github.com/tosun-si/bigtesty
+Author: Mazlum TOSUN
+Author-email: mazlum.tosun@gmail.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9.19
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# BigTesty
+
+BigTesty is a framework that allows to create Integration Tests with BigQuery on a real and short-lived Infrastructure.
+
+Integration and End-to-End tests are a robust way to validate if SQL queries work as expected.\
+There is no an emulator in this case and the queries are executed directly in the BigQuery Engine.
+
+BigTesty isolates the tests for each execution to prevent collisions.\
+Multiples developers or CI CD pipelines can execute tests at the same time.
+
+The infrastructure proposed for the tests is ephemeral by default, but we can keep it if needed, to analyse the\
+result in BigQuery.
+
+After each test, a report result is returned to indicate the good and failure cases.
+
+![bigtesty_pulumi_automation.png](diagram%2Fbigtesty_pulumi_automation.png)
+
+## Getting started
+
+There is a `Python` package for BigTesty and it can be installed from `PiPy`:
+
+```bash
+pip install bigtesty
+```
+
+## How to run tests
+
+**You need to be authenticated with Google Cloud Platform before running command.**
+
+We recommend to be authenticated with [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials)
+
+```bash
+gcloud auth application-default login
+```
+
+### Example of code structure
+
+![bigtesty_examples_code_structure.png](bigtesty-doc%2Fstatic%2Fimg%2Fbigtesty_examples_code_structure.png)
+
+**The root test folder**
+
+This folder contains all the testing definition files and the tests scenarios. The format is Json.
+
+Example of a scenarios with a nominal case `definition_spec_failure_by_feature_name_no_error.json`:
+
+```json
+{
+  "description": "Test of monitoring data",
+  "scenarios": [
+    {
+      "description": "Nominal case find failure by feature name",
+      "given": [
+        {
+          "input_file_path": "monitoring/given/input_failures_feature_name.json",
+          "destination_dataset": "monitoring",
+          "destination_table": "job_failure"
+        }
+      ],
+      "then": [
+        {
+          "fields_to_ignore": [
+            "\\[\\d+\\]\\['dwhCreationDate']"
+          ],
+          "actual_file_path": "monitoring/when/find_failures_by_feature_name.sql",
+          "expected_file_path": "monitoring/then/expected_failures_feature_name.json"
+        }
+      ]
+    }
+  ]
+}
+```
+
+In this example, there is only one scenario with 3 blocs:
+- `given`: a list of input test data to ingest to the BigQuery tables. The input data can be proposed in a separate `Json` file or directly embedded. `input_file_path` for a separate file and `input` for an embedded object.
+- `then`: a list of objects contains the SQL query to test and execute and the expected data. `actual/actual_file_path` => SQL query | `expected/expected_file_path` => expected data
+
+**The root tables folder**
+
+This folder contains the resources concerning the `BigQuery` `datasets` and `tables` to create.\
+For example, all the `BigQuery` schemas are proposed in this folder.
+
+**The tables config file**
+
+The config file that lists all the `BigQuery` `datasets` and `tables` to create in a `Json` format.
+
+Example:
+
+```json
+[
+  {
+    "datasetId": "monitoring",
+    "datasetRegion": "EU",
+    "datasetFriendlyName": "Monitoring Dataset",
+    "datasetDescription": "Monitoring Dataset description",
+    "tables": [
+      {
+        "tableId": "job_failure",
+        "autodetect": false,
+        "tableSchemaPath": "schema/monitoring/job_failure.json",
+        "partitionType": "DAY",
+        "partitionField": "dwhCreationDate",
+        "clustering": [
+          "featureName",
+          "jobName",
+          "componentType"
+        ]
+      }
+    ]
+  }
+]
+```
+
+In this example, we have a dataset called `monitoring` with the metadata.\
+This dataset contains a table called `job_failure` with the metadata. Some fields can target on the `BigQuery` schemas proposed in the `root tables folder`.
+
+### Run with CLI
+
+We need to pass the 3 parameters indicated in the previous section, in the command line to launch the tests:
+
+- root-test-folder: the root folder containing all the testing files
+- root-tables-folder: the root folder containing all the needed files to create the datasets and tables in BigQuery (Json schema...)
+- tables-config-file: the Json configuration file that lists all the datasets and tables to create in BigQuery
+
+Also, common GCP parameters like:
+- project: the GCP project ID
+- region: the GCP region
+
+`BigTesty` uses an ephemeral infra internally via the concept of Infra As Code and the backend to host the state must be a `cloud Storage` bucket.\
+We need to pass the backend URL via parameter in the CLI:
+- iac-backend-url
+
+The tests can be executed with the following command line:
+
+```bash
+bigtesty test \
+  --project $PROJECT_ID \
+  --region $LOCATION \
+  --iac-backend-url gs://$IAC_BUCKET_STATE/bigtesty \
+  --root-test-folder $(pwd)/examples/tests \
+  --root-tables-folder $(pwd)/examples/tests/tables \
+  --tables-config-file $(pwd)/examples/tests/tables/tables.json
+```
+
+**All the testing files showed in the documentation are accessible from the `examples` folder proposed at the root of the `BigTesty` repo.**
+
+### Run with Docker
+
+Instead of pass the arguments by the CLI, we can also pass them with environment variables.
+
+```bash
+export PROJECT_ID={{project_id}}
+export LOCATION={{region}}
+export IAC_BACKEND_URL=gs://{{gcs_state_bucket}}/bigtesty
+export ROOT_TEST_FOLDER=/opt/bigtesty/tests
+export ROOT_TABLES_FOLDER=/opt/bigtesty/tests/tables
+export TABLES_CONFIG_FILE_PATH=/opt/bigtesty/tests/tables/tables.json
+
+docker run -it \
+   -e GOOGLE_PROJECT=$PROJECT_ID \
+   -e GOOGLE_REGION=$LOCATION \
+   -e IAC_BACKEND_URL=$IAC_BACKEND_URL \
+   -e TABLES_CONFIG_FILE="$TABLES_CONFIG_FILE_PATH" \
+   -e ROOT_TEST_FOLDER=$ROOT_TEST_FOLDER \
+   -e ROOT_TABLES_FOLDER="$ROOT_TABLES_FOLDER" \
+   -v $(pwd)/examples/tests:/opt/bigtesty/tests \
+   -v $(pwd)/examples/tests/tables:/opt/bigtesty/tests/tables \
+   -v $HOME/.config/gcloud:/opt/bigtesty/.config/gcloud \
+   groupbees/bigtesty test
+```
+
+Some explanations:
+
+All the parameters are passed as environment variables.\
+We need also to mount as volumes:
+- the tests root folder : `-v $(pwd)/examples/tests:/opt/bigtesty/tests`
+- the tables root folder: `-v $(pwd)/examples/tests/tables:/opt/bigtesty/tests/tables`
+- the `gcloud` configuration: `-v $HOME/.config/gcloud:/opt/bigtesty/.config/gcloud`
+
+When the authentication is done with Applications Default Credentials via the following command `gcloud auth application-default login`,\
+a short-lived credential is generated in the local `gcloud` configuration: `$HOME/.config/gcloud`
+
+To prevent the use of a long-lived SA token key, we can share and mount as volume the local `gcloud` configuration with the `Docker` container: `-v $HOME/.config/gcloud:/opt/bigtesty/.config/gcloud`\
+With this technic, the container will be authenticated in Google Cloud securely, with your current user in the Shell session.
+
+### Run with Cloud Build
+
+```bash
+export PROJECT_ID={{project_id}}
+export LOCATION={{region}}
+export IAC_BACKEND_URL=gs://{{gcs_state_bucket}}/bigtesty
+
+gcloud builds submit \
+   --project=$PROJECT_ID \
+   --region=$LOCATION \
+   --config examples/ci/cloud_build/run-tests-cloud-build.yaml \
+   --substitutions _IAC_BACKEND_URL=$IAC_BACKEND_URL \
+   --verbosity="debug" .
+```
+
+## Contributing
+
+cf. [CONTRIBUTING](CONTRIBUTING.md).
+
+

bigtesty-0.1.0/README.md

@@ -0,0 +1,202 @@
+# BigTesty
+
+BigTesty is a framework that allows to create Integration Tests with BigQuery on a real and short-lived Infrastructure.
+
+Integration and End-to-End tests are a robust way to validate if SQL queries work as expected.\
+There is no an emulator in this case and the queries are executed directly in the BigQuery Engine.
+
+BigTesty isolates the tests for each execution to prevent collisions.\
+Multiples developers or CI CD pipelines can execute tests at the same time.
+
+The infrastructure proposed for the tests is ephemeral by default, but we can keep it if needed, to analyse the\
+result in BigQuery.
+
+After each test, a report result is returned to indicate the good and failure cases.
+
+![bigtesty_pulumi_automation.png](diagram%2Fbigtesty_pulumi_automation.png)
+
+## Getting started
+
+There is a `Python` package for BigTesty and it can be installed from `PiPy`:
+
+```bash
+pip install bigtesty
+```
+
+## How to run tests
+
+**You need to be authenticated with Google Cloud Platform before running command.**
+
+We recommend to be authenticated with [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials)
+
+```bash
+gcloud auth application-default login
+```
+
+### Example of code structure
+
+![bigtesty_examples_code_structure.png](bigtesty-doc%2Fstatic%2Fimg%2Fbigtesty_examples_code_structure.png)
+
+**The root test folder**
+
+This folder contains all the testing definition files and the tests scenarios. The format is Json.
+
+Example of a scenarios with a nominal case `definition_spec_failure_by_feature_name_no_error.json`:
+
+```json
+{
+  "description": "Test of monitoring data",
+  "scenarios": [
+    {
+      "description": "Nominal case find failure by feature name",
+      "given": [
+        {
+          "input_file_path": "monitoring/given/input_failures_feature_name.json",
+          "destination_dataset": "monitoring",
+          "destination_table": "job_failure"
+        }
+      ],
+      "then": [
+        {
+          "fields_to_ignore": [
+            "\\[\\d+\\]\\['dwhCreationDate']"
+          ],
+          "actual_file_path": "monitoring/when/find_failures_by_feature_name.sql",
+          "expected_file_path": "monitoring/then/expected_failures_feature_name.json"
+        }
+      ]
+    }
+  ]
+}
+```
+
+In this example, there is only one scenario with 3 blocs:
+- `given`: a list of input test data to ingest to the BigQuery tables. The input data can be proposed in a separate `Json` file or directly embedded. `input_file_path` for a separate file and `input` for an embedded object.
+- `then`: a list of objects contains the SQL query to test and execute and the expected data. `actual/actual_file_path` => SQL query | `expected/expected_file_path` => expected data
+
+**The root tables folder**
+
+This folder contains the resources concerning the `BigQuery` `datasets` and `tables` to create.\
+For example, all the `BigQuery` schemas are proposed in this folder.
+
+**The tables config file**
+
+The config file that lists all the `BigQuery` `datasets` and `tables` to create in a `Json` format.
+
+Example:
+
+```json
+[
+  {
+    "datasetId": "monitoring",
+    "datasetRegion": "EU",
+    "datasetFriendlyName": "Monitoring Dataset",
+    "datasetDescription": "Monitoring Dataset description",
+    "tables": [
+      {
+        "tableId": "job_failure",
+        "autodetect": false,
+        "tableSchemaPath": "schema/monitoring/job_failure.json",
+        "partitionType": "DAY",
+        "partitionField": "dwhCreationDate",
+        "clustering": [
+          "featureName",
+          "jobName",
+          "componentType"
+        ]
+      }
+    ]
+  }
+]
+```
+
+In this example, we have a dataset called `monitoring` with the metadata.\
+This dataset contains a table called `job_failure` with the metadata. Some fields can target on the `BigQuery` schemas proposed in the `root tables folder`.
+
+### Run with CLI
+
+We need to pass the 3 parameters indicated in the previous section, in the command line to launch the tests:
+
+- root-test-folder: the root folder containing all the testing files
+- root-tables-folder: the root folder containing all the needed files to create the datasets and tables in BigQuery (Json schema...)
+- tables-config-file: the Json configuration file that lists all the datasets and tables to create in BigQuery
+
+Also, common GCP parameters like:
+- project: the GCP project ID
+- region: the GCP region
+
+`BigTesty` uses an ephemeral infra internally via the concept of Infra As Code and the backend to host the state must be a `cloud Storage` bucket.\
+We need to pass the backend URL via parameter in the CLI:
+- iac-backend-url
+
+The tests can be executed with the following command line:
+
+```bash
+bigtesty test \
+  --project $PROJECT_ID \
+  --region $LOCATION \
+  --iac-backend-url gs://$IAC_BUCKET_STATE/bigtesty \
+  --root-test-folder $(pwd)/examples/tests \
+  --root-tables-folder $(pwd)/examples/tests/tables \
+  --tables-config-file $(pwd)/examples/tests/tables/tables.json
+```
+
+**All the testing files showed in the documentation are accessible from the `examples` folder proposed at the root of the `BigTesty` repo.**
+
+### Run with Docker
+
+Instead of pass the arguments by the CLI, we can also pass them with environment variables.
+
+```bash
+export PROJECT_ID={{project_id}}
+export LOCATION={{region}}
+export IAC_BACKEND_URL=gs://{{gcs_state_bucket}}/bigtesty
+export ROOT_TEST_FOLDER=/opt/bigtesty/tests
+export ROOT_TABLES_FOLDER=/opt/bigtesty/tests/tables
+export TABLES_CONFIG_FILE_PATH=/opt/bigtesty/tests/tables/tables.json
+
+docker run -it \
+   -e GOOGLE_PROJECT=$PROJECT_ID \
+   -e GOOGLE_REGION=$LOCATION \
+   -e IAC_BACKEND_URL=$IAC_BACKEND_URL \
+   -e TABLES_CONFIG_FILE="$TABLES_CONFIG_FILE_PATH" \
+   -e ROOT_TEST_FOLDER=$ROOT_TEST_FOLDER \
+   -e ROOT_TABLES_FOLDER="$ROOT_TABLES_FOLDER" \
+   -v $(pwd)/examples/tests:/opt/bigtesty/tests \
+   -v $(pwd)/examples/tests/tables:/opt/bigtesty/tests/tables \
+   -v $HOME/.config/gcloud:/opt/bigtesty/.config/gcloud \
+   groupbees/bigtesty test
+```
+
+Some explanations:
+
+All the parameters are passed as environment variables.\
+We need also to mount as volumes:
+- the tests root folder : `-v $(pwd)/examples/tests:/opt/bigtesty/tests`
+- the tables root folder: `-v $(pwd)/examples/tests/tables:/opt/bigtesty/tests/tables`
+- the `gcloud` configuration: `-v $HOME/.config/gcloud:/opt/bigtesty/.config/gcloud`
+
+When the authentication is done with Applications Default Credentials via the following command `gcloud auth application-default login`,\
+a short-lived credential is generated in the local `gcloud` configuration: `$HOME/.config/gcloud`
+
+To prevent the use of a long-lived SA token key, we can share and mount as volume the local `gcloud` configuration with the `Docker` container: `-v $HOME/.config/gcloud:/opt/bigtesty/.config/gcloud`\
+With this technic, the container will be authenticated in Google Cloud securely, with your current user in the Shell session.
+
+### Run with Cloud Build
+
+```bash
+export PROJECT_ID={{project_id}}
+export LOCATION={{region}}
+export IAC_BACKEND_URL=gs://{{gcs_state_bucket}}/bigtesty
+
+gcloud builds submit \
+   --project=$PROJECT_ID \
+   --region=$LOCATION \
+   --config examples/ci/cloud_build/run-tests-cloud-build.yaml \
+   --substitutions _IAC_BACKEND_URL=$IAC_BACKEND_URL \
+   --verbosity="debug" .
+```
+
+## Contributing
+
+cf. [CONTRIBUTING](CONTRIBUTING.md).

bigtesty-0.1.0/bigtesty/arguments.py

@@ -0,0 +1,7 @@
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--root_folder', dest='root_folder', type=str, help='Root folder')
+parser.add_argument('--project_id', dest='project_id', type=str, help='GCP Project ID')
+parser.add_argument('--datasets_hash', dest='datasets_hash', type=str, help='Unique hash to isolate datasets')
+args = parser.parse_args()

bigtesty-0.1.0/bigtesty/cli/cli_env_vars.py

@@ -0,0 +1,13 @@
+GOOGLE_PROJECT_KEY = "GOOGLE_PROJECT"
+GOOGLE_REGION_KEY = "GOOGLE_REGION"
+IAC_BACKEND_URL_KEY = "IAC_BACKEND_URL"
+ROOT_TEST_FOLDER_KEY = "ROOT_TEST_FOLDER"
+ROOT_TABLES_FOLDER_KEY = "ROOT_TABLES_FOLDER"
+TABLES_CONFIG_FILE_KEY = "TABLES_CONFIG_FILE"
+KEEP_INFRA_KEY = "KEEP_INFRA"
+BIGTESTY_STACK_NAME_KEY = "BIGTESTY_STACK_NAME"
+PULUMI_CONFIG_PASSPHRASE_KEY = "PULUMI_CONFIG_PASSPHRASE"
+PULUMI_BACKEND_URL_KEY = "PULUMI_BACKEND_URL"
+
+BIGTESTY_STACK_NAME_VALUE = "bigtesty"
+PULUMI_CONFIG_PASSPHRASE_VALUE = "gcp_fake_passphrase"

bigtesty-0.1.0/bigtesty/cli/main.py

@@ -0,0 +1,102 @@
+import os
+
+import typer
+from typing_extensions import Annotated
+
+from bigtesty.cli.cli_env_vars import ROOT_TEST_FOLDER_KEY, ROOT_TABLES_FOLDER_KEY, TABLES_CONFIG_FILE_KEY, \
+    KEEP_INFRA_KEY, BIGTESTY_STACK_NAME_KEY, PULUMI_CONFIG_PASSPHRASE_KEY, PULUMI_BACKEND_URL_KEY, IAC_BACKEND_URL_KEY, \
+    BIGTESTY_STACK_NAME_VALUE, PULUMI_CONFIG_PASSPHRASE_VALUE, GOOGLE_PROJECT_KEY, GOOGLE_REGION_KEY
+from bigtesty.infra.launch_tests_ephemeral_infra import launch_tests_ephemeral_infra
+
+app = typer.Typer()
+
+
+@app.command("test", help="Run tests")
+def run_tests(
+        project: Annotated[
+            str,
+            typer.Option(
+                "--project",
+                envvar=GOOGLE_PROJECT_KEY,
+                help="GCP project ID."
+            )
+        ],
+        region: Annotated[
+            str,
+            typer.Option(
+                "--region",
+                envvar=GOOGLE_REGION_KEY,
+                help="GCP region."
+            )
+        ],
+        iac_backend_url: Annotated[
+            str,
+            typer.Option(
+                "--iac-backend-url",
+                envvar=IAC_BACKEND_URL_KEY,
+                help="IaC backend URL for the ephemeral infra used for the tests."
+            )
+        ],
+        root_test_folder: Annotated[
+            str,
+            typer.Option(
+                "--root-test-folder",
+                envvar=ROOT_TEST_FOLDER_KEY,
+                help="Directory that contains test scenarios."
+            )
+        ],
+        root_tables_folder: Annotated[
+            str,
+            typer.Option(
+                "--root-tables-folder",
+                envvar=ROOT_TABLES_FOLDER_KEY,
+                help="Directory that contains schema files."
+            )
+        ],
+        tables_config_file_path: Annotated[
+            str,
+            typer.Option(
+                "--tables-config-file",
+                envvar=TABLES_CONFIG_FILE_KEY,
+                help="Path to configuration file."
+            )
+        ],
+        keep_infra: Annotated[
+            bool,
+            typer.Option(
+                "--keep-infra",
+                envvar=KEEP_INFRA_KEY,
+                help="Keep infrastructure after exit."
+            )
+        ] = False):
+    print(f"####################### The CLI is invoked with params : ")
+
+    print(f"project : {project}")
+    print(f"region : {region}")
+    print(f"iac-backend-url : {iac_backend_url}")
+    print(f"root-test-folder : {root_test_folder}")
+    print(f"root-tables-folder : {root_tables_folder}")
+    print(f"tables-config-file : {tables_config_file_path}")
+    print(f"keep-infra : {keep_infra}")
+
+    os.environ[GOOGLE_PROJECT_KEY] = project
+    os.environ[GOOGLE_REGION_KEY] = region
+    os.environ[PULUMI_BACKEND_URL_KEY] = iac_backend_url
+    os.environ[PULUMI_CONFIG_PASSPHRASE_KEY] = PULUMI_CONFIG_PASSPHRASE_VALUE
+    os.environ[BIGTESTY_STACK_NAME_KEY] = BIGTESTY_STACK_NAME_VALUE
+
+    launch_tests_ephemeral_infra(
+        root_test_folder=root_test_folder,
+        root_tables_folder=root_tables_folder,
+        tables_config_file_path=tables_config_file_path,
+        keep_infra=keep_infra
+    )
+
+
+@app.command("help")
+def help():
+    print("BigTesty is an integration testing framework for BigQuery")
+
+
+def run():
+    app()

bigtesty-0.1.0/bigtesty/dataset_helper.py

@@ -0,0 +1,4 @@
+def build_unique_dataset_id_for_scenario(dataset_id: str,
+                                         scenario_hash: str,
+                                         datasets_hash: str) -> str:
+    return f'{dataset_id}_{scenario_hash}_{datasets_hash}'

bigtesty-0.1.0/bigtesty/definition_test_config_helper.py

@@ -0,0 +1,57 @@
+import glob
+import json
+from typing import List, Dict
+
+from deepdiff import DeepHash
+
+from bigtesty.definition_test_file_exception import DefinitionTestFileException
+from bigtesty.lambda_functions import flat_map
+
+DEFINITION_TEST_FILE_PATTERN = "**/definition_*.json"
+
+
+def get_definition_test_dicts_from_path(data_testing_root_path: str) -> List[Dict]:
+    """
+     Gets all the test definition files existing in the given folder path and then map them to dicts.
+     The result is a list of dict, and each dict represents a test definition.
+     If there is no definition files in the given folder, a :class:`~DefinitionTestFileException` is raised.
+    :param data_testing_root_path: the root folder path containing test definition files
+    :return: a list of test definition dict
+    """
+    print("#############ROOT DIR")
+    print(data_testing_root_path)
+
+    definition_test_file_paths: List[str] = get_definition_tests_file_paths(data_testing_root_path)
+
+    if not definition_test_file_paths:
+        raise DefinitionTestFileException(
+            f'There is no definition files in the given folder path {data_testing_root_path}'
+        )
+
+    return list(map(lambda path: to_definition_test_dict(path), definition_test_file_paths))
+
+
+def get_scenarios(data_testing_root_path: str):
+    return list(
+        flat_map(lambda deftest: deftest['scenarios'], get_definition_test_dicts_from_path(data_testing_root_path))
+    )
+
+
+def get_definition_tests_file_paths(data_testing_root_path: str) -> List[str]:
+    """
+    Gets all the test definitions file paths existing in the given folder path.
+    The search of files is recursive.
+    """
+    return glob.glob(
+        pathname=f'{data_testing_root_path}/{DEFINITION_TEST_FILE_PATTERN}',
+        recursive=True
+    )
+
+
+def to_definition_test_dict(definition_test_file_path: str):
+    with open(definition_test_file_path) as definition_test_file:
+        return json.load(definition_test_file)
+
+
+def get_scenario_hash(scenario_dict: Dict) -> str:
+    return DeepHash(scenario_dict)[scenario_dict]

bigtesty-0.1.0/bigtesty/definition_test_file_exception.py

@@ -0,0 +1,2 @@
+class DefinitionTestFileException(Exception):
+    pass

bigtesty-0.1.0/bigtesty/files_loader_helper.py

@@ -0,0 +1,12 @@
+import json
+from typing import List, Dict
+
+
+def load_file_as_dicts(file_path: str) -> List[Dict]:
+    with open(file_path) as file:
+        return json.load(file)
+
+
+def load_file_as_string(file_path: str) -> str:
+    with open(file_path, 'r') as file:
+        return file.read().rstrip()