File size: 5,456 Bytes
6c50d1f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | import random
import string
from typing import Dict, List
from specification_parser import ParameterProperties, ItemProperties
class RandomizedSelector:
def __init__(self, parameters: dict, request_body: dict):
self.generate_accurate = random.randint(1, 10) <= 5
self.dropout_ratio = 0.05
self.randomized_weight = 0.8
self.max_arr_length = 2**16
self.randomization_max_val = 100
self.generators = {"integer": self.randomize_integer,
"float": self.randomize_float,
"number": self.randomize_float,
"boolean": self.randomize_boolean,
"string" : self.randomize_string,
"array" : self.randomize_array,
"object" : self.randomize_object,
"null": self.randomize_null}
self.parameters: Dict[str, ParameterProperties] = parameters
self.request_body: Dict[str, ItemProperties] = request_body
def use_primitive_generator(self, item_properties: ItemProperties):
if item_properties is None:
return None
generator = self.generators.get(item_properties.type)
if self.should_generate_accurately():
return generator() if generator else None
else:
return random.choice(list(self.generators.values()))()
def generate_randomized_object(self, item_properties: ItemProperties) -> Dict:
if not item_properties.properties:
return self.generators["object"]()
randomized_object = {}
for item_name, item_values in item_properties.properties.items():
if self.generate_accurate or not self.is_dropped():
randomized_object[item_name] = self.randomize_item(item_values)
return randomized_object
def generate_randomized_array(self, item_properties: ItemProperties) -> List:
if not item_properties.items:
return self.generators["array"]()
array_length = self.randomized_array_length()
return [self.randomize_item(item_properties.items) for _ in range(array_length)]
def randomize_item(self, item_properties: ItemProperties):
if item_properties is None:
return None
if item_properties.type in ["object", "array"] and self.should_generate_accurately():
composite_method = self.generate_randomized_object if item_properties.type == "object" else self.generate_randomized_array
return composite_method(item_properties)
else:
return self.use_primitive_generator(item_properties)
def randomize_parameters(self) -> Dict[str, any]:
query_parameters = {}
for parameter_name, parameter_properties in self.parameters.items():
if self.is_dropped():
continue
randomized_value = self.randomize_item(parameter_properties.schema)
query_parameters[parameter_name] = randomized_value
return query_parameters
def randomize_request_body(self):
if self.is_dropped():
return []
if isinstance(self.request_body, list):
return [self.randomize_item(item) for item in self.request_body]
elif isinstance(self.request_body, ItemProperties):
return self.randomize_item(self.request_body)
else:
error_msg = "Error parsing request body"
#print(error_msg)
raise ValueError(error_msg)
def should_generate_accurately(self):
return self.generate_accurate or not self.randomize_type()
def randomize_type(self):
return random.randint(1, self.randomization_max_val) < self.randomized_weight * self.randomization_max_val # return accurate
def is_dropped(self):
return random.randint(0, self.randomization_max_val) < self.dropout_ratio * self.randomization_max_val if not self.generate_accurate else False
def randomize_boolean(self):
return random.choice([True, False])
def randomize_null(self):
return None
def randomize_integer(self):
if random.randint(1, 100) <= 70:
return random.randint(0, 1000)
else:
return random.randint(-(2 ** 10), (2 ** 10))
def randomize_float(self):
if random.randint(1, 100) <= 70:
return random.uniform(0, 1000)
else:
return random.uniform(-(2 ** 10), (2 ** 10))
def randomize_string(self):
if random.randint(1, 100) <= 90:
length = random.randint(4, 16)
else:
length = random.randint(1, 100)
return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
def randomize_array(self):
if random.randint(1, 100) <= 90:
length = random.randint(4, 10)
else:
length = random.randint(0, 50)
return [random.randint(-9999, 9999) for _ in range(length)]
def randomize_object(self):
if random.randint(1, 100) <= 90:
length = random.randint(4, 10)
else:
length = random.randint(0, 50)
return {random.choice(string.ascii_letters): random.randint(-9999, 9999) for _ in range(length)}
def randomized_array_length(self):
if random.randint(0,100) <= 90:
return random.randint(4, 10)
else:
return random.randint(0, 50)
|