def test_dispatch(self):
service = client.connect(**self.opts.kwargs)
saved_searches = service.saved_searches
if 'sdk-test1' in saved_searches:
saved_searches.delete('sdk-test1')
self.assertFalse('sdk-test1' in saved_searches)
search = "search index=sdk-tests * earliest=-1m"
saved_search = saved_searches.create('sdk-test1', search)
self.assertEqual('sdk-test1', saved_search.name)
self.assertTrue('sdk-test1' in saved_searches)
job = saved_search.dispatch()
testlib.wait(job, lambda job: bool(int(job['isDone'])))
job.results().close()
job.cancel()
# Dispatch with some additional options
kwargs = { 'dispatch.buckets': 100 }
job = saved_search.dispatch(**kwargs)
testlib.wait(job, lambda job: bool(int(job['isDone'])))
job.timeline().close()
job.cancel()
saved_searches.delete('sdk-test1')
self.assertFalse('sdk-test1' in saved_searches)
def test_results(self):
service = client.connect(**self.opts.kwargs)
jobs = service.jobs
# Run a new job to get the results, but we also make
# sure that there is at least one event in the index already
index = service.indexes['sdk-tests']
old_event_count = int(index['totalEventCount'])
if old_event_count == 0:
index.submit("test event")
testlib.wait(index, lambda index: index['totalEventCount'] == '1')
job = jobs.create("search index=sdk-tests | head 1 | stats count")
testlib.wait(job, lambda job: job['isDone'] == '1')
self.assertEqual(job['isDone'], '1')
# Fetch the results
reader = results.ResultsReader(job.results())
# The first one should always be RESULTS
kind, result = reader.next()
self.assertEqual(results.RESULTS, kind)
self.assertEqual(int(result["preview"]), 0)
# The second is always the actual result
kind, result = reader.next()
self.assertEqual(results.RESULT, kind)
self.assertEqual(int(result["count"]), 1)
def test_crud(self):
service = client.connect(**self.opts.kwargs)
jobs = service.jobs
if not service.indexes.contains("sdk-tests"):
service.indexes.create("sdk-tests")
service.indexes['sdk-tests'].clean()
# Make sure we can create a job
job = jobs.create("search index=sdk-tests")
self.assertTrue(jobs.contains(job.sid))
# Make sure we can cancel the job
job.cancel()
self.assertFalse(jobs.contains(job.sid))
# Search for non-existant data
job = jobs.create("search index=sdk-tests TERM_DOES_NOT_EXIST")
testlib.wait(job, lambda job: job['isDone'] == '1')
self.assertEqual(job['isDone'], '1')
self.assertEqual(job['eventCount'], '0')
job.finalize()
# Create a new job
job = jobs.create("search * | head 1 | stats count")
self.assertTrue(jobs.contains(job.sid))
# Set various properties on it
job.disable_preview()
job.pause()
job.set_ttl(1000)
job.set_priority(5)
job.touch()
job.refresh()
# Assert that the properties got set properly
self.check_properties(job, {
'isPreviewEnabled': '0',
'isPaused': '1',
'ttl': '1000',
'priority': '5'
})
# Set more properties
job.enable_preview()
job.unpause()
job.finalize()
job.refresh()
# Assert that they got set properly
self.check_properties(job, {
'isPreviewEnabled': '1',
'isPaused': '0',
'isFinalized': '1'
})
job.cancel()
self.assertFalse(jobs.contains(job.sid))
def test_crud(self):
service = client.connect(**self.opts.kwargs)
if not service.indexes.contains("sdk-tests"):
service.indexes.create("sdk-tests")
self.assertTrue(service.indexes.contains("sdk-tests"))
index = service.indexes['sdk-tests']
index.disable()
index.refresh()
self.assertEqual(index['disabled'], '1')
index.enable()
index.refresh()
self.assertEqual(index['disabled'], '0')
index.clean()
index.refresh()
self.assertEqual(index['totalEventCount'], '0')
cn = index.attach()
cn.write("Hello World!")
cn.close()
testlib.wait(index, lambda index: index['totalEventCount'] == '1')
self.assertEqual(index['totalEventCount'], '1')
index.submit("Hello again!!")
testlib.wait(index, lambda index: index['totalEventCount'] == '2')
self.assertEqual(index['totalEventCount'], '2')
# The following test must run on machine where splunkd runs,
# otherwise a failure is expected
testpath = path.dirname(path.abspath(__file__))
index.upload(path.join(testpath, "testfile.txt"))
testlib.wait(index, lambda index: index['totalEventCount'] == '3')
self.assertEqual(index['totalEventCount'], '3')
index.clean()
index.refresh()
self.assertEqual(index['totalEventCount'], '0')
def test_analytics(self):
# We have to add the current path to the PYTHONPATH,
# otherwise the import doesn't work quite right
sys.path.append(os.getcwd())
import analytics
# Create a tracker
tracker = analytics.input.AnalyticsTracker(
"sdk-test", self.opts.kwargs, index = "sdk-test")
service = client.connect(**self.opts.kwargs)
# Before we start, we'll clean the index
index = service.indexes["sdk-test"]
index.clean()
tracker.track("test_event", distinct_id="abc123", foo="bar", abc="123")
tracker.track("test_event", distinct_id="123abc", abc="12345")
# Wait until the events get indexed
testlib.wait(index, lambda index: index['totalEventCount'] == '2')
# Now, we create a retriever to retrieve the events
retriever = analytics.output.AnalyticsRetriever(
"sdk-test", self.opts.kwargs, index = "sdk-test")
# Assert applications
applications = retriever.applications()
self.assertEquals(len(applications), 1)
self.assertEquals(applications[0]["name"], "sdk-test")
self.assertEquals(applications[0]["count"], 2)
# Assert events
events = retriever.events()
self.assertEqual(len(events), 1)
self.assertEqual(events[0]["name"], "test_event")
self.assertEqual(events[0]["count"], 2)
# Assert properties
expected_properties = {
"abc": 2,
"foo": 1
}
properties = retriever.properties("test_event")
self.assertEqual(len(properties), len(expected_properties))
for prop in properties:
name = prop["name"]
count = prop["count"]
self.assertTrue(name in expected_properties.keys())
self.assertEqual(count, expected_properties[name])
# Assert property values
expected_property_values = {
"123": 1,
"12345": 1
}
values = retriever.property_values("test_event", "abc")
self.assertEqual(len(values), len(expected_property_values))
for value in values:
name = value["name"]
count = value["count"]
self.assertTrue(name in expected_property_values.keys())
self.assertEqual(count, expected_property_values[name])
# 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)
# Now that we're done, we'll clean the index
index.clean()
def test(self):
domain = self.environment.IPADOMAIN
domainip = self.environment.IPADOMAINIP
self.replace_file("/etc/resolv.conf",
"domain %s\nsearch %s\nnameserver %s\n"
% (domain, domain, domainip))
wait(lambda: process.run("nslookup -type=SRV _ldap._tcp.%s" % domain))
default_user = "******"
b = self.browser
b.login_and_go("server", user=default_user, href="/system/host")
def wait_number_domains(n):
if n == 0:
b.wait_text("#system_information_realms_button", "Join Domain")
else:
b.wait_text_not("#system_information_realms_button", "Join Domain")
b.wait_not_attr("#system_information_realms_button", "disabled", "disabled")
wait_number_domains(0)
# Join cockpit.lan
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
with b.wait_timeout(120):
b.set_val(".realms-op-address", domain)
b.wait_attr(".realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val(".realms-op-admin", "admin")
b.set_val(".realms-op-admin-password", "foobarfoo")
b.click(".realms-op-apply")
b.wait_popdown("realms-op")
# Check that this has worked
wait_number_domains(1)
# Leave the domain
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.click(".realms-op-apply")
b.wait_popdown("realms-op")
wait_number_domains(0)
# Send a wrong password
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.set_val(".realms-op-address", domain)
b.wait_attr(".realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val(".realms-op-admin", "admin")
b.set_val(".realms-op-admin-password", "foo")
b.click(".realms-op-apply")
b.wait_text_not(".realms-op-error", "")
b.click(".realms-op-cancel")
b.wait_popdown("realms-op")
# Try to join a non-existing domain
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.set_val(".realms-op-address", "NOPE")
b.wait_js_cond("$('.realms-op-address-error').attr('title') != ''")
b.click(".realms-op-cancel")
b.wait_popdown("realms-op")
# Cancel a join
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.set_val(".realms-op-address", domain)
b.wait_attr(".realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val(".realms-op-admin", "admin")
b.set_val(".realms-op-admin-password", "foobarfoo")
b.click(".realms-op-apply")
b.wait_visible(".realms-op-spinner")
b.click(".realms-op-cancel")
b.wait_popdown("realms-op")
def test(self):
domain = self.environment.IPADOMAIN
domainip = self.environment.IPADOMAINIP
self.replace_file(
"/etc/resolv.conf", "domain %s\nsearch %s\nnameserver %s\n" %
(domain, domain, domainip))
# Wait for DNS to work as expected.
# https://bugzilla.redhat.com/show_bug.cgi?id=1071356#c11
#
wait(lambda: process.run("nslookup -type=SRV _ldap._tcp.%s" % domain))
default_user = "******"
b = self.browser
b.login_and_go("/system", user=default_user)
def wait_number_domains(n):
if n == 0:
b.wait_text("#system-info-domain a", "Join Domain")
else:
b.wait_text_not("#system-info-domain a", "Join Domain")
b.wait_not_attr("#system-info-domain a", "disabled", "disabled")
wait_number_domains(0)
# Join cockpit.lan
b.click("#system-info-domain a")
b.wait_popup("realms-op")
with b.wait_timeout(120):
b.set_val(".realms-op-address", domain)
b.wait_attr(".realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val(".realms-op-admin", "admin")
b.set_val(".realms-op-admin-password", "foobarfoo")
b.click(".realms-op-apply")
b.wait_popdown("realms-op")
# Check that this has worked
wait_number_domains(1)
# Leave the domain
b.click("#system-info-domain a")
b.wait_popup("realms-op")
b.click(".realms-op-apply")
b.wait_popdown("realms-op")
wait_number_domains(0)
# Send a wrong password
b.click("#system-info-domain a")
b.wait_popup("realms-op")
b.set_val(".realms-op-address", domain)
b.wait_attr(".realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val(".realms-op-admin", "admin")
b.set_val(".realms-op-admin-password", "foo")
b.click(".realms-op-apply")
b.wait_text_not(".realms-op-error", "")
b.click(".realms-op-cancel")
b.wait_popdown("realms-op")
# Try to join a non-existing domain
b.click("#system-info-domain a")
b.wait_popup("realms-op")
b.set_val(".realms-op-address", "NOPE")
b.wait_js_cond("$('.realms-op-address-error').attr('title') != ''")
b.click(".realms-op-cancel")
b.wait_popdown("realms-op")
# Cancel a join
b.click("#system-info-domain a")
b.wait_popup("realms-op")
b.set_val(".realms-op-address", domain)
b.wait_attr(".realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val(".realms-op-admin", "admin")
b.set_val(".realms-op-admin-password", "foobarfoo")
b.click(".realms-op-apply")
b.wait_visible(".realms-op-spinner")
b.click(".realms-op-cancel")
b.wait_popdown("realms-op")
def test(self):
domain = self.environment.IPADOMAIN
domainip = self.environment.IPADOMAINIP
self.replace_file(
"/etc/resolv.conf", "domain %s\nsearch %s\nnameserver %s\n" %
(domain, domain, domainip))
wait(lambda: process.run("nslookup -type=SRV _ldap._tcp.%s" % domain))
default_user = "******"
b = self.browser
b.login_and_go("server", user=default_user, href="/system/host")
def wait_number_domains(n):
if n == 0:
b.wait_text("#system_information_realms_button", "Join Domain")
else:
b.wait_text_not("#system_information_realms_button",
"Join Domain")
b.wait_dbus_prop('com.redhat.Cockpit.Realms', 'Busy', ",")
wait_number_domains(0)
# Join cockpit.lan
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
with b.wait_timeout(120):
b.set_val("#realms-op-address", domain)
b.wait_attr("#realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val("#realms-op-admin", "admin")
b.set_val("#realms-op-admin-password", "foobarfoo")
b.click("#realms-op-apply")
b.wait_popdown("realms-op")
# Check that this has worked
wait_number_domains(1)
# Leave the domain
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.click("#realms-op-apply")
b.wait_popdown("realms-op")
wait_number_domains(0)
# Send a wrong password
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.set_val("#realms-op-address", domain)
b.wait_attr("#realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val("#realms-op-admin", "admin")
b.set_val("#realms-op-admin-password", "foo")
b.click("#realms-op-apply")
b.wait_text_not("#realms-op-error", "")
b.click("#realms-op-cancel")
b.wait_popdown("realms-op")
# Try to join a non-existing domain
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.set_val("#realms-op-address", "NOPE")
b.wait_js_cond("$('#realms-op-address-error').attr('title') != ''")
b.click("#realms-op-cancel")
b.wait_popdown("realms-op")
# Cancel a join
b.click("#system_information_realms_button")
b.wait_popup("realms-op")
b.set_val("#realms-op-address", domain)
b.wait_attr("#realms-op-admin", "placeholder", 'e.g. "admin"')
b.set_val("#realms-op-admin", "admin")
b.set_val("#realms-op-admin-password", "foobarfoo")
b.click("#realms-op-apply")
b.wait_visible("#realms-op-spinner")
b.click("#realms-op-cancel")
b.wait_popdown("realms-op")
def test_crud(self):
service = client.connect(**self.opts.kwargs)
searches = service.saved_searches
fired_alerts = service.fired_alerts
if 'sdk-tests' not in service.indexes:
service.indexes.create("sdk-tests")
# Clean out the test index
index = service.indexes['sdk-tests']
index.clean()
index.refresh()
self.assertEqual(event_count(index), 0)
# Delete any leftover test search
search_name = "sdk-test-search"
if search_name in searches: searches.delete(search_name)
self.assertFalse(search_name in searches)
# Create a saved search that will register an alert for any event
# submitted to the `sdk-tests` index. Note that the search is not
# yet scheduled - we wil schedule after doing a little more cleanup.
query = "index=sdk-tests"
kwargs = {
'actions': "rss",
'alert_type': "always",
'alert_comparator': "greater than",
'alert_threshold': "0",
'alert.severity': "5",
'alert.suppress': "0",
'alert.track': "1",
'dispatch.earliest_time': "rt",
'dispatch.latest_time': "rt",
'is_scheduled': "0",
'realtime_schedule': "1",
'cron_schedule': "* * * * *"
}
search = searches.create(search_name, query, **kwargs)
self.assertEqual(search.name, search_name)
self.assertEqual(search.content.is_scheduled, "0")
# Clear out any search history that may have matched due to reuse of
# the saved search name.
for job in search.history(): job.cancel()
testlib.wait(search, lambda search: len(search.history()) == 0)
self.assertEqual(len(search.history()), 0)
# Now schedule the saved search
search.update(is_scheduled=1)
search.refresh()
self.assertEqual(search.content.is_scheduled, "1")
self.assertEqual(alert_count(search), 0)
# Wait for the saved search to run. When it runs we will see a new job
# show up in the search's history.
testlib.wait(search, lambda search: len(search.history()) == 1)
self.assertEqual(len(search.history()), 1)
# When it first runs the alert count should be zero.
search.refresh()
self.assertEqual(alert_count(search), 0)
# And the fired alerts category should not exist
self.assertFalse(search_name in fired_alerts)
# Submit events and verify that they each trigger the expected alert
for count in xrange(1, 6):
# Submit an event that the search is expected to match, and wait
# for the indexer to process.
self.assertTrue(event_count(index) <= count)
index.submit("Hello #%d!!!" % count)
testlib.wait(index, lambda index: event_count(index) == count)
# Wait for the saved search to register the triggered alert
self.assertTrue(alert_count(search) <= count)
testlib.wait(
search,
lambda search: alert_count(search) == count,
timeout=120)
self.assertEqual(alert_count(search), count)
# And now .. after all that trouble, verify that we see the alerts!
self.assertTrue(search_name in fired_alerts)
alert_group = fired_alerts[search_name]
self.assertEqual(alert_group.name, search_name)
self.assertEqual(alert_group.count, count)
# Cleanup
searches.delete(search_name)
self.assertFalse(search_name in searches)
self.assertFalse(search_name in fired_alerts)
