Merge pull request #26 from abhijo89-to/v2

Removed few Unnecessary else after return

Author: crazi-coder

.coveragerc

@@ -1,6 +1,8 @@
 # .coveragerc to control coverage.py
 [run]
 branch = True
+omit = py3resttest/runner.py
+
 command_line = --source py3resttest -m pytest tests/test_*.py
 [paths]
 source =

coverage.sh

@@ -2,3 +2,4 @@
 # pip install coverage
 coverage run --source py3resttest -m pytest tests/test_*.py
 coverage html
+coverage report

py3resttest/binding.py

@@ -10,7 +10,7 @@
 
 class Context(object):
     """ Manages binding of variables & generators, with both variable name and generator name being strings """
-
+    # variables = {}
     def __init__(self):
         self.variables = {}  # Maps variable name to current value
         self.generators = {}  # Maps generator name to generator function
@@ -21,6 +21,7 @@ def bind_variable(self, variable_name, variable_value):
             This allows for passing in variables in testing """
         str_name = str(variable_name)
         prev = self.variables.get(str_name)
+
         if prev != variable_value:
             self.variables[str(variable_name)] = variable_value
             self.mod_count = self.mod_count + 1

py3resttest/generators.py

@@ -232,16 +232,8 @@ def parse_generator(configuration):
     elif gen_type == 'env_string':
         return factory_env_string(configuration['string'])()
     elif gen_type == 'number_sequence':
-        start = configuration.get('start')
-        increment = configuration.get('increment')
-        if not start:
-            start = 1
-        else:
-            start = int(start)
-        if not increment:
-            increment = 1
-        else:
-            increment = int(increment)
+        start = int(configuration.get('start', 1))
+        increment = int(configuration.get('increment', 1))
         return factory_generate_ids(start, increment)()
     elif gen_type == 'random_int':
         return generator_random_int32()

py3resttest/testcase.py

@@ -86,7 +86,7 @@ def __init__(self):
     def parse(self, base_url: str, testcase_list: List, test_file=None, working_directory=None, variable_dict=None):
 
         if working_directory is None:
-            working_directory = os.path.abspath(os.getcwd())
+            working_directory = Path(os.path.abspath(os.getcwd()))
         else:
             working_directory = Path(working_directory)
         if variable_dict is None:
@@ -108,27 +108,24 @@ def parse(self, base_url: str, testcase_list: List, test_file=None, working_dire
                         raise ValueError("include should be list not %s" % type(sub_testcase_node))
                     for testcase_file_path in sub_testcase_node:
                         testcase_file_path = testcase_file_path.replace('.', '/')
-                        testcase_file = working_directory.joinpath("%s.yaml" % testcase_file_path).resolve()
+                        testcase_file = str(working_directory.joinpath("%s.yaml" % testcase_file_path).resolve())
                         if testcase_file not in self.__testcase_file:
                             self.__testcase_file.add(testcase_file)
                             import_testcase_list = read_testcase_file(testcase_file)
                             with ChangeDir(working_directory):
                                 self.parse(base_url, import_testcase_list, variable_dict=variable_dict)
                 elif key == YamlKeyWords.IMPORT:
                     if sub_testcase_node not in self.__testcase_file:
-                        testcase_file_path = os.path.dirname(os.path.realpath(sub_testcase_node))
+                        testcase_file_path = sub_testcase_node
                         logger.debug("Importing testcase from %s", testcase_file_path)
+                        testcase_file_path = str(working_directory.joinpath("%s" % testcase_file_path).resolve())
                         self.__testcase_file.add(sub_testcase_node)
                         import_testcase_list = read_testcase_file(testcase_file_path)
-                        with ChangeDir(testcase_file_path):
+                        with ChangeDir(working_directory):
                             self.parse(base_url, import_testcase_list, variable_dict=variable_dict)
                 elif key == YamlKeyWords.URL:
                     __group_name = TestCaseGroup.DEFAULT_GROUP
-                    try:
-                        group_object = TestSet.test_group_list_dict[__group_name]
-                    except KeyError:
-                        group_object = TestCaseGroup(TestCaseGroup.DEFAULT_GROUP, config=testcase_config_object)
-                        TestSet.test_group_list_dict[__group_name] = group_object
+                    group_object = TestSet.__create_test(__group_name, testcase_config_object)
                     testcase_object = TestCase(
                         base_url=base_url, extract_binds=group_object.extract_binds,
                         variable_binds=group_object.variable_binds, context=group_object.context,
@@ -153,11 +150,7 @@ def parse_test(base_url, sub_testcase_node, testcase_config_object):
             if __group_name is None:
                 __group_name = node_dict.get(TestCaseKeywords.group)
         __group_name = __group_name if __group_name else TestCaseGroup.DEFAULT_GROUP
-        try:
-            group_object = TestSet.test_group_list_dict[__group_name]
-        except KeyError:
-            group_object = TestCaseGroup(TestCaseGroup.DEFAULT_GROUP, config=testcase_config_object)
-            TestSet.test_group_list_dict[__group_name] = group_object
+        group_object = TestSet.__create_test(__group_name, testcase_config_object)
         testcase_object = TestCase(
             base_url=base_url, extract_binds=group_object.extract_binds,
             variable_binds=group_object.variable_binds, context=group_object.context,
@@ -166,6 +159,15 @@ def parse_test(base_url, sub_testcase_node, testcase_config_object):
         testcase_object.parse(sub_testcase_node)
         group_object.testcase_list = testcase_object
 
+    @staticmethod
+    def __create_test(__group_name, testcase_config_object):
+        try:
+            group_object = TestSet.test_group_list_dict[__group_name]
+        except KeyError:
+            group_object = TestCaseGroup(TestCaseGroup.DEFAULT_GROUP, config=testcase_config_object)
+            TestSet.test_group_list_dict[__group_name] = group_object
+        return group_object
+
 
 class TestCaseGroup:
     DEFAULT_GROUP = "NO GROUP"
@@ -367,6 +369,8 @@ def url(self):
             val = self.__url
         if not self.__abs_url:
             val = urljoin(self.__base_url, val)
+        if isinstance(val, dict):
+            logger.warning("URL is not applied template values.")
         return val
 
     @url.setter
@@ -489,8 +493,10 @@ def body(self, value):
         if value:
             if isinstance(value, bytes):
                 self.__body = ContentHandler.parse_content(value.decode())
-            else:
+            elif isinstance(value, str):
                 self.__body = ContentHandler.parse_content(value)
+            else:
+                self.__body = value
         else:
             self.__body = value
 
@@ -499,7 +505,7 @@ def failures(self):
         return self.__failure_list
 
     def realize_template(self, variable_name, context):
-        if context is None or self.templates is None or variable_name not in self.templates:
+        if (context or self.templates) is None or (variable_name not in self.templates):
             return None
         if not context.get_values():
             return None

py3resttest/validators.py

@@ -60,7 +60,6 @@ def __str__(self):
     @abstractmethod
     def extract_internal(self, query=None, body=None, headers=None, args=None):
         """ Do extraction, query should be pre-templated """
-        pass
 
     def extract(self, body=None, headers=None, context=None):
         """ Extract data """
@@ -165,8 +164,8 @@ def extract_internal(self, query=None, args=None, body=None, headers=None):
         # Fix #19
         if len(extracted) == 1:
             return extracted[0]
-        else:
-            return extracted
+
+        return extracted
 
     @classmethod
     def parse(cls, config):
@@ -198,9 +197,8 @@ def _get_extractor(config_dict):
     for key, value in config_dict.items():
         if key in EXTRACTORS:
             return parse_extractor(key, value)
-    else:  # No valid extractor
-        raise Exception(
-            'No valid extractor name to use in input: {0}'.format(config_dict))
+    raise Exception(
+        'No valid extractor name to use in input: {0}'.format(config_dict))
 
 
 class AbstractValidator(metaclass=ABCMeta):
@@ -218,7 +216,6 @@ def __init__(self):
     @abstractmethod
     def validate(self, body=None, headers=None, context=None):
         """ Run the validation function, return true or a Failure """
-        pass
 
 
 class ComparatorValidator(AbstractValidator):
@@ -322,7 +319,7 @@ def parse(config):
         # Expected value can be another extractor query, or a single value, or
         # a templated value
 
-        if isinstance(expected, str) or isinstance(expected, (int, float, complex)):
+        if isinstance(expected, (str, int, float, complex)):
             output.expected = expected
         elif isinstance(expected, dict):
 
@@ -457,13 +454,13 @@ def register_extractor(extractor_name, parse_function):
     if extractor_name.lower() == 'comparator':
         raise ValueError(
             "Cannot register extractors called 'comparator', that is a reserved name")
-    elif extractor_name.lower() == 'test':
+    if extractor_name.lower() == 'test':
         raise ValueError(
             "Cannot register extractors called 'test', that is a reserved name")
-    elif extractor_name.lower() == 'expected':
+    if extractor_name.lower() == 'expected':
         raise ValueError(
             "Cannot register extractors called 'expected', that is a reserved name")
-    elif extractor_name in EXTRACTORS:
+    if extractor_name in EXTRACTORS:
         raise ValueError(
             "Cannot register an extractor name that already exists: {0}".format(extractor_name))
     EXTRACTORS[extractor_name] = parse_function
@@ -473,7 +470,7 @@ def register_test(test_name, test_function):
     """ Register a new one-argument test function """
     if not isinstance(test_name, str):
         raise TypeError("Cannot register a non-string test name")
-    elif test_name in VALIDATOR_TESTS:
+    if test_name in VALIDATOR_TESTS:
         raise ValueError(
             "Cannot register a test name that already exists: {0}".format(test_name))
     VALIDATOR_TESTS[test_name] = test_function

tests/content-test-include.yaml

@@ -0,0 +1,2 @@
+- include:
+    - tests.content-test

tests/test_binding.py

@@ -19,6 +19,7 @@ def test_variables(self):
         """ Test bind/return of variables """
 
         context = Context()
+        context.variables = {}
         self.assertTrue(context.get_value('foo') is None)
         self.assertEqual(0, context.mod_count)
 

tests/test_generators.py

@@ -3,6 +3,8 @@
 import types
 import unittest
 
+import pytest
+
 from py3resttest import generators
 from py3resttest.binding import Context
 
@@ -140,6 +142,8 @@ def test_parse_fixed_sequence(self):
                   'values': vals}
         gen = generators.parse_generator(config)
         self.generator_basic_test(gen, lambda x: x in vals)
+        self.assertRaises(ValueError, generators.parse_generator, {'type': 'fixed_sequence', 'values': []})
+        self.assertRaises(ValueError, generators.parse_generator, {'type': 'fixed_sequence', 'values': {'x': 1}})
 
     def test_factory_choice(self):
         """ Tests linear sequences """
@@ -155,6 +159,17 @@ def test_factory_choice(self):
         gen = generators.factory_choice_generator(vals)()
         self.generator_basic_test(gen, lambda x: x in vals)
 
+        with pytest.raises(ValueError) as e:
+            gen = generators.parse_choice_generator({'values': []})()
+
+    def test_register_generator(self):
+
+        with pytest.raises(TypeError) as e:
+            gen = generators.register_generator(1, lambda x: x)
+
+        with pytest.raises(ValueError) as e:
+            gen = generators.register_generator('env_string', lambda x: x)
+
     def test_parse_choice_generatpr(self):
         vals = ['moobie', 'moby', 'moo']
         config = {'type': 'choice',

tests/test_testcase.py

@@ -115,6 +115,31 @@ def test_config(self):
             }
         ]
         self.assertRaises(TypeError, config_object.parse, config_list)
+        test_case = TestCase('https://api.github.com', None, None)
+        testcase_list = [
+            {'name': 'Get github user abihijo89-to'},
+            {'url': '/search/users?q=abhijo89-to'},
+            {'method': 'GET'},
+            {'headers': {'Content-Type': 'application/json'}},
+
+        ]
+
+        test_case.parse(testcase_list)
+        test_case.run()
+        self.assertTrue(test_case.is_passed)
+
+    def test_include(self):
+        with open("%s/content-test-include.yaml" % current_module_path.parent, 'r') as f:
+            test_dict_list = yaml.safe_load(f.read())
+
+            ts = TestSet()
+            ts.parse('', test_dict_list)
+            self.assertEqual(1, len(ts.test_group_list_dict))
+            ts.parse('', [{'url': 'http://google.com'}])
+            self.assertEqual(1, len(ts.test_group_list_dict))
+            ts.parse('', [{'import': 'tests/content-test.yaml'}])
+            self.assertEqual(1, len(ts.test_group_list_dict))
+
 
-        if __name__ == '__main__':
-            unittest.main()
+if __name__ == '__main__':
+    unittest.main()