def test_await_telemetry_count(self):
count_seq = self.get_counter_sequence(20)
sin_seq = self.get_oscillator_sequence(100)
pred = predicates.greater_than_or_equal_to(10)
search_pred = self.api.get_telemetry_pred("Counter", pred)
count_pred = predicates.within_range(10, 20)
t1 = self.fill_history_async(self.pipeline.enqueue_telemetry,
count_seq, 0.05)
t2 = self.fill_history_async(self.pipeline.enqueue_telemetry, sin_seq,
0.01)
results = self.api.await_telemetry_count(count_pred, search_pred)
msg = predicates.get_descriptive_string(len(results), count_pred)
assert count_pred(len(results)), msg
t1.join()
t2.join()
self.api.clear_histories()
t1 = self.fill_history_async(self.pipeline.enqueue_telemetry,
count_seq, 0.05)
t2 = self.fill_history_async(self.pipeline.enqueue_telemetry, sin_seq,
0.01)
results = self.api.await_telemetry_count(100)
assert len(results) == 100, "await count should have found 100 items"
t1.join()
t2.join()
self.fill_history_async(self.pipeline.enqueue_telemetry, count_seq,
0.05)
self.fill_history_async(self.pipeline.enqueue_telemetry, sin_seq, 0.02)
results = self.api.await_telemetry_count(100, timeout=1)
assert len(
results) < 100, "await count should have found fewer 100 items"
def test_find_history_count_timeout(self):
count_pred = predicates.greater_than_or_equal_to(10)
search_pred = predicates.greater_than_or_equal_to(40)
self.fill_history_async(self.tHistory.data_callback, range(0, 50),
0.01)
results = self.api.find_history_count(count_pred, self.tHistory)
assert (
len(results) < 10
), "The search should have returned an incomplete list, but found {}".format(
results)
results = self.api.find_history_count(count_pred,
self.tHistory,
search_pred,
timeout=2)
self.assert_lists_equal(range(40, 50), results)
self.fill_history_async(self.tHistory.data_callback, range(50, 60),
0.01)
results = self.api.find_history_count(count_pred,
self.tHistory,
search_pred,
start=50,
timeout=2)
self.assert_lists_equal(range(50, 60), results)
self.tHistory.clear()
self.fill_history_async(self.tHistory.data_callback, range(35, 60),
0.1)
results = self.api.find_history_count(count_pred,
self.tHistory,
search_pred,
timeout=1)
assert (
len(results) < 10
), "The search should have returned an incomplete list, but found {}".format(
results)
def test_find_history_count(self):
count_pred = predicates.greater_than_or_equal_to(10)
search_pred = predicates.greater_than_or_equal_to(40)
self.fill_history(self.tHistory.data_callback, range(0, 50))
results = self.api.find_history_count(count_pred, self.tHistory)
self.assert_lists_equal(range(0, 50), results)
results = self.api.find_history_count(count_pred, self.tHistory,
search_pred)
self.assert_lists_equal(range(40, 50), results)
self.fill_history(self.tHistory.data_callback, range(50, 70))
results = self.api.find_history_count(count_pred, self.tHistory,
search_pred)
self.assert_lists_equal(range(40, 70), results)
results = self.api.find_history_count(count_pred,
self.tHistory,
start=60)
self.assert_lists_equal(range(60, 70), results)
def test_dummy_pipeline(self):
length = 15
event_list = self.get_severity_sequence(length)
t1 = self.fill_history_async(self.pipeline.enqueue_event, event_list,
0.1)
print("waiting for queue to fill")
pred = predicates.greater_than_or_equal_to(length // 2)
results = self.api.await_event_count(pred)
assert pred(len(results)), "the correct amount of objects was received"
t1.join()
evr_hist = self.api.get_event_test_history()
item_count = len(evr_hist)
assert (
item_count == length
), "Were the correct number of items in the history? ({},{})".format(
item_count, length)
def test_assert_telemetry_count(self):
count_seq = self.get_counter_sequence(20)
sin_seq = self.get_oscillator_sequence(100)
pred = predicates.greater_than_or_equal_to(10)
search_pred = self.api.get_telemetry_pred("Counter", pred)
count_pred = predicates.within_range(10, 20)
self.fill_history_async(self.pipeline.enqueue_telemetry, count_seq,
0.05)
self.fill_history_async(self.pipeline.enqueue_telemetry, sin_seq, 0.01)
self.api.assert_telemetry_count(count_pred, search_pred, timeout=2)
self.api.assert_telemetry_count(count_pred, search_pred)
self.api.clear_histories()
t1 = self.fill_history_async(self.pipeline.enqueue_telemetry,
count_seq, 0.05)
t2 = self.fill_history_async(self.pipeline.enqueue_telemetry, sin_seq,
0.01)
self.api.assert_telemetry_count(100, timeout=2)
t1.join()
t2.join()
try:
self.api.assert_telemetry_count(100)
raise self.AssertionFailure()
except AssertionError:
assert True, "api raised the correct error"
except self.AssertionFailure:
assert False, "api failed to raise an assertion error"
self.api.clear_histories()
self.fill_history_async(self.pipeline.enqueue_telemetry, count_seq,
0.05)
self.fill_history_async(self.pipeline.enqueue_telemetry, sin_seq, 0.02)
try:
self.api.assert_telemetry_count(100, timeout=1)
raise self.AssertionFailure()
except AssertionError:
assert True, "api raised the correct error"
except self.AssertionFailure:
assert False, "api failed to raise an assertion error"
def test_greater_than_or_equal_to(self):
pred = predicates.greater_than_or_equal_to(1)
assert pred(1), "one is greater than or equal to 1"
assert pred(10), "ten is greater than or equal to 1"
assert not pred(-1), "negative is not greater than or equal to 1"
self.check_str(pred)
