tools/morest/fuzzer/runtime_dictionary.py

import collections
import difflib
import json
import re

import numpy as np
from model.method import Method
from .schema_validator import validate
from .util import resolve_json_value
from .relation_reasoner import RelationReasoner


class ParameterType:
    STRING = "STRING"
    BOOLEAN = "BOOLEAN"
    NUMBER = "NUMBER"
    NONE = "NONE"
    OBJECT = "OBJECT"
    LIST = "LIST"


class RuntimeDictionary:
    def __init__(self):
        self.api_response_parameter = {}
        self.signature_to_value = {}
        self.signature_splitter = '%APITestGen%'
        self.array_pattern = re.compile('\[[0-9]+\]')
        self.path_to_signature_threshold = {}
        self.path_to_signature_suffix = {}
        self.path_to_type = {}
        self.signature_value_match_dict = {}
        self.debug_method = "getLunDetails"
        self.relation_reasoner = RelationReasoner()

    def remove_array_notation(self, key=""):
        notations = self.array_pattern.findall(key)
        for notation in notations:
            key = key.replace(notation, "[0]")
        return key

    def has_candidate_in_dictionary(self, path: str):
        return self.path_to_signature_threshold.__contains__(path) or self.path_to_signature_suffix.__contains__(path)

    def calculate_path_threshold(self, path: str):
        sequence_matcher = difflib.SequenceMatcher()
        for signature in self.signature_to_value.keys():
            api, response_value_path = signature.split(self.signature_splitter)
            # ratio
            sequence_matcher.set_seqs(response_value_path, path)
            signature_threshold_list = self.path_to_signature_threshold.get(path, [])
            signature_threshold_list.append((signature, sequence_matcher.ratio()))
            self.path_to_signature_threshold[path] = signature_threshold_list

            # suffix match
            ignored_response_value_path = str(response_value_path).lower().split('.')[-1]
            ignored_case_path = str(path).lower().split('.')[-1]
            if ignored_response_value_path.endswith(ignored_case_path) or ignored_case_path.endswith(
                    ignored_response_value_path):
                suffix_set = self.path_to_signature_suffix.get(path, set())
                suffix_set.add(signature)
                self.path_to_signature_suffix[path] = suffix_set

    def update_signature_to_path_threshold(self, signature):
        api, response_value_path = signature.split(self.signature_splitter)
        sequence_matcher = difflib.SequenceMatcher()
        for path in self.path_to_signature_threshold.keys():
            sequence_matcher.set_seqs(path, response_value_path)
            self.path_to_signature_threshold[path].append((signature, sequence_matcher.ratio()))
            ignored_case_response_path = str(response_value_path).lower().split('.')[-1]
            ignored_case_path = str(path).lower().split('.')[-1]
            # suffix match
            if ignored_case_path.endswith(ignored_case_response_path) or ignored_case_response_path.endswith(
                    ignored_case_path):
                suffix_set = self.path_to_signature_suffix.get(path, set())
                suffix_set.add(signature)
                self.path_to_signature_suffix[path] = suffix_set

    def should_use_dictionary(self, path: str):
        # we leave the opportunity for random
        if np.random.random() < 0.1:
            return False
        if self.path_to_signature_suffix.__contains__(path) or self.path_to_signature_threshold.__contains__(path):
            return True
        return False

    def generate_value_from_dictionary(self, path: str, method: Method, schema: dict):
        feed_from_methods = [feed_method.method_name for feed_method in method.feed_from_method]
        valid_parameters = []
        feed_from_valid_parameters = []
        odg_reference_signature = []
        if "existing_lun_ids[0]" in path:
            a = 2
        if "deleteLunGroup" == method.method_name:
            c = 3
        for method_name in method.required_feed_parameter:
            dependency_dict = method.required_feed_parameter[method_name]
            for reference in dependency_dict:
                reference_attribute_list = method.get_single_request_parameter_by_property_name(reference)
                feed_parameter_list = method.get_feed_from_method_response_parameter_by_property_and_method_name(
                    method_name, dependency_dict[reference])
                if path in reference_attribute_list and len(feed_parameter_list) > 0:
                    for feed_parameter in feed_parameter_list:
                        signature = f'{method_name}{self.signature_splitter}{feed_parameter}'
                        if signature in self.signature_to_value:
                            odg_reference_signature.append(signature)
        if len(odg_reference_signature) > 0 and np.random.random() > 0.05:
            valid_references = []
            for signature in odg_reference_signature:
                sample = self.signature_to_value[signature][
                    np.random.randint(0, len(self.signature_to_value[signature]))]
                try:
                    validate(sample, schema)
                    valid_references.append(signature)
                except:
                    pass
            if len(valid_references) > 0:
                signature = valid_references[np.random.randint(0, len(valid_references))]
                val = self.signature_to_value[signature][np.random.randint(0, len(self.signature_to_value[signature]))]
                return val
        for parameter_signature in self.signature_to_value:
            sample_value = self.signature_to_value[parameter_signature][0]
            try:
                validate(sample_value, schema)
                # if is_id and not ('id' in parameter_signature):
                #     continue

                # should_skip = True
                # for method_name in feed_from_methods:
                #     if method_name in parameter_signature:
                #         should_skip = True
                #         break
                # if should_skip:
                #     continue
                valid_parameters.append(parameter_signature)
                for feed_from_method_name in feed_from_methods:
                    if feed_from_method_name in parameter_signature:
                        feed_from_valid_parameters.append(parameter_signature)
                        break
            except Exception as ex:
                pass
        if len(valid_parameters) == 0:
            return None
        suffix_parameters = self.path_to_signature_suffix.get(path, set())
        intersection_suffix_feed_from_parameters = set.intersection(suffix_parameters, set(feed_from_valid_parameters))
        valid_suffix_parameters = set.intersection(suffix_parameters, feed_from_valid_parameters)
        # we leave the opportunity for other cases
        if len(intersection_suffix_feed_from_parameters) > 0 and np.random.random() < 0.5:
            signature = np.random.choice(list(intersection_suffix_feed_from_parameters))
            value = self.signature_to_value[signature][np.random.choice(len(self.signature_to_value[signature]))]
            return value
        # suffix parameters
        if len(valid_suffix_parameters) > 0 and np.random.random() < 0.5:
            signature = np.random.choice(list(valid_suffix_parameters))
            value = self.signature_to_value[signature][np.random.choice(len(self.signature_to_value[signature]))]
            return value

        # valid parameters
        if len(valid_parameters) > 0:
            signature = np.random.choice(list(valid_parameters))
            value = self.signature_to_value[signature][np.random.choice(len(self.signature_to_value[signature]))]
            return value

        # from threshold dictionary
        weights = []
        candidates = []
        for item in self.path_to_signature_threshold[path]:
            cand, w = item
            if not (cand in valid_parameters):
                continue
            weights.append(w + 0.00001)
            candidates.append(cand)
        weights = weights / np.sum(weights)
        signature = np.random.choice(candidates, 1, p=weights)[-1]
        value = self.signature_to_value[signature][np.random.choice(len(self.signature_to_value[signature]))]
        # print('in threshold', path, signature, value)
        return value

    def inject_signature(self, api_name, attribute_path, value):
        signature = api_name + self.signature_splitter + attribute_path
        fifo = self.signature_to_value.get(signature, collections.deque(maxlen=20))
        self.signature_to_value[signature] = fifo
        fifo.append(value)

    def infer_response_value_type(self, val):
        if isinstance(val, bool):
            return ParameterType.BOOLEAN
        elif isinstance(val, dict):
            return ParameterType.OBJECT
        elif isinstance(val, list):
            return ParameterType.LIST
        elif isinstance(val, float) or isinstance(val, int):
            return ParameterType.NUMBER
        elif isinstance(val, str):
            return ParameterType.STRING
        elif val is None:
            return ParameterType.NONE
        raise Exception('unknown value type {}'.format(val))

    def parse(self, method, response={}):
        has_new_attribute = False
        # we do not consider abnormal responses
        if response["statusCode"] > 299:
            return has_new_attribute

        content = response["content"]
        api_name = method.method_name

        # we do not handle empty content
        if content is None or len(content) == 0:
            return has_new_attribute

        try:
            content = json.loads(content)
            data = {}
            resolve_json_value("", content, data)
            # self.relation_reasoner.update_or_create_db_by_data(request_value, variable_replace_map, method, data)
            for key in data.keys():
                value = data[key]
                nominal_key = self.remove_array_notation(key)
                signature = f'{api_name}{self.signature_splitter}{nominal_key}'
                signature_to_value = self.signature_to_value.get(signature, collections.deque(maxlen=20))
                if not self.signature_to_value.__contains__(signature):
                    self.signature_to_value[signature] = signature_to_value
                    self.update_signature_to_path_threshold(signature)
                    has_new_attribute = True
                    print(signature, value)
                # record value type
                # value_type_set = self.path_to_type.get(signature, set())
                # value_type_set.add(value_type)
                # self.path_to_type[signature] = value_type_set
                # if value_type in [ParameterType.STRING]:
                #     for sig in self.path_to_type:
                #         if api_name in sig or not (value_type in self.path_to_type[sig]):
                #             continue
                #         compare_sig_set = self.signature_value_match_dict.get(sig, set())
                #         current_sig_set = self.signature_value_match_dict.get(signature, set())
                #         if sig in current_sig_set:
                #             continue
                #         for val in self.signature_to_value[sig]:
                #             if val == value:
                #                 compare_sig_set.add(signature)
                #                 current_sig_set.add(sig)
                #                 break
                #         self.signature_value_match_dict[sig] = compare_sig_set
                #         self.signature_value_match_dict[signature] = current_sig_set
                if not (value in signature_to_value):
                    signature_to_value.append(value)
            return has_new_attribute
        except Exception as e:
            print("exception", content)
            print(e)
            # raise e
            return has_new_attribute