Initial commit

Warrfie · Warrfie · commit 962d938a30c7 · 2023-02-10T19:27:30.000+03:00
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Maxim
+
+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.
diff --git a/README.md b/README.md
@@ -0,0 +1,10 @@
+[![PyPi Package Version](https://img.shields.io/pypi/v/combidate.svg)](https://pypi.python.org/pypi/re-generate)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/combidate.svg)](https://pypi.python.org/pypi/re-generate)
+[![PyPi status](https://img.shields.io/pypi/status/combidate.svg?style=flat-square)](https://pypi.python.org/pypi/re-generate)
+
+# <p align="center">Combidate
+
+<p align="center">A simple and light package for QA development which can generate random data from given cases.</p>
+<p align="center">Technical documentation is not prepared now, sorry.</p>
+
+
diff --git a/combidata/__init__.py b/combidata/__init__.py
@@ -0,0 +1,16 @@
+from combidata.classes.data_generator import DataGenerator
+from combidata.classes.process import Process
+from combidata.processes.combine import combine
+from combidata.processes.form import form
+from combidata.processes.genetate import generate
+
+
+
+ST_COMBINE = Process("ST_COMBINE", combine)
+ST_GENERATE = Process("ST_GENERATE", generate)
+ST_FORM = Process("ST_FORM", form)
+
+
+
+
+
diff --git a/combidata/classes/__init__.py b/combidata/classes/__init__.py
diff --git a/combidata/classes/case.py b/combidata/classes/case.py
@@ -0,0 +1,37 @@
+import copy
+
+
+class Case:
+    field_name = None
+    field_mode = None
+
+    value = None
+    case_name = None
+
+    is_presented = True
+
+    gen_func = None
+    type_of_case = None
+    requirements = None
+    options = None
+
+
+
+    def __init__(self, case: dict, field_name, field_mode):
+        self.field_name = field_name
+        self.field_mode = field_mode
+        self.case_name = case["name"]
+
+        self.value = None if "value" not in case.keys() else case["value"]
+
+        self.type_of_case = None if "type" not in case.keys() else case["type"]
+
+        self.gen_func = None if "gen_func" not in case.keys() else case["gen_func"]
+
+        self.is_presented = True if "is_presented" not in case.keys() else case["is_presented"]
+
+        self.requirements = None if "requirements" not in case.keys() else case["requirements"]
+
+        self.options = None if "options" not in case.keys() else case["options"]
+
+        self.additional_fields = copy.deepcopy(case) #TODO make normal warehouse
diff --git a/combidata/classes/combination.py b/combidata/classes/combination.py
@@ -0,0 +1,52 @@
+def step_not_done(current_step_name, combi):
+    if isinstance(combi, list):
+        for combination in combi:
+            if combination.step_done != current_step_name or combination.step_done == "STOP":
+                return True
+    else:
+        if combi.step_done != current_step_name or combi.step_done == "STOP":
+            return True
+    return False
+
+class Combination:
+    format_func = None
+    export_func = None
+
+    test_seed = None
+    formed_data = None
+
+    first_comb_func = None
+    first_gen_func = None
+    uni_export_format = None
+    answer = None
+    uni_prove = None
+    uni_result_format = None
+
+    cache = None
+    dev_log = None
+    prod_log = None
+
+    step_done = None  # last passed step
+
+    def __init__(self, case, workflow, init_lib, template, tools, type_of_cases=None):
+        self.init_lib = init_lib
+        self.main_case = case
+        self.template = template
+        self.tools = tools
+
+        self.generated_data = {}
+        self.other_cases = {}
+
+        self.cache = {}
+
+        self.type_of_cases = type_of_cases
+
+        self.workflow = workflow
+
+    def run(self):
+        self.workflow = list(self.workflow) if isinstance(self.workflow, list) else self.workflow #todo beautify
+        workflow = self.workflow.pop(0) if isinstance(self.workflow, list) else self.workflow
+        for current_step in workflow:
+            while step_not_done(current_step.name, self):
+                if self.step_done != current_step.name:
+                    current_step.activate(self)
diff --git a/combidata/classes/data_generator.py b/combidata/classes/data_generator.py
@@ -0,0 +1,71 @@
+import random
+
+from combidata.classes.case import Case
+from combidata.classes.combination import Combination, step_not_done
+
+
+class DataGenerator:
+    def __init__(self, library: dict, banned_fields=None, possible_fields=None, possible_modes=None, type_of_cases=None, amount=None):
+        assert banned_fields is None or isinstance(banned_fields, list), "banned_fields must be list instance"
+        assert possible_fields is None or isinstance(possible_fields, list), "possible_fields must be list instance"
+        assert banned_fields is None or possible_fields is None, "You can't use banned_fields and possible_fields arguments simultaneously"
+
+        self.combinations = {}
+
+        self.init_lib = {}
+        for field_name, field in library["cases"].items():
+            self.init_lib[field_name] = {}
+            for mode_name, mode in field.items():
+                self.init_lib[field_name].update({mode_name: Case(mode, field_name, mode_name)})
+
+        if possible_fields is not None or banned_fields is not None:
+            banned_fields = banned_fields if possible_fields is None else [field for field in self.init_lib.keys() if field not in possible_fields]
+            for field in banned_fields:
+                del self.init_lib[field]
+
+
+        self.form_lib = library["form"]
+        self.tools = library["tools"]
+        if isinstance(library["workflow"], dict):
+            if type_of_cases in library["workflow"].keys():
+                self.workflow = library["workflow"][type_of_cases]
+            else:
+                self.workflow = library["workflow"]["standart"]
+        else:
+            self.workflow = library["workflow"]
+        # TODO for next realises — make more consistency checks
+
+
+
+        if type_of_cases is None:
+            for field_name, cases in self.init_lib.items():
+                for field_mode, case in cases.items():
+                    if possible_modes is not None and field_name in possible_modes.keys() and field_mode not in possible_modes[field_name]:
+                        case.type_of_case = "OFF"
+                    if case.type_of_case is None:
+                        assert case.case_name not in self.combinations.keys(), case.case_name + " - is not unique"
+                        self.combinations.update({case.case_name: Combination(case, self.workflow, self.init_lib, self.form_lib, self.tools)})
+        else:
+            for field_name, cases in self.init_lib.items():
+                for field_mode, case in cases.items():
+                    if possible_modes is not None and field_name in possible_modes.keys() and field_mode not in possible_modes[field_name]:
+                        case.type_of_case = "OFF"
+                    if case.type_of_case == type_of_cases:
+                        assert case.case_name not in self.combinations.keys(), case.case_name + " - is not unique"
+                        self.combinations.update({case.case_name: Combination(case, self.workflow, self.init_lib, self.form_lib, self.tools, type_of_cases)})
+
+        if amount is not None: # TODO for next realises — upgrade that algorithm
+            if amount >= len(self.combinations.keys()):
+                return # TODO for next realises — make additional cases
+            for _ in amount:
+                del self.combinations[random.choice([self.combinations.keys()])]
+
+
+    def run(self):
+        workflow = self.workflow.pop(0) if isinstance(self.workflow, list) else self.workflow
+
+        for current_step in workflow:
+            while step_not_done(current_step.name, list(self.combinations.values())):
+                for combination in self.combinations.values():
+                    if combination.step_done != current_step.name:
+                        current_step.activate(combination)
diff --git a/combidata/classes/process.py b/combidata/classes/process.py
@@ -0,0 +1,9 @@
+class Process:
+
+    def __init__(self, name, func):
+        self.name = name
+        self.func = func
+
+    def activate(self, combination):
+        if self.func(combination):
+            combination.step_done = self.name
diff --git a/combidata/processes/__init__.py b/combidata/processes/__init__.py
diff --git a/combidata/processes/combine.py b/combidata/processes/combine.py
@@ -0,0 +1,63 @@
+import copy
+import random
+
+def check_join(main, rule):
+    for field, mode in rule.items():
+        if field in main.keys():
+            if mode != main[field]:
+                return False
+    return True
+
+def form_requirements(init_lib, rule):#todo add [] list choise
+    exp = copy.deepcopy(rule)
+    for field, mode in rule.items():
+        if init_lib[field][mode].requirements is not None:
+            new_rule = form_requirements(init_lib, init_lib[field][mode].requirements)
+            if check_join(exp, new_rule):
+                exp.update(new_rule)
+    return exp
+
+def combine(combination):
+    combination.test_seed = {combination.main_case.field_name: combination.main_case.field_mode}
+    all_fields = list(combination.init_lib.keys())
+
+    if combination.main_case.requirements is not None:
+        case_requirements = form_requirements(combination.init_lib, combination.main_case.requirements)
+        if check_join(combination.test_seed, case_requirements):
+            for name, mode in case_requirements.items():
+                if combination.main_case.field_name != name and name in all_fields:
+                    combination.other_cases.update({name: combination.init_lib[name][mode]})
+                    combination.test_seed.update({name: mode})
+                    del all_fields[all_fields.index(name)]
+
+
+    del all_fields[all_fields.index(combination.main_case.field_name)]
+
+    while len(all_fields) > 0:
+        field_name = random.choice(all_fields)
+        cases = combination.init_lib[field_name]
+        field_modes = [case.field_mode for case in cases.values() if case.type_of_case is None]
+        field_mode = None
+        for _ in range(len(field_modes)):
+            example_mode = random.choice(field_modes)
+            if cases[example_mode].requirements is None:
+                field_mode = example_mode
+                break
+            case_requirements = form_requirements(combination.init_lib, cases[example_mode].requirements)
+            if check_join(combination.test_seed, case_requirements):
+                for name, mode in case_requirements.items():
+                    if combination.main_case.field_name != name and name in all_fields:
+                        combination.other_cases.update({name: combination.init_lib[name][mode]})
+                        combination.test_seed.update({name: mode})
+                        del all_fields[all_fields.index(name)]
+                field_mode = example_mode
+                break
+            del field_modes[field_modes.index(example_mode)]
+
+        assert field_mode is not None, "Не удалось подобрать кейс!"
+
+        combination.other_cases.update({field_name: cases[field_mode]})
+        combination.test_seed.update({field_name: field_mode})
+        del all_fields[all_fields.index(field_name)]
+
+    return True
diff --git a/combidata/processes/form.py b/combidata/processes/form.py
@@ -0,0 +1,17 @@
+def find_replace_in_dict(template, generated_data, keys):
+    result = {}
+    for key, value in template.items():
+        if isinstance(value, dict):
+            result.update({key: find_replace_in_dict(value, generated_data, keys)})
+        elif isinstance(value, str) and value in keys:
+            if value in generated_data.keys():
+                result.update({key: generated_data[value]})
+        else:
+            result.update({key: value})
+
+    return result
+
+def form(combination):
+    combination.formed_data = find_replace_in_dict(combination.template, combination.generated_data, combination.init_lib.keys())
+
+    return True
diff --git a/combidata/processes/genetate.py b/combidata/processes/genetate.py
@@ -0,0 +1,45 @@
+import random
+
+from combidata.classes.combination import Combination
+
+
+def generate_value(all_fields, case, combination: Combination):
+    generated_data = combination.generated_data
+    test_seed = combination.test_seed
+    cases = combination.other_cases
+
+    if case.options is None:
+        if case.gen_func is None:
+            item_value = case.value
+        else:
+            item_value = case.gen_func(case.value)
+    else:
+        options = {}
+        for key, field in case.options.items():
+            if isinstance(field, str) and field in test_seed.keys():
+                if field in generated_data.keys():
+                    options.update({key: generated_data[field]})
+                else:
+                    generate_value(all_fields, cases[field], combination)
+                    options.update({key: generated_data[field]})
+            elif isinstance(field, str) and field == "combination":
+                options.update({key: combination})
+            else:
+                options.update({key: field})
+        item_value = case.gen_func(case.value, **options)
+
+    if case.is_presented:
+        generated_data.update({case.field_name: item_value})
+    if case in all_fields:
+        del all_fields[all_fields.index(case)]
+
+def generate(combination: Combination):
+    all_fields = list(combination.other_cases.values())
+
+    generate_value(all_fields, combination.main_case, combination)
+
+    while len(all_fields) > 0:
+        case = random.choice(all_fields)
+        generate_value(all_fields, case, combination)
+
+    return True
diff --git a/pyproject.toml b/pyproject.toml
@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.2", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+readme = "README.md"
+name = "combidate"
+description = "Package for random data generation, combination and data prepare for tests"
+keywords = [
+    "QA",
+    "SET",
+    "random data generation",
+    "testing API",
+    "testing",
+    "autotesting"
+]
+urls = {Homepage = "https://github.com/Warrfie/combidate"}
+authors = [{name = "MaximKuklikov(Warrfie)", email = "warrfie@gmail.com"}]
+requires-python = ">=3.10"
+version="0.1.1"
diff --git a/setup.py b/setup.py
diff --git a/tests/test_generator.py b/tests/test_generator.py
