bigtesty 0.1.0a1__py3-none-any.whl

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/dataset_helper.py

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

bigtesty/definition_test_config_helper.py

@@ -0,0 +1,51 @@
+import glob
+import json
+from typing import List, Dict
+
+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)

bigtesty/definition_test_file_exception.py

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

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()

bigtesty/given/insertion_test_data_bigquery.py

@@ -0,0 +1,40 @@
+from typing import List, Dict
+
+from google.cloud import bigquery
+
+from bigtesty.dataset_helper import build_unique_dataset_id_for_scenario
+from bigtesty.files_loader_helper import load_file_as_dicts
+
+
+def insert_test_data_to_bq_tables(
+        project_id: str,
+        root_test_folder: str,
+        datasets_hash: str,
+        scenarios: List[Dict]) -> None:
+    client = bigquery.Client(project=project_id)
+
+    for scenario in scenarios:
+        for given in scenario['given']:
+            print("###### GIVEN")
+            print(given)
+
+            input_file_path = f"{root_test_folder}/{given['input_file_path']}"
+            input = given.get('input')
+            input_as_dicts: List[Dict] = input if input else load_file_as_dicts(input_file_path)
+
+            print("####### INPUT AS DICT")
+            print(input_as_dicts)
+
+            dataset_id_with_hash = build_unique_dataset_id_for_scenario(
+                dataset_id=given['destination_dataset'],
+                scenario_id=scenario["id"],
+                datasets_hash=datasets_hash
+            )
+
+            results = client.insert_rows_json(
+                f"{dataset_id_with_hash}.{given['destination_table']}",
+                input_as_dicts
+            )
+
+            print("###### RESULTS")
+            print(results)

bigtesty/infra/create_iac_for_datasets_with_tables.py

@@ -0,0 +1,49 @@
+from typing import Dict, List
+
+from pulumi_gcp.bigquery import Dataset
+
+from bigtesty.dataset_helper import build_unique_dataset_id_for_scenario
+from bigtesty.infra.datasets_with_tables_factory import get_dataset, get_table_with_partitioning, get_table
+
+
+def create_datasets_and_tables(root_tables_folder: str,
+                               datasets_with_tables_config: List[Dict],
+                               datasets_hash: str,
+                               scenarios: List[Dict]) -> None:
+    for dataset_config in datasets_with_tables_config:
+        for scenario in scenarios:
+            dataset_id_with_hash = build_unique_dataset_id_for_scenario(
+                dataset_id=dataset_config["datasetId"],
+                scenario_id=scenario["id"],
+                datasets_hash=datasets_hash
+            )
+
+            bq_dataset = get_dataset(dataset_id_with_hash, dataset_config)
+
+            create_tables(
+                root_tables_folder=root_tables_folder,
+                dataset_config=dataset_config,
+                dataset=bq_dataset,
+                dataset_id_with_hash=dataset_id_with_hash
+            )
+
+
+def create_tables(root_tables_folder: str,
+                  dataset_config: Dict,
+                  dataset: Dataset,
+                  dataset_id_with_hash: str) -> None:
+    for table_config in dataset_config["tables"]:
+        (
+            get_table_with_partitioning(
+                root_tables_folder=root_tables_folder,
+                dataset_id_with_hash=dataset_id_with_hash,
+                dataset=dataset,
+                table=table_config
+            ) if table_config.get("partitionType") is not None
+            else get_table(
+                root_tables_folder=root_tables_folder,
+                dataset_id_with_hash=dataset_id_with_hash,
+                dataset=dataset,
+                table=table_config
+            )
+        )

bigtesty/infra/datasets_with_tables_config_file_loader.py

@@ -0,0 +1,28 @@
+import json
+import random
+import string
+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) as file:
+        return file.read()
+
+
+def get_table_schema(root_tables_folder: str, table: Dict) -> str:
+    datasets_tables_config_file_path = f'{root_tables_folder}/{table["tableSchemaPath"]}'
+
+    return _load_file_as_string(datasets_tables_config_file_path)
+
+
+def get_datasets_hash(length) -> str:
+    letters = string.ascii_lowercase
+    datasets_hash = ''.join(random.choice(letters) for _ in range(length))
+    print(f'The generated datasets hash is : {datasets_hash}')
+
+    return datasets_hash

bigtesty/infra/datasets_with_tables_factory.py

@@ -0,0 +1,55 @@
+from typing import Dict
+
+import pulumi_gcp as gcp
+from pulumi import ResourceOptions
+from pulumi_gcp.bigquery import Dataset
+
+from bigtesty.infra.datasets_with_tables_config_file_loader import get_table_schema
+
+
+def get_table(root_tables_folder: str,
+              dataset_id_with_hash: str,
+              dataset: Dataset,
+              table: Dict):
+    return gcp.bigquery.Table(
+        get_table_resource_name(dataset_id_with_hash, table['tableId']),
+        deletion_protection=False,
+        dataset_id=dataset.dataset_id,
+        table_id=table["tableId"],
+        clusterings=table.get("clustering"),
+        schema=get_table_schema(root_tables_folder, table),
+        opts=ResourceOptions(depends_on=[dataset])
+    )
+
+
+def get_table_with_partitioning(root_tables_folder: str,
+                                dataset_id_with_hash: str,
+                                dataset: Dataset,
+                                table: Dict):
+    return gcp.bigquery.Table(
+        get_table_resource_name(dataset_id_with_hash, table['tableId']),
+        deletion_protection=False,
+        dataset_id=dataset.dataset_id,
+        table_id=table["tableId"],
+        clusterings=table.get("clustering"),
+        time_partitioning=gcp.bigquery.TableTimePartitioningArgs(
+            type=table["partitionType"],
+            field=table["partitionField"],
+        ),
+        schema=get_table_schema(root_tables_folder, table),
+        opts=ResourceOptions(depends_on=[dataset])
+    )
+
+
+def get_table_resource_name(dataset_id: str, table_id: str) -> str:
+    return f'{dataset_id}_{table_id}'
+
+
+def get_dataset(dataset_id_with_hash: str, dataset: Dict):
+    return gcp.bigquery.Dataset(
+        dataset_id_with_hash,
+        dataset_id=dataset_id_with_hash,
+        friendly_name=dataset["datasetFriendlyName"],
+        description=dataset["datasetDescription"],
+        location=dataset["datasetRegion"]
+    )

bigtesty/infra/launch_tests_ephemeral_infra.py

@@ -0,0 +1,107 @@
+import json
+import os
+from typing import List, Dict
+
+from pulumi import automation as auto
+
+from bigtesty.definition_test_config_helper import get_scenarios
+from bigtesty.given.insertion_test_data_bigquery import insert_test_data_to_bq_tables
+from bigtesty.infra.create_iac_for_datasets_with_tables import create_datasets_and_tables
+from bigtesty.infra.datasets_with_tables_config_file_loader import get_datasets_hash, \
+    _load_file_as_dicts
+from bigtesty.then.assertion_and_tests_reports_result import execute_query_and_build_reports_result, \
+    check_any_failed_test_in_reports
+
+
+def launch_tests_ephemeral_infra(root_test_folder: str,
+                                 root_tables_folder: str,
+                                 tables_config_file_path: str):
+    project_id = os.environ["GOOGLE_PROJECT"]
+    region = os.environ["GOOGLE_REGION"]
+    stack_name = os.environ["BIGTESTY_STACK_NAME"]
+
+    datasets_hash = get_datasets_hash(5)
+
+    scenarios = get_scenarios(root_test_folder)
+
+    stack = auto.create_or_select_stack(
+        stack_name=stack_name,
+        project_name=project_id,
+        program=lambda: pulumi_program(scenarios,
+                                       datasets_hash,
+                                       root_tables_folder,
+                                       tables_config_file_path)
+    )
+
+    print("Successfully initialized stack")
+
+    # for inline programs, we must manage plugins ourselves
+    print("Installing plugins...")
+    stack.workspace.install_plugin("gcp", "v6.67.0")
+    print("Plugins installed")
+
+    print("Setting up config")
+    stack.set_config("gcp:project", auto.ConfigValue(value=project_id))
+    stack.set_config("gcp:region", auto.ConfigValue(value=region))
+    print("Config set")
+
+    print("Refreshing stack...")
+    stack.refresh(on_output=print)
+    print("Refresh complete")
+
+    print("#################### Creating the ephemeral infra...")
+    up_res = stack.up(
+        on_output=print,
+        color="always",
+        show_secrets=False,
+        diff=True
+    )
+    print(f"Update summary: \n{json.dumps(up_res.summary.resource_changes, indent=4)}")
+
+    print("#################### Inserting Test data to Tables...")
+    insert_test_data_to_bq_tables(
+        project_id=project_id,
+        root_test_folder=root_test_folder,
+        datasets_hash=datasets_hash,
+        scenarios=scenarios
+    )
+
+    print("#################### Execute SQL queries and generate reports result...")
+    reports_result: List[Dict] = execute_query_and_build_reports_result(
+        project_id=project_id,
+        root_test_folder=root_test_folder,
+        datasets_hash=datasets_hash,
+        scenarios=scenarios
+    )
+
+    print("################## The reports result is #################")
+    print(reports_result)
+    print("#################")
+
+    print("################### Destroying the ephemeral infra and tests assertions...")
+    stack.destroy(
+        on_output=print,
+        color="always",
+        show_secrets=False,
+        log_flow=True,
+        log_verbosity=3
+    )
+    print("############### Destroy ephemeral infra complete")
+
+    print("############### After destroying the ephemeral infra, checking if there is any failed test...")
+    check_any_failed_test_in_reports(reports_result)
+    print("############### Tests assertions finished")
+
+
+def pulumi_program(scenarios: List[Dict],
+                   datasets_hash: str,
+                   root_tables_folder: str,
+                   tables_config_file_path: str):
+    datasets_with_tables_config = _load_file_as_dicts(tables_config_file_path)
+
+    create_datasets_and_tables(
+        root_tables_folder=root_tables_folder,
+        datasets_with_tables_config=datasets_with_tables_config,
+        datasets_hash=datasets_hash,
+        scenarios=scenarios
+    )

bigtesty/lambda_functions.py

@@ -0,0 +1 @@
+flat_map = lambda f, xs: (y for ys in xs for y in f(ys))

bigtesty/then/assertion_and_tests_reports_result.py

@@ -0,0 +1,129 @@
+import re
+from typing import List, Dict
+
+import deepdiff
+from google.cloud import bigquery
+from google.cloud.bigquery import Client
+from toolz.curried import pipe, map
+
+from bigtesty.dataset_helper import build_unique_dataset_id_for_scenario
+from bigtesty.files_loader_helper import load_file_as_string, load_file_as_dicts
+from bigtesty.then.failure_test_exception import FailureTestException
+
+
+def execute_query_and_build_reports_result(
+        project_id: str,
+        root_test_folder: str,
+        datasets_hash: str,
+        scenarios: List[Dict]) -> List[Dict]:
+    client = bigquery.Client(project=project_id)
+
+    return list(pipe(
+        scenarios,
+        map(lambda scenario: _execute_query_and_build_report_result(
+            bigquery_python_client=client,
+            scenario=scenario,
+            root_test_folder=root_test_folder,
+            datasets_hash=datasets_hash
+        ))
+    ))
+
+
+def check_any_failed_test_in_reports(reports_result: List[Dict]) -> bool:
+    any_failed_test: bool = any(report['result'] is False for report in reports_result)
+
+    if any_failed_test:
+        print("There is any failed test in the reports result, the pipeline is in failure status !!")
+        raise FailureTestException('Error : there is any failed test !!!')
+
+    print("There is no failed test in the reports result, the pipeline is in success status !!")
+    return any_failed_test
+
+
+def _execute_query_and_build_report_result(bigquery_python_client: Client,
+                                           scenario: Dict,
+                                           root_test_folder: str,
+                                           datasets_hash: str) -> Dict:
+    given_list: List[Dict] = scenario["given"]
+
+    for then in scenario["then"]:
+        print("######THEN")
+        print(then)
+
+        query = _build_query(
+            scenario_id=scenario["id"],
+            datasets_hash=datasets_hash,
+            root_test_folder=root_test_folder,
+            given_list=given_list,
+            then=then
+        )
+
+        print("#########SQL QUERY")
+        print(query)
+
+        query_job = bigquery_python_client.query(query)
+        actual_list: List[Dict] = list(map(lambda r: dict(r), query_job.result()))
+        print("#########ACTUAL")
+        print(actual_list)
+
+        expected_list = _get_expected_list(root_test_folder, then)
+        print("#########EXPECTED")
+        print(expected_list)
+
+        fields_to_ignore_compiled_regex = list(
+            map(lambda field_regex: re.compile(field_regex), then['fields_to_ignore'])
+        )
+
+        result: Dict = deepdiff.DeepDiff(actual_list,
+                                         expected_list,
+                                         ignore_order=True,
+                                         exclude_regex_paths=fields_to_ignore_compiled_regex,
+                                         view='tree')
+        print("#########TEST RESULT")
+        print(result)
+
+        return {
+            'scenario': scenario,
+            'actual': actual_list,
+            'expected': expected_list,
+            'comparison_info': result,
+            'result': result == {}
+        }
+
+
+def _build_query(scenario_id: str,
+                 datasets_hash: str,
+                 root_test_folder: str,
+                 given_list: List[Dict],
+                 then: Dict) -> str:
+    actual = then.get('actual')
+    sql_query = actual if actual else load_file_as_string(f"{root_test_folder}/{then['actual_file_path']}")
+
+    sql_query_result = ""
+    for given in given_list:
+        sql_query_result = _replace_current_dataset_by_unique_dataset_for_scenario(
+            sql_query=sql_query,
+            current_dataset=given["destination_dataset"],
+            scenario_id=scenario_id,
+            datasets_hash=datasets_hash
+        )
+
+    return sql_query_result
+
+
+def _replace_current_dataset_by_unique_dataset_for_scenario(sql_query: str,
+                                                            current_dataset: str,
+                                                            scenario_id: str,
+                                                            datasets_hash: str) -> str:
+    unique_dataset_with_for_scenario = build_unique_dataset_id_for_scenario(
+        dataset_id=current_dataset,
+        scenario_id=scenario_id,
+        datasets_hash=datasets_hash
+    )
+
+    return sql_query.replace(f"{current_dataset}.", f"{unique_dataset_with_for_scenario}.")
+
+
+def _get_expected_list(root_test_folder: str, then: Dict) -> List[Dict]:
+    expected = then.get('expected')
+    return expected if expected else load_file_as_dicts(f"{root_test_folder}/{then['expected_file_path']}")

bigtesty/then/failure_test_exception.py

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

bigtesty-0.1.0a1.dist-info/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.0a1.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.1
+Name: bigtesty
+Version: 0.1.0a1
+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.18
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pulumi-gcp ==6.67.0
+Requires-Dist: google-cloud-bigquery ==3.7.0
+Requires-Dist: typer[all] ==0.9.0
+Requires-Dist: pytest ==7.2.1
+Requires-Dist: deepdiff ==6.3.0
+Requires-Dist: toolz ==0.12.0
+
+# bigtesty
+
+BigTesty is a framework that allows to create Integration Tests with BigQuery on a real and short-lived Infrastructure.
+
+## Run integration tests with BigTesty
+
+```bash
+ docker run -it \
+    -e GOOGLE_PROJECT=$PROJECT_ID \
+    -e SA_EMAIL=$SA_EMAIL \
+    -e GOOGLE_REGION=$LOCATION \
+    -e PULUMI_BACKEND_URL=$IAC_BACKEND_URL \
+    -e ROOT_TEST_FOLDER=$ROOT_TEST_FOLDER \
+    -e BIGTESTY_STACK_NAME=bigtesty \
+    -e PULUMI_CONFIG_PASSPHRASE=gcp_fake_passphrase \
+    -v $(pwd)/tests:/app/tests \
+    -v $(pwd)/tests/tables:/app/bigtesty/infra/resource/tables \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    -v $HOME/.config/gcloud:/root/.config/gcloud \
+     bigtesty-pulumi
+```
+
+```
+docker build -f Dockerfile -t bigtesty  --progress plain .
+```
+
+

bigtesty-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,23 @@
+bigtesty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigtesty/arguments.py,sha256=JwwMPFkRSSrWILzO6mY9Xlbbajk4cs6ddFbC4zyrQs0,365
+bigtesty/dataset_helper.py,sha256=mk7Klu-Nb8t17yyNie948nkYHGIY9rz-Atxr2cuGdGw,286
+bigtesty/definition_test_config_helper.py,sha256=41xakzxtZAGxoj8ZvsuTgyYf9PQYU_8WoJbyp1zxpf0,1921
+bigtesty/definition_test_file_exception.py,sha256=2ojAbfQ_FSN4Gq-f82ARynQvFYDBaAOy4bAZ4tqUZB0,55
+bigtesty/files_loader_helper.py,sha256=hUBQ8jVuIULc0auAd0g2Bw2HEHOckg2WKo89VlamWe4,288
+bigtesty/lambda_functions.py,sha256=Kha-s1_P_BU5d-PAY2HOW11tnZNa0EiGVSFyn9HquYI,57
+bigtesty/given/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigtesty/given/insertion_test_data_bigquery.py,sha256=lLNM9KP2zf-X3X5yFbkDCYCiWhR_Hlodrvoqvs37ank,1296
+bigtesty/infra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigtesty/infra/create_iac_for_datasets_with_tables.py,sha256=oWX7tuK1xzLpASARQ0Qpp0-vLLcwtKwBTYJLw8mjeAo,1887
+bigtesty/infra/datasets_with_tables_config_file_loader.py,sha256=zIsQkq-_ygZ8ffYWyPo1z31v_wlBTYrDxvNwafzMZfQ,771
+bigtesty/infra/datasets_with_tables_factory.py,sha256=xxKn7H6e5ufxtneG_svYvDwUutZm1UZcXnrlrMGYmQ0,1903
+bigtesty/infra/launch_tests_ephemeral_infra.py,sha256=8Tbx70TsP63pUGpBq2Ujab9d6GpDtDJL5O9XyNHCVDQ,3801
+bigtesty/then/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigtesty/then/assertion_and_tests_reports_result.py,sha256=Elx0NOhgwxFVDWN4f3vFreQU3L4WIvAfFiCqhYbX9ik,4659
+bigtesty/then/failure_test_exception.py,sha256=XGdZ75LXL3TpNV7zaZvSj-6S21pUBRkh-J_ygaQDIIE,48
+bigtesty-0.1.0a1.dist-info/LICENSE,sha256=aBCOCCCvY_F67UK2dRXZ9vJccUsM1hyU34OTSo_CgJI,1069
+bigtesty-0.1.0a1.dist-info/METADATA,sha256=_wpLt4dwhmkDzMKxHtIhvG-rOp0xlcj9TSlLo7EcXYg,1475
+bigtesty-0.1.0a1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bigtesty-0.1.0a1.dist-info/entry_points.txt,sha256=kjIHnEfQrvmIoEceW6l5xLvzqQNjbVJ2almYITl9RFw,70
+bigtesty-0.1.0a1.dist-info/top_level.txt,sha256=iAitepHcGGQQNekCFAr2NrkMPd8rvWichurwR-mrxXw,9
+bigtesty-0.1.0a1.dist-info/RECORD,,

bigtesty-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bigtesty-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+
+        [console_scripts]
+        bigtesty=bigtesty.cli.main:run
+    

bigtesty-0.1.0a1.dist-info/top_level.txt

@@ -0,0 +1 @@
+bigtesty