Resolved David's comments.

Author: Frederick Ross

tests/test_conf.py

@@ -79,7 +79,7 @@ def test_confs(self):
         key = testlib.tmpname()
         val = testlib.tmpname()
         stanza.update(**{key: val})
-        self.assertEventuallyEqual(1, lambda: stanza.refresh() and len(stanza), pause_time=0.2)
+        self.assertEventuallyTrue(lambda: stanza.refresh() and len(stanza) == 1, pause_time=0.2)
         self.assertEqual(len(stanza), 1)
         self.assertTrue(key in stanza)
 

tests/test_examples.py

@@ -284,7 +284,7 @@ def test_analytics(self):
         tracker.track("test_event", distinct_id="123abc", abc="12345")
 
         # Wait until the events get indexed
-        self.assertEventuallyEqual('2', lambda: index.refresh()['totalEventCount'])
+        self.assertEventuallyTrue(lambda: index.refresh()['totalEventCount'] == '2')
 
         # Now, we create a retriever to retrieve the events
         retriever = analytics.output.AnalyticsRetriever(

tests/test_fired_alert.py

@@ -62,20 +62,24 @@ def test_alerts_on_events(self):
         self.assertEqual(len(self.saved_search.fired_alerts), 0)
 
         self.index.enable()
-        self.assertEventuallyEqual('0', lambda: self.index.refresh() and self.index['disabled'], timeout=25)
+        self.assertEventuallyTrue(lambda: self.index.refresh() and self.index['disabled'] == '0', timeout=25)
 
         eventCount = int(self.index['totalEventCount'])
         self.assertEqual(self.index['sync'], '0')
         self.assertEqual(self.index['disabled'], '0')
         self.index.refresh()
         self.index.submit('This is a test ' + testlib.tmpname(),
                           sourcetype='sdk_use', host='boris')
-        self.assertEventuallyEqual(str(eventCount+1), lambda: self.index.refresh() and self.index['totalEventCount'], timeout=50)
-        self.assertEventuallyEqual(
-            1,
-            lambda: self.saved_search.refresh() and self.saved_search.alert_count,
-            timeout=200
-        )
+        def f():
+            self.index.refresh()
+            return int(self.index['totalEventCount']) == eventCount+1
+        self.assertEventuallyTrue(f, timeout=50)
+
+        def g():
+            self.saved_search.refresh()
+            return self.saved_search.alert_count == 1
+        self.assertEventuallyTrue(g, timeout=200)
+
         alerts = self.saved_search.fired_alerts
         self.assertEqual(len(alerts), 1)
 

tests/test_index.py

@@ -27,7 +27,7 @@ def setUp(self):
         super(IndexTest, self).setUp()
         self.index_name = testlib.tmpname()
         self.index = self.service.indexes.create(self.index_name)
-        self.assertEventuallyEqual('0', lambda: self.index.refresh()['disabled'])
+        self.assertEventuallyTrue(lambda: self.index.refresh()['disabled'] == '0')
 
     def tearDown(self):
         super(IndexTest, self).tearDown()
@@ -73,7 +73,7 @@ def test_submit_and_clean(self):
         self.index.refresh()
         originalCount = int(self.index['totalEventCount'])
         self.index.submit("Hello again!", sourcetype="Boris", host="meep")
-        self.assertEventuallyEqual(originalCount+1, self.totalEventCount)
+        self.assertEventuallyTrue(lambda: self.totalEventCount == originalCount+1)
 
         # Cleaning an enabled index on 4.x takes forever, so we disable it.
         # However, cleaning it on 5 requires it to be enabled.
@@ -91,21 +91,21 @@ def test_submit(self):
         self.assertEqual(self.index['sync'], '0')
         self.assertEqual(self.index['disabled'], '0')
         self.index.submit("Hello again!", sourcetype="Boris", host="meep")
-        self.assertEventuallyEqual(eventCount+1, self.totalEventCount)
+        self.assertEventuallyTrue(lambda: self.totalEventCount == eventCount+1)
 
     def test_submit_via_attach(self):
         eventCount = int(self.index['totalEventCount'])
         cn = self.index.attach()
         cn.send("Hello Boris!\r\n")
         cn.close()
-        self.assertEventuallyEqual(eventCount+1, self.totalEventCount)
+        self.assertEventuallyTrue(lambda: self.totalEventCount == eventCount+1)
 
     def test_submit_via_attached_socket(self):
         eventCount = int(self.index['totalEventCount'])
         f = self.index.attached_socket
         with f() as sock:
             sock.send('Hello world!\r\n')
-        self.assertEventuallyEqual(eventCount+1, self.totalEventCount)
+        self.assertEventuallyTrue(lambda: self.totalEventCount == eventCount+1)
 
     def test_upload(self):
         self.installAppFromCollection("file_to_upload")
@@ -114,7 +114,7 @@ def test_upload(self):
 
         path = self.pathInApp("file_to_upload", ["log.txt"])
         self.index.upload(path)
-        self.assertEventuallyEqual(eventCount+4, self.totalEventCount)
+        self.assertEventuallyTrue(lambda: self.totalEventCount == eventCount+4)
 
 if __name__ == "__main__":
     import unittest

tests/test_input.py

@@ -69,10 +69,11 @@ def test_oneshot(self):
 
         path = self.pathInApp("file_to_upload", ["log.txt"])
         self.service.inputs.oneshot(path, index=index_name)
-        self.assertEventuallyEqual(
-            str(eventCount+4),
-            lambda: index.refresh()['totalEventCount']
-        )
+
+        def f():
+            index.refresh()
+            return int(index['totalEventCount'] == eventCount+4)
+        self.assertEventuallyTrue(f)
 
     def test_oneshot_on_nonexistant_file(self):
         name = testlib.tmpname()

tests/test_job.py

@@ -141,18 +141,16 @@ def test_setpriority(self):
         # of a job unless Splunk is running as root. This is because Splunk jobs
         # are tied up with operating system processes and their priorities.
         self.assertEqual(5, int(self.job['priority']))
+
         new_priority = 3
         self.job.set_priority(new_priority)
-        def priority():
+
+        def f():
             if self.job.is_done():
                 self.fail("Job already done before priority was set.")
             self.job.refresh()
-            return int(self.job['priority'])
-        self.assertEventuallyEqual(
-            new_priority,
-            priority,
-            timeout=120
-        )
+            return int(self.job['priority']) == new_priority
+        self.assertEventuallyTrue(f, timeout=120)
 
 class TestJob(testlib.SDKTestCase):
     def setUp(self):
@@ -190,28 +188,22 @@ def test_pause(self):
             self.assertEqual(self.job['isPaused'], '0')
 
         self.job.pause()
-        self.assertEventuallyEqual(
-            '1',
-            lambda: self.job.refresh()['isPaused']
-        )
+        self.assertEventuallyTrue(lambda: self.job.refresh()['isPaused'] == '1')
 
     def test_unpause(self):
         if self.job['isPaused'] == '0':
             self.job.pause()
             self.job.refresh()
             self.assertEqual(self.job['isPaused'], '1')
         self.job.unpause()
-        self.assertEventuallyEqual(
-            '0',
-            lambda: self.job.refresh()['isPaused']
-        )
+        self.assertEventuallyTrue(lambda: self.job.refresh()['isPaused'] == '0')
 
     def test_finalize(self):
         if self.job['isFinalized'] == '1':
             self.fail("Job is already finalized; can't test .finalize() method.")
         else:
             self.job.finalize()
-            self.assertEventuallyEqual('1', lambda: self.job.refresh()['isFinalized'])
+            self.assertEventuallyTrue(lambda: self.job.refresh()['isFinalized'] == '1')
 
     def test_setttl(self):
         old_ttl = int(self.job['ttl'])

tests/testlib.py

@@ -72,14 +72,6 @@ class SDKTestCase(unittest.TestCase):
     restart_already_required = False
     installedApps = []
 
-    def assertEventuallyEqual(self, expected, func, timeout=10, pause_time=0.5,
-                              timeout_message="Operation timed out."):
-        self.assertEventuallyTrue(
-            lambda: expected == func(),
-            timeout=timeout, pause_time=pause_time,
-            timeout_message=timeout_message
-        )
-
     def assertEventuallyTrue(self, predicate, timeout=10, pause_time=0.5,
                              timeout_message="Operation timed out."):
         assert pause_time < timeout
@@ -134,6 +126,14 @@ def check_entity(self, entity):
                 raise
 
     def clearRestartMessage(self):
+        """Tell Splunk to forget that it needs to be restarted.
+
+        This is used mostly in cases such as deleting a temporary application.
+        Splunk asks to be restarted when that happens, but unless the application
+        contained modular input kinds or the like, it isn't necessary.
+        """
+        if not self.service.restart_required:
+            raise ValueError("Tried to clear restart message when there was none.")
         try:
             self.service.delete("messages/restart_required")
         except client.HTTPError as he:
@@ -158,20 +158,35 @@ def installAppFromCollection(self, name):
     def pathInApp(self, appName, pathComponents):
         """Return a path to *pathComponents* in *appName*.
 
-        *pathComponents* shold be a list of strings giving the components.
+        `pathInApp` is used to refer to files in applications installed with
+        `installAppFromCollection`. For example, the app `file_to_upload` in
+        the collection contains `log.txt`. To get the path to it, call::
+
+            pathInApp('file_to_upload', ['log.txt'])
+
+        The path to `setup.xml` in `has_setup_xml` would be fetched with::
+
+            pathInApp('has_setup_xml', ['default', 'setup.xml'])
+
+        `pathInApp` figures out the correct separator to use (based on whether
+        splunkd is running on Windows or Unix) and joins the elements in
+        *pathComponents* into a path relative to the application specified by
+        *appName*.
+
+        *pathComponents* should be a list of strings giving the components.
         This function will try to figure out the correct separator (/ or \)
         for the platform that splunkd is running on and construct the path
         as needed.
 
         :return: A string giving the path.
         """
         splunkHome = self.service.settings['SPLUNK_HOME']
-        if "/" in splunkHome and "\\" in splunkHome:
-            raise ValueError("There are both forward and back slashes in $SPLUNK_HOME. What system are you on?!?")
+        if "\\" in splunkHome:
+            # This clause must come first, since Windows machines may
+            # have mixed \ and / in their paths.
+            separator = "\\"
         elif "/" in splunkHome:
             separator = "/"
-        elif "\\" in splunkHome:
-            separator = "\\"
         else:
             raise ValueError("No separators in $SPLUNK_HOME. Can't determine what file separator to use.")
         appPath = separator.join([splunkHome, "etc", "apps", appName] + pathComponents)
@@ -198,6 +213,9 @@ def setUpClass(cls):
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.service = client.connect(**self.opts.kwargs)
+        # If Splunk is in a state requiring restart, go ahead
+        # and restart. That way we'll be sane for the rest of
+        # the test.
         if self.service.restart_required:
             self.restartSplunk()
         logging.debug("Connected to splunkd version %s", '.'.join(str(x) for x in self.service.splunk_version))