pytest.ini and remove deprecation warnings

Author: amysutedja

pytest.ini

@@ -0,0 +1,6 @@
+[pytest]
+markers =
+    smoke: essential smoke tests
+
+junit_family =
+    xunit2

tests/searchcommands/test_builtin_options.py

@@ -145,18 +145,18 @@ def test_logging_level(self):
 
         # logging_level accepts all logging levels and returns their canonical string values
 
-        self.assertEquals(warning, command.logging_level)
+        self.assertEqual(warning, command.logging_level)
 
         for level in logging._levelNames:
             if type(level) is int:
                 command.logging_level = level
                 level_name = logging.getLevelName(level)
-                self.assertEquals(command.logging_level, warning if level_name == notset else level_name)
+                self.assertEqual(command.logging_level, warning if level_name == notset else level_name)
             else:
                 level_name = logging.getLevelName(logging.getLevelName(level))
                 for variant in level, level.lower(), level.capitalize():
                     command.logging_level = variant
-                    self.assertEquals(command.logging_level, warning if level_name == notset else level_name)
+                    self.assertEqual(command.logging_level, warning if level_name == notset else level_name)
 
         # logging_level accepts any numeric value
 
@@ -203,10 +203,10 @@ def _test_boolean_option(self, option):
             for variant in value, value.capitalize(), value.upper():
                 for s in variant, bytes(variant):
                     option.fset(command, s)
-                    self.assertEquals(option.fget(command), boolean_values[value])
+                    self.assertEqual(option.fget(command), boolean_values[value])
 
         option.fset(command, None)
-        self.assertEquals(option.fget(command), None)
+        self.assertEqual(option.fget(command), None)
 
         for value in 13, b'bytes', 'string', object():
             try:

tests/searchcommands/test_internals_v1.py

@@ -89,7 +89,7 @@ def fix_up(cls, command_class): pass
 
         expected = 'testcommandlineparser required_option="t" unnecessary_option="f" field_1 field_2 field_3'
         self.assertEqual(expected, str(command))
-        self.assertEquals(command.fieldnames, fieldnames)
+        self.assertEqual(command.fieldnames, fieldnames)
 
         # Command line without any unnecessary options
 
@@ -104,7 +104,7 @@ def fix_up(cls, command_class): pass
 
         expected = 'testcommandlineparser required_option="t" field_1 field_2 field_3'
         self.assertEqual(expected, str(command))
-        self.assertEquals(command.fieldnames, fieldnames)
+        self.assertEqual(command.fieldnames, fieldnames)
 
         # Command line with missing required options, with or without fieldnames or unnecessary options
 
@@ -235,7 +235,7 @@ def test_input_header(self):
         with closing(StringIO('\r\n'.encode())) as input_file:
             input_header.read(input_file)
 
-        self.assertEquals(len(input_header), 0)
+        self.assertEqual(len(input_header), 0)
 
         # One unnamed single-line item (same as no items)
 
@@ -244,14 +244,14 @@ def test_input_header(self):
         with closing(StringIO('this%20is%20an%20unnamed%20single-line%20item\n\n'.encode())) as input_file:
             input_header.read(input_file)
 
-        self.assertEquals(len(input_header), 0)
+        self.assertEqual(len(input_header), 0)
 
         input_header = InputHeader()
 
         with closing(StringIO('this%20is%20an%20unnamed\nmulti-\nline%20item\n\n'.encode())) as input_file:
             input_header.read(input_file)
 
-        self.assertEquals(len(input_header), 0)
+        self.assertEqual(len(input_header), 0)
 
         # One named single-line item
 
@@ -260,16 +260,16 @@ def test_input_header(self):
         with closing(StringIO('Foo:this%20is%20a%20single-line%20item\n\n'.encode())) as input_file:
             input_header.read(input_file)
 
-        self.assertEquals(len(input_header), 1)
-        self.assertEquals(input_header['Foo'], 'this is a single-line item')
+        self.assertEqual(len(input_header), 1)
+        self.assertEqual(input_header['Foo'], 'this is a single-line item')
 
         input_header = InputHeader()
 
         with closing(StringIO('Bar:this is a\nmulti-\nline item\n\n'.encode())) as input_file:
             input_header.read(input_file)
 
-        self.assertEquals(len(input_header), 1)
-        self.assertEquals(input_header['Bar'], 'this is a\nmulti-\nline item')
+        self.assertEqual(len(input_header), 1)
+        self.assertEqual(input_header['Bar'], 'this is a\nmulti-\nline item')
 
         # The infoPath item (which is the path to a file that we open for reads)
 
@@ -278,7 +278,7 @@ def test_input_header(self):
         with closing(StringIO('infoPath:non-existent.csv\n\n'.encode())) as input_file:
             input_header.read(input_file)
 
-        self.assertEquals(len(input_header), 1)
+        self.assertEqual(len(input_header), 1)
         self.assertEqual(input_header['infoPath'], 'non-existent.csv')
 
         # Set of named items
@@ -348,7 +348,7 @@ def fix_up(cls, command_class): pass
             'warn_message=warning_message\r\n'
             '\r\n')
 
-        self.assertEquals(output_buffer.getvalue(), expected)
+        self.assertEqual(output_buffer.getvalue(), expected)
         return
 
     _package_path = os.path.dirname(__file__)

tests/test_examples.py

@@ -70,7 +70,7 @@ class ExamplesTestCase(testlib.SDKTestCase):
     def check_commands(self, *args):
         for arg in args:
             result = run(arg)
-            self.assertEquals(result, 0, '"{0}" run failed with result code {1}'.format(arg, result))
+            self.assertEqual(result, 0, '"{0}" run failed with result code {1}'.format(arg, result))
         self.service.login()  # Because a Splunk restart invalidates our session
 
     def setUp(self):
@@ -82,14 +82,14 @@ def setUp(self):
     @unittest.skipIf(six.PY3, "Async needs work to support Python 3")
     def test_async(self):
         result = run("async/async.py sync")
-        self.assertEquals(result, 0)
+        self.assertEqual(result, 0)
 
         try:
             # Only try running the async version of the test if eventlet
             # is present on the system
             import eventlet
             result = run("async/async.py async")
-            self.assertEquals(result, 0)
+            self.assertEqual(result, 0)
         except:
             pass
 
@@ -98,7 +98,7 @@ def test_build_dir_exists(self):
 
     def test_binding1(self):
         result = run("binding1.py")
-        self.assertEquals(result, 0)
+        self.assertEqual(result, 0)
 
     def test_conf(self):
         try:
@@ -161,7 +161,7 @@ def test_handlers(self):
         #     try:
         #         time.sleep(5) # Wait for proxy to finish initializing
         #         result = run("handlers/handler_proxy.py --proxy=localhost:8080")
-        #         self.assertEquals(result, 0)
+        #         self.assertEqual(result, 0)
         #     finally:
         #         process.kill()
 
@@ -289,9 +289,9 @@ def test_analytics(self):
 
         # Assert applications
         applications = retriever.applications()
-        self.assertEquals(len(applications), 1)
-        self.assertEquals(applications[0]["name"], "sdk-test")
-        self.assertEquals(applications[0]["count"], 2)
+        self.assertEqual(len(applications), 1)
+        self.assertEqual(applications[0]["name"], "sdk-test")
+        self.assertEqual(applications[0]["count"], 2)
 
         # Assert events
         events = retriever.events()
@@ -328,9 +328,9 @@ def test_analytics(self):
         # Assert event over time
         over_time = retriever.events_over_time(
             time_range = analytics.output.TimeRange.MONTH)
-        self.assertEquals(len(over_time), 1)
-        self.assertEquals(len(over_time["test_event"]), 1)
-        self.assertEquals(over_time["test_event"][0]["count"], 2)
+        self.assertEqual(len(over_time), 1)
+        self.assertEqual(len(over_time["test_event"]), 1)
+        self.assertEqual(over_time["test_event"][0]["count"], 2)
 
         # Now that we're done, we'll clean the index
         index.clean()

tests/test_results.py

@@ -30,7 +30,7 @@ def test_read_from_empty_result_set(self):
         job = self.service.jobs.create("search index=_internal_does_not_exist | head 2")
         while not job.is_done():
             sleep(0.5)
-        self.assertEquals(0, len(list(results.ResultsReader(io.BufferedReader(job.results())))))
+        self.assertEqual(0, len(list(results.ResultsReader(io.BufferedReader(job.results())))))
 
     def test_read_normal_results(self):
         xml_text = """
@@ -162,7 +162,7 @@ def test_read_raw_field_with_segmentation(self):
     def assert_parsed_results_equals(self, xml_text, expected_results):
         results_reader = results.ResultsReader(BytesIO(xml_text.encode('utf-8')))
         actual_results = [x for x in results_reader]
-        self.assertEquals(expected_results, actual_results)
+        self.assertEqual(expected_results, actual_results)
 
 if __name__ == "__main__":
     try:

tests/test_service.py

@@ -41,9 +41,9 @@ def test_capabilities(self):
     def test_info(self):
         info = self.service.info
         keys = ["build", "cpu_arch", "guid", "isFree", "isTrial", "licenseKeys",
-            "licenseSignature", "licenseState", "master_guid", "mode", 
+            "licenseSignature", "licenseState", "master_guid", "mode",
             "os_build", "os_name", "os_version", "serverName", "version"]
-        for key in keys: 
+        for key in keys:
             self.assertTrue(key in list(info.keys()))
 
     def test_info_with_namespace(self):
@@ -141,11 +141,11 @@ def test_splunk_version(self):
         for version in [(4,3,3), (5,), (5,0,1)]:
             with self.fake_splunk_version(version):
                 self.assertEqual(version, self.service.splunk_version)
-    
+
     def test_query_without_login_raises_auth_error(self):
         service = self._create_unauthenticated_service()
         self.assertRaises(AuthenticationError, lambda: service.indexes.list())
-    
+
     # This behavior is needed for backward compatibility for code
     # prior to the introduction of AuthenticationError
     def test_query_without_login_raises_http_401(self):
@@ -181,11 +181,11 @@ def assertIsNotNone(self, obj, msg=None):
 
     def test_login_and_store_cookie(self):
         self.assertIsNotNone(self.service.get_cookies())
-        self.assertEquals(len(self.service.get_cookies()), 0)
+        self.assertEqual(len(self.service.get_cookies()), 0)
         self.service.login()
         self.assertIsNotNone(self.service.get_cookies())
         self.assertNotEquals(self.service.get_cookies(), {})
-        self.assertEquals(len(self.service.get_cookies()), 1)
+        self.assertEqual(len(self.service.get_cookies()), 1)
 
     def test_login_with_cookie(self):
         self.service.login()
@@ -202,10 +202,10 @@ def test_login_with_cookie(self):
     def test_login_fails_with_bad_cookie(self):
         bad_cookie = {'bad': 'cookie'}
         service2 = client.Service()
-        self.assertEquals(len(service2.get_cookies()), 0)
+        self.assertEqual(len(service2.get_cookies()), 0)
         service2.get_cookies().update(bad_cookie)
         service2.login()
-        self.assertEquals(service2.get_cookies(), {'bad': 'cookie'})
+        self.assertEqual(service2.get_cookies(), {'bad': 'cookie'})
 
         # Should get an error with a bad cookie
         try:
@@ -228,7 +228,7 @@ def test_autologin_with_cookie(self):
 
     def test_login_fails_with_no_cookie(self):
         service2 = client.Service()
-        self.assertEquals(len(service2.get_cookies()), 0)
+        self.assertEqual(len(service2.get_cookies()), 0)
 
         # Should get an error when no authentication method
         try:
@@ -330,25 +330,25 @@ def test_trailing_with_n_args_works(self):
 class TestEntityNamespacing(testlib.SDKTestCase):
     def test_proper_namespace_with_arguments(self):
         entity = self.service.apps['search']
-        self.assertEquals((None,None,"global"), entity._proper_namespace(sharing="global"))
-        self.assertEquals((None,"search","app"), entity._proper_namespace(sharing="app", app="search"))
-        self.assertEquals(
+        self.assertEqual((None,None,"global"), entity._proper_namespace(sharing="global"))
+        self.assertEqual((None,"search","app"), entity._proper_namespace(sharing="app", app="search"))
+        self.assertEqual(
             ("admin", "search", "user"),
             entity._proper_namespace(sharing="user", app="search", owner="admin")
         )
 
     def test_proper_namespace_with_entity_namespace(self):
         entity = self.service.apps['search']
         namespace = (entity.access.owner, entity.access.app, entity.access.sharing)
-        self.assertEquals(namespace, entity._proper_namespace())
+        self.assertEqual(namespace, entity._proper_namespace())
 
     def test_proper_namespace_with_service_namespace(self):
         entity = client.Entity(self.service, client.PATH_APPS + "search")
         del entity._state['access']
         namespace = (self.service.namespace.owner,
                      self.service.namespace.app,
                      self.service.namespace.sharing)
-        self.assertEquals(namespace, entity._proper_namespace())
+        self.assertEqual(namespace, entity._proper_namespace())
 
 if __name__ == "__main__":
     try: