test changes for six.py removal

Author: ashah-splunk

tests/searchcommands/test_builtin_options.py

@@ -22,7 +22,7 @@
 
 from unittest import main, TestCase
 import pytest
-from splunklib.six.moves import cStringIO as StringIO
+from io import StringIO
 
 
 from splunklib.searchcommands import environment

tests/searchcommands/test_configuration_settings.py

@@ -28,7 +28,6 @@
 from unittest import main, TestCase
 import pytest
 from splunklib.searchcommands.decorators import Configuration
-from splunklib import six
 
 
 
@@ -48,7 +47,7 @@ def generate(self):
         command._protocol_version = 1
 
         self.assertTrue(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('generating', True)])
 
         self.assertIs(command.configuration.generates_timeorder, None)
@@ -71,15 +70,15 @@ def generate(self):
             self.fail('Expected AttributeError')
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('generates_timeorder', True), ('generating', True), ('local', True), ('retainsevents', True),
              ('streaming', True)])
 
         command = TestCommand()
         command._protocol_version = 2
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('generating', True), ('type', 'stateful')])
 
         self.assertIs(command.configuration.distributed, False)
@@ -98,7 +97,7 @@ def generate(self):
             self.fail('Expected AttributeError')
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('generating', True), ('type', 'streaming')])
 
     def test_streaming_command(self):
@@ -115,7 +114,7 @@ def stream(self, records):
         command._protocol_version = 1
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('streaming', True)])
 
         self.assertIs(command.configuration.clear_required_fields, None)
@@ -139,15 +138,15 @@ def stream(self, records):
             self.fail('Expected AttributeError')
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('clear_required_fields', True), ('local', True), ('overrides_timeorder', True),
              ('required_fields', ['field_1', 'field_2', 'field_3']), ('streaming', True)])
 
         command = TestCommand()
         command._protocol_version = 2
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('type', 'streaming')])
 
         self.assertIs(command.configuration.distributed, True)
@@ -166,7 +165,7 @@ def stream(self, records):
             self.fail('Expected AttributeError')
 
         self.assertEqual(
-            list(six.iteritems(command.configuration)),
+            list(command.configuration.items()),
             [('required_fields', ['field_1', 'field_2', 'field_3']), ('type', 'stateful')])
 
 

tests/searchcommands/test_decorators.py

@@ -29,13 +29,9 @@
 
 from tests.searchcommands import rebase_environment
 
-from splunklib import six
-
-
 
 @Configuration()
 class TestSearchCommand(SearchCommand):
-
     boolean = Option(
         doc='''
         **Syntax:** **boolean=***<value>*
@@ -226,49 +222,48 @@ def fix_up(cls, command_class):
             return ConfiguredSearchCommand.ConfigurationSettings
 
         for name, values, error_values in (
-            ('clear_required_fields',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('distributed',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('generates_timeorder',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('generating',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('maxinputs',
-             (0, 50000, sys.maxsize),
-             (None, -1, sys.maxsize + 1, 'anything other than an int')),
-            ('overrides_timeorder',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('required_fields',
-             (['field_1', 'field_2'], set(['field_1', 'field_2']), ('field_1', 'field_2')),
-             (None, 0xdead, {'foo': 1, 'bar': 2})),
-            ('requires_preop',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('retainsevents',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('run_in_preview',
-              (True, False),
-             (None, 'anything other than a bool')),
-            ('streaming',
-             (True, False),
-             (None, 'anything other than a bool')),
-            ('streaming_preop',
-             ('some unicode string', b'some byte string'),
-             (None, 0xdead)),
-            ('type',
-             # TODO: Do we need to validate byte versions of these strings?
-             ('events', 'reporting', 'streaming'),
-             ('eventing', 0xdead))):
+                ('clear_required_fields',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('distributed',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('generates_timeorder',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('generating',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('maxinputs',
+                 (0, 50000, sys.maxsize),
+                 (None, -1, sys.maxsize + 1, 'anything other than an int')),
+                ('overrides_timeorder',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('required_fields',
+                 (['field_1', 'field_2'], set(['field_1', 'field_2']), ('field_1', 'field_2')),
+                 (None, 0xdead, {'foo': 1, 'bar': 2})),
+                ('requires_preop',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('retainsevents',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('run_in_preview',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('streaming',
+                 (True, False),
+                 (None, 'anything other than a bool')),
+                ('streaming_preop',
+                 ('some unicode string', b'some byte string'),
+                 (None, 0xdead)),
+                ('type',
+                 # TODO: Do we need to validate byte versions of these strings?
+                 ('events', 'reporting', 'streaming'),
+                 ('eventing', 0xdead))):
 
             for value in values:
-
                 settings_class = new_configuration_settings_class(name, value)
 
                 # Setting property exists
@@ -296,7 +291,9 @@ def fix_up(cls, command_class):
                 try:
                     new_configuration_settings_class(name, value)
                 except Exception as error:
-                    self.assertIsInstance(error, ValueError, 'Expected ValueError, not {}({}) for {}={}'.format(type(error).__name__, error, name, repr(value)))
+                    self.assertIsInstance(error, ValueError,
+                                          'Expected ValueError, not {}({}) for {}={}'.format(type(error).__name__,
+                                                                                             error, name, repr(value)))
                 else:
                     self.fail(f'Expected ValueError, not success for {name}={repr(value)}')
 
@@ -355,13 +352,13 @@ def test_option(self):
         command = TestSearchCommand()
         options = command.options
 
-        itervalues = lambda: six.itervalues(options)
+        #itervalues = lambda: options.values()
 
         options.reset()
         missing = options.get_missing()
-        self.assertListEqual(missing, [option.name for option in itervalues() if option.is_required])
-        self.assertListEqual(presets, [six.text_type(option) for option in itervalues() if option.value is not None])
-        self.assertListEqual(presets, [six.text_type(option) for option in itervalues() if six.text_type(option) != option.name + '=None'])
+        self.assertListEqual(missing, [option.name for option in options.values() if option.is_required])
+        self.assertListEqual(presets, [str(option) for option in options.values() if option.value is not None])
+        self.assertListEqual(presets, [str(option) for option in options.values() if str(option) != option.name + '=None'])
 
         test_option_values = {
             validators.Boolean: ('0', 'non-boolean value'),
@@ -378,7 +375,7 @@ def test_option(self):
             validators.RegularExpression: ('\\s+', '(poorly formed regular expression'),
             validators.Set: ('bar', 'non-existent set entry')}
 
-        for option in itervalues():
+        for option in options.values():
             validator = option.validator
 
             if validator is None:
@@ -397,7 +394,8 @@ def test_option(self):
             except ValueError:
                 pass
             except BaseException as error:
-                self.assertFalse(f'Expected ValueError for {option.name}={illegal_value}, not this {type(error).__name__}: {error}')
+                self.assertFalse(
+                    f'Expected ValueError for {option.name}={illegal_value}, not this {type(error).__name__}: {error}')
             else:
                 self.assertFalse(f'Expected ValueError for {option.name}={illegal_value}, not a pass.')
 
@@ -407,7 +405,7 @@ def test_option(self):
             'code': 'foo == \"bar\"',
             'duration': 89999,
             'fieldname': 'some.field_name',
-            'file': six.text_type(repr(__file__)),
+            'file': str(repr(__file__)),
             'integer': 100,
             'float': 99.9,
             'logging_configuration': environment.logging_configuration,
@@ -421,7 +419,7 @@ def test_option(self):
             'required_code': 'foo == \"bar\"',
             'required_duration': 89999,
             'required_fieldname': 'some.field_name',
-            'required_file': six.text_type(repr(__file__)),
+            'required_file': str(repr(__file__)),
             'required_integer': 100,
             'required_float': 99.9,
             'required_map': 'foo',
@@ -436,36 +434,38 @@ def test_option(self):
         self.maxDiff = None
 
         tuplewrap = lambda x: x if isinstance(x, tuple) else (x,)
-        invert = lambda x: {v: k for k, v in six.iteritems(x)}
+        invert = lambda x: {v: k for k, v in x.items()}
 
-        for x in six.itervalues(command.options):
-             # isinstance doesn't work for some reason
+        for x in command.options.values():
+            # isinstance doesn't work for some reason
             if type(x.value).__name__ == 'Code':
                 self.assertEqual(expected[x.name], x.value.source)
             elif type(x.validator).__name__ == 'Map':
                 self.assertEqual(expected[x.name], invert(x.validator.membership)[x.value])
             elif type(x.validator).__name__ == 'RegularExpression':
                 self.assertEqual(expected[x.name], x.value.pattern)
             elif isinstance(x.value, TextIOWrapper):
-                self.assertEqual(expected[x.name], f"'{x.value.name}'" )
-            elif not isinstance(x.value, (bool,) + (float,) + (six.text_type,) + (six.binary_type,) + tuplewrap(six.integer_types)):
+                self.assertEqual(expected[x.name], f"'{x.value.name}'")
+            elif not isinstance(x.value, (bool,) + (float,) + (str,) + (bytes,) + tuplewrap(int)):
                 self.assertEqual(expected[x.name], repr(x.value))
             else:
                 self.assertEqual(expected[x.name], x.value)
 
         expected = (
-            'foo="f" boolean="f" code="foo == \\"bar\\"" duration="24:59:59" fieldname="some.field_name" '
-            'file=' + json_encode_string(__file__) + ' float="99.9" integer="100" map="foo" match="123-45-6789" '
-            'optionname="some_option_name" record="f" regularexpression="\\\\s+" required_boolean="f" '
-            'required_code="foo == \\"bar\\"" required_duration="24:59:59" required_fieldname="some.field_name" '
-            'required_file=' + json_encode_string(__file__) + ' required_float="99.9" required_integer="100" required_map="foo" '
-            'required_match="123-45-6789" required_optionname="some_option_name" required_regularexpression="\\\\s+" '
-            'required_set="bar" set="bar" show_configuration="f"')
+                'foo="f" boolean="f" code="foo == \\"bar\\"" duration="24:59:59" fieldname="some.field_name" '
+                'file=' + json_encode_string(__file__) + ' float="99.9" integer="100" map="foo" match="123-45-6789" '
+                                                         'optionname="some_option_name" record="f" regularexpression="\\\\s+" required_boolean="f" '
+                                                         'required_code="foo == \\"bar\\"" required_duration="24:59:59" required_fieldname="some.field_name" '
+                                                         'required_file=' + json_encode_string(
+            __file__) + ' required_float="99.9" required_integer="100" required_map="foo" '
+                        'required_match="123-45-6789" required_optionname="some_option_name" required_regularexpression="\\\\s+" '
+                        'required_set="bar" set="bar" show_configuration="f"')
 
-        observed = six.text_type(command.options)
+        observed = str(command.options)
 
         self.assertEqual(observed, expected)
 
+
 TestSearchCommand.__test__ = False
 
 if __name__ == "__main__":

tests/searchcommands/test_internals_v1.py

@@ -26,10 +26,8 @@
 
 from splunklib.searchcommands.search_command import SearchCommand
 
-from splunklib.six import StringIO, BytesIO
+from io import StringIO, BytesIO
 
-from splunklib import six
-from splunklib.six.moves import range
 
 
 @pytest.mark.smoke
@@ -57,7 +55,7 @@ def fix_up(cls, command_class): pass
         command = TestCommandLineParserCommand()
         CommandLineParser.parse(command, options)
 
-        for option in six.itervalues(command.options):
+        for option in command.options.values():
             if option.name in ['logging_configuration', 'logging_level', 'record', 'show_configuration']:
                 self.assertFalse(option.is_set)
                 continue
@@ -74,7 +72,7 @@ def fix_up(cls, command_class): pass
         command = TestCommandLineParserCommand()
         CommandLineParser.parse(command, options + fieldnames)
 
-        for option in six.itervalues(command.options):
+        for option in command.options.values():
             if option.name in ['logging_configuration', 'logging_level', 'record', 'show_configuration']:
                 self.assertFalse(option.is_set)
                 continue
@@ -89,7 +87,7 @@ def fix_up(cls, command_class): pass
         command = TestCommandLineParserCommand()
         CommandLineParser.parse(command, ['required_option=true'] + fieldnames)
 
-        for option in six.itervalues(command.options):
+        for option in command.options.values():
             if option.name in ['unnecessary_option', 'logging_configuration', 'logging_level', 'record',
                                'show_configuration']:
                 self.assertFalse(option.is_set)
@@ -284,7 +282,7 @@ def test_input_header(self):
             'sentence': 'hello world!'}
 
         input_header = InputHeader()
-        text = reduce(lambda value, item: value + f'{item[0]}:{item[1]}\n', six.iteritems(collection), '') + '\n'
+        text = reduce(lambda value, item: value + f'{item[0]}:{item[1]}\n', collection.items(), '') + '\n'
 
         with closing(StringIO(text)) as input_file:
             input_header.read(input_file)