First Commit

Author: abhijo89-uc

pyresttest/benchmarks.py

@@ -1,21 +1,12 @@
 import math
 import json
 import pycurl
-import sys
 
-from . import tests
-from .tests import Test
-from . import parsing
-from .parsing import *
+from constants import DEFAULT_TIMEOUT
+from tests import Test, coerce_to_string
+from parsing import *
 
-# Python 2/3 switches
-if sys.version_info[0] > 2:
-    from past.builtins import basestring
 
-# Python 3 compatibility shims
-from . import six
-from .six import binary_type
-from .six import text_type
 
 """
 Encapsulates logic related to benchmarking
@@ -109,10 +100,7 @@ def std_deviation(array):
 
     average = AGGREGATES['mean_arithmetic'](array)
     variance = map(lambda x: (x - average)**2, array)
-    try:
-        len(variance)
-    except TypeError:  # Python 3.3 workaround until can use the statistics module from 3.4
-        variance = list(variance)
+    variance = list(variance)
     stdev = AGGREGATES['mean_arithmetic'](variance)
     return math.sqrt(stdev)
 
@@ -193,13 +181,9 @@ def realize_partial(self, context=None):
         # Enhanceme - once extract is done, check if variables already bound,
         # in that case template out
         return self
-    else:
-        copyout = copy.cop
-
-    pass
 
 
-def configure_curl(self, timeout=tests.DEFAULT_TIMEOUT, context=None, curl_handle=None):
+def configure_curl(self, timeout=DEFAULT_TIMEOUT, context=None, curl_handle=None):
     curl = super().configure_curl(self, timeout=timeout,
                                   context=context, curl_handle=curl_handle)
     # Simulate results from different users hitting server
@@ -229,42 +213,42 @@ def parse_benchmark(base_url, node):
             else:
                 raise ValueError('Invalid benchmark output format: ' + format)
         elif key == u'output_file':
-            if not isinstance(value, basestring):
+            if not isinstance(value, str):
                 raise ValueError("Invalid output file format")
             benchmark.output_file = value
         elif key == u'metrics':
-            if isinstance(value, basestring):
+            if isinstance(value, str):
                 # Single value
-                benchmark.add_metric(tests.coerce_to_string(value))
+                benchmark.add_metric(coerce_to_string(value))
             # FIXME refactor the parsing of metrics here, lots of duplicated logic
             elif isinstance(value, list) or isinstance(value, set):
                 # List of single values or list of {metric:aggregate, ...}
                 for metric in value:
                     if isinstance(metric, dict):
                         for metricname, aggregate in metric.items():
-                            if not isinstance(metricname, basestring):
+                            if not isinstance(metricname, str):
                                 raise TypeError(
                                     "Invalid metric input: non-string metric name")
-                            if not isinstance(aggregate, basestring):
+                            if not isinstance(aggregate, str):
                                 raise TypeError(
                                     "Invalid aggregate input: non-string aggregate name")
                             # TODO unicode-safe this
-                            benchmark.add_metric(tests.coerce_to_string(metricname),
-                                tests.coerce_to_string(aggregate))
+                            benchmark.add_metric(coerce_to_string(metricname),
+                                coerce_to_string(aggregate))
 
-                    elif isinstance(metric, basestring):
-                        benchmark.add_metric(tests.coerce_to_string(metric))
+                    elif isinstance(metric, str):
+                        benchmark.add_metric(coerce_to_string(metric))
             elif isinstance(value, dict):
                 # Dictionary of metric-aggregate pairs
                 for metricname, aggregate in value.items():
-                    if not isinstance(metricname, basestring):
+                    if not isinstance(metricname, str):
                         raise TypeError(
                             "Invalid metric input: non-string metric name")
-                    if not isinstance(aggregate, basestring):
+                    if not isinstance(aggregate, str):
                         raise TypeError(
                             "Invalid aggregate input: non-string aggregate name")
-                    benchmark.add_metric(tests.coerce_to_string(metricname),
-                        tests.coerce_to_string(aggregate))
+                    benchmark.add_metric(coerce_to_string(metricname),
+                        coerce_to_string(aggregate))
             else:
                 raise TypeError(
                     "Invalid benchmark metric datatype: " + str(value))

pyresttest/constants.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+DEFAULT_TIMEOUT = 10
+
+
+@dataclass(frozen=True)
+class YamlKeyWords:
+    IMPORT = 'import'
+    TEST = 'test'
+    URL = 'url'
+    BENCHMARK = 'benchmark'
+    CONFIG = 'config'
+    # Configurations
+    TIMEOUT = 'timeout'
+    LOG_BODY = 'print_bodies'
+    VARS = 'variable_binds'
+    GENERATORS = 'generators'
+    RETRIES = 'retries'
+

pyresttest/contenthandling.py

@@ -1,13 +1,5 @@
 import os
-import sys
-
-from . import parsing
-from .parsing import *
-
-# Python 2/3 switches
-PYTHON_MAJOR_VERSION = sys.version_info[0]
-if PYTHON_MAJOR_VERSION > 2:
-    from past.builtins import basestring
+from pyresttest.parsing import *
 
 
 """
@@ -72,7 +64,7 @@ def create_noread_version(self):
 
     def setup(self, input, is_file=False, is_template_path=False, is_template_content=False):
         """ Self explanatory, input is inline content or file path. """
-        if not isinstance(input, basestring):
+        if not isinstance(input, str):
             raise TypeError("Input is not a string")
         if is_file:
             input = os.path.abspath(input)
@@ -103,7 +95,7 @@ def parse_content(node):
 
         while (node and not is_done):  # Dive through the configuration tree
             # Finally we've found the value!
-            if isinstance(node, basestring):
+            if isinstance(node, str):
                 output.content = node
                 output.setup(node, is_file=is_file, is_template_path=is_template_path,
                              is_template_content=is_template_content)
@@ -118,7 +110,7 @@ def parse_content(node):
             flat = lowercase_keys(flatten_dictionaries(node))
             for key, value in flat.items():
                 if key == u'template':
-                    if isinstance(value, basestring):
+                    if isinstance(value, str):
                         if is_file:
                             value = os.path.abspath(value)
                         output.content = value
@@ -134,7 +126,7 @@ def parse_content(node):
                         break
 
                 elif key == 'file':
-                    if isinstance(value, basestring):
+                    if isinstance(value, str):
                         output.content = os.path.abspath(value)
                         output.is_file = True
                         output.is_template_content = is_template_content

pyresttest/ext/extractor_jmespath.py

@@ -1,10 +1,7 @@
-import traceback
 import json
 import sys
-PYTHON_MAJOR_VERSION = sys.version_info[0]
 
-import yaml
-import ast
+
 import jmespath
 
 try:  # First try to load pyresttest from global namespace
@@ -18,6 +15,7 @@
     from .. import parsing
     from .. import contenthandling
 
+
 class JMESPathExtractor(validators.AbstractExtractor):
     """ Extractor that uses JMESPath syntax
         See http://jmespath.org/specification.html for details
@@ -26,13 +24,11 @@ class JMESPathExtractor(validators.AbstractExtractor):
     is_body_extractor = True
 
     def extract_internal(self, query=None, args=None, body=None, headers=None):
-        mybody = body
-        if PYTHON_MAJOR_VERSION > 2:
-            if isinstance(mybody, bytes):
-                mybody = str(mybody, 'utf-8')
+        if isinstance(body, bytes):
+            body = str(body, 'utf-8')
 
         try:
-            res = jmespath.search(query, json.loads(mybody)) # Better way
+            res = jmespath.search(query, json.loads(body))
             return res
         except Exception as e:
             raise ValueError("Invalid query: " + query + " : " + str(e))
@@ -41,6 +37,6 @@ def extract_internal(self, query=None, args=None, body=None, headers=None):
     def parse(cls, config):
         base = JMESPathExtractor()
         return cls.configure_base(config, base)
-        return base
+
 
 EXTRACTORS = {'jmespath': JMESPathExtractor.parse}

pyresttest/generators.py

@@ -2,15 +2,7 @@
 import string
 import os
 import logging
-import sys
-
-from . import parsing
-from .parsing import flatten_dictionaries, lowercase_keys, safe_to_bool
-
-# Python 3 compatibility
-if sys.version_info[0] > 2:
-    from builtins import range as xrange
-    from past.builtins import basestring
+from pyresttest.parsing import flatten_dictionaries, lowercase_keys
 
 """ Collection of generators to be used in templating for test data
 
@@ -29,8 +21,8 @@
     'ascii_uppercase': string.ascii_uppercase,
     'digits': string.digits,
     'hexdigits': string.hexdigits,
-    'hex_lower':  string.digits + 'abcdef',
-    'hex_upper':  string.digits + 'ABCDEF',
+    'hex_lower': string.digits + 'abcdef',
+    'hex_upper': string.digits + 'ABCDEF',
     'letters': string.ascii_letters,
     'lowercase': string.ascii_lowercase,
     'octdigits': string.octdigits,
@@ -49,12 +41,14 @@
 def factory_generate_ids(starting_id=1, increment=1):
     """ Return function generator for ids starting at starting_id
         Note: needs to be called with () to make generator """
+
     def generate_started_ids():
         val = starting_id
         local_increment = increment
-        while(True):
+        while (True):
             yield val
             val += local_increment
+
     return generate_started_ids
 
 
@@ -76,14 +70,15 @@ def factory_generate_text(legal_characters=string.ascii_letters, min_length=8, m
 
         For hex digits, combine with string.hexstring, etc
         """
+
     def generate_text():
         local_min_len = min_length
         local_max_len = max_length
         rand = random.Random()
-        while(True):
+        while True:
             length = random.randint(local_min_len, local_max_len)
             array = [random.choice(legal_characters)
-                     for x in xrange(0, length)]
+                     for x in range(0, length)]
             yield ''.join(array)
 
     return generate_text
@@ -95,10 +90,11 @@ def factory_fixed_sequence(values):
     def seq_generator():
         my_list = list(values)
         i = 0
-        while(True):
+        while (True):
             yield my_list[i]
             if i == len(my_list):
                 i = 0
+
     return seq_generator
 
 
@@ -118,8 +114,9 @@ def factory_choice_generator(values):
     def choice_generator():
         my_list = list(values)
         rand = random.Random()
-        while(True):
+        while (True):
             yield random.choice(my_list)
+
     return choice_generator
 
 
@@ -138,7 +135,7 @@ def factory_env_variable(env_variable):
 
     def return_variable():
         variable_name = env_variable
-        while(True):
+        while (True):
             yield os.environ.get(variable_name)
 
     return return_variable
@@ -149,11 +146,12 @@ def factory_env_string(env_string):
 
     def return_variable():
         my_input = env_string
-        while(True):
+        while (True):
             yield os.path.expandvars(my_input)
 
     return return_variable
 
+
 """ Implements the parsing logic for YAML, and acts as single point for reading configuration """
 
 
@@ -190,13 +188,13 @@ def parse_random_text_generator(configuration):
 
 
 # List of valid generator types
-GENERATOR_TYPES = set(['env_variable',
-                       'env_string',
-                       'number_sequence',
-                       'random_int',
-                       'random_text',
-                       'fixed_sequence'
-                       ])
+GENERATOR_TYPES = {'env_variable',
+                   'env_string',
+                   'number_sequence',
+                   'random_int',
+                   'random_text',
+                   'fixed_sequence'
+                   }
 
 GENERATOR_PARSING = {'fixed_sequence': parse_fixed_sequence}
 
@@ -206,7 +204,7 @@ def register_generator(typename, parse_function):
         typename is the new generator type name (must not already exist)
         parse_function will parse a configuration object (dict)
     """
-    if not isinstance(typename, basestring):
+    if not isinstance(typename, str):
         raise TypeError(
             'Generator type name {0} is invalid, must be a string'.format(typename))
     if typename in GENERATOR_TYPES:
@@ -215,6 +213,7 @@ def register_generator(typename, parse_function):
     GENERATOR_TYPES.add(typename)
     GENERATOR_PARSING[typename] = parse_function
 
+
 # Try registering a new generator
 register_generator('choice', parse_choice_generator)