def test_hook_exception(self): message = 'exception message' def exception_hook(exception, **kwargs): self.assertIsInstance(exception, TimeExecutionException) return dict(exception_message=str(exception)) def asserts(name, **data): self.assertEqual(data['exception_message'], message) configure( backends=[AssertBackend(asserts)], hooks=[exception_hook] ) class TimeExecutionException(Exception): pass @time_execution def go(): raise TimeExecutionException(message) with self.assertRaises(TimeExecutionException): go()
def test_with_origin(self): with settings(origin='unit_test'): go() for metric in self._query_backend(go.fqn)['hits']['hits']: self.assertEqual(metric['_source']['origin'], 'unit_test')
def test_with_origin(self): with settings(origin="unit_test"): go() for metric in self._query_backend(go.get_fqn())["hits"]["hits"]: self.assertEqual(metric["_source"]["origin"], "unit_test")
def test_with_origin(self): with settings(origin='unit_test'): go() for metric in self._query_backend(): assert metric.value['origin'] == 'unit_test'
def test_duration_field(self): with settings(duration_field='my_duration'): go() for metric in self._query_backend(go.fqn): self.assertTrue('my_duration' in metric)
def test_duration_field(self): with settings(duration_field="my_duration"): go() for metric in self._query_backend(go.fqn): self.assertTrue("my_duration" in metric)
def test_with_origin(self): with settings(origin="unit_test"): go() for metric in self._query_backend(go.fqn): self.assertEqual(metric["origin"], "unit_test")
def test_double_start(self): self.assertEqual(0, self.backend.fetched_items) go() time.sleep(2 * self.qtimeout) self.assertEqual(1, self.backend.fetched_items) # try to double start self.backend.start_worker() self.assertEqual(1, self.backend.fetched_items)
def test_with_arguments(self): go('hello', world='world') Dummy().go('hello', world='world') metrics = self._query_backend() assert len([m for m in metrics if m.value['name'] == get_fqn(go)]) == 1 assert len([m for m in metrics if m.value['name'] == get_fqn(Dummy().go)]) == 1
def test_duration_field(self): configure(backends=[self.backend], duration_field='my_duration') go() for metric in self._query_backend(go.fqn)['hits']['hits']: self.assertTrue('my_duration' in metric['_source'])
def test_with_arguments(self): go('hello', world='world') Dummy().go('hello', world='world') metrics = list(self._query_backend(go.fqn)) self.assertEqual(len(metrics), 1) metrics = list(self._query_backend(Dummy().go.fqn)) self.assertEqual(len(metrics), 1)
def test_with_arguments(self): go('hello', world='world') Dummy().go('hello', world='world') metrics = self._query_backend(go.fqn) self.assertEqual(metrics['hits']['total'], 1) metrics = self._query_backend(Dummy().go.fqn) self.assertEqual(metrics['hits']['total'], 1)
def test_with_arguments(self): go('hello', world='world') Dummy().go('hello', world='world') metrics = list(self._query_backend(get_fqn(go))) self.assertEqual(len(metrics), 1) metrics = list(self._query_backend(get_fqn(Dummy().go))) self.assertEqual(len(metrics), 1)
def test_with_arguments(self): go("hello", world="world") Dummy().go("hello", world="world") metrics = list(self._query_backend(get_fqn(go))) self.assertEqual(len(metrics), 1) metrics = list(self._query_backend(get_fqn(Dummy().go))) self.assertEqual(len(metrics), 1)
def test_with_arguments(self): go("hello", world="world") Dummy().go("hello", world="world") metrics = self._query_backend(get_fqn(go)) self.assertEqual(metrics["hits"]["total"], 1) metrics = self._query_backend(get_fqn(Dummy().go)) self.assertEqual(metrics["hits"]["total"], 1)
def test_time_execution(self): count = 4 for i in range(count): go() metrics = list(self._query_backend(go.fqn)) self.assertEqual(len(metrics), count) for metric in metrics: self.assertTrue('value' in metric)
def test_time_execution(self): count = 4 for i in range(count): go() metrics = self._query_backend(go.fqn) self.assertEqual(metrics['hits']['total'], count) for metric in metrics['hits']['hits']: self.assertTrue('value' in metric['_source'])
def test_pipeline_present(self, mocked_index): backend = ElasticsearchBackend(ELASTICSEARCH_HOST, index="pipelinetest", pipeline="custom-pipeline") with settings(backends=[backend]): go() assert "pipeline" in mocked_index.call_args.kwargs assert mocked_index.call_args.kwargs[ "pipeline"] == "custom-pipeline" ElasticTestMixin._clear(backend)
def test_hook_func_kwargs(self): param = "foo" @time_execution def go(param1): return "200 OK" def hook(response, exception, metric, func, func_args, func_kwargs): assert func_kwargs["param1"] == param with settings(hooks=[hook]): go(param1=param)
def test_hook_func_kwargs(self): param = 'foo' @time_execution def go(param1): return '200 OK' def hook(response, exception, metric, func_args, func_kwargs): self.assertEqual(func_kwargs['param1'], param) with settings(hooks=[hook]): go(param1=param)
def test_hook_func_kwargs(self): param = 'foo' @time_execution def go(param1): return '200 OK' def hook(response, exception, metric, func_args, func_kwargs): assert func_kwargs['param1'] == param with settings(hooks=[hook]): go(param1=param)
def test_time_execution(self): count = 4 for i in range(count): go() metrics = self._query_backend() assert len(metrics) == count for metric in metrics: assert metric.value
def test_hook_func_args(self): param = 'foo' @time_execution def go(param1): return '200 OK' def hook(response, exception, metric, func_args, func_kwargs): self.assertEqual(func_args[0], param) with settings(hooks=[hook]): go(param)
def test_decorator(self): with freeze_time('2016-08-01 00:00:00'): go() # ensure worker thread catches up time.sleep(2 * self.backend.bulk_timeout) mocked_write = self.mocked_backend.bulk_write self.assertEqual(1, self.backend.fetched_items) mocked_write.assert_called_with([{ 'timestamp': datetime(2016, 8, 1, 0, 0), 'hostname': SHORT_HOSTNAME, 'name': 'tests.conftest.go', 'value': 0.0, }])
def test_hook_func_args(self): param = 'foo' def hook(response, exception, metric, func_args, func_kwargs): self.assertEqual(func_args[0], param) configure(hooks=[hook]) @time_execution def go(param1): return '200 OK' go(param)
def test_hook_func_kwargs(self): param = 'foo' def hook(response, exception, metric, func_args, func_kwargs): self.assertEqual(func_kwargs['param1'], param) configure(hooks=[hook]) @time_execution def go(param1): return '200 OK' go(param1=param)
def test_worker_sends_remainder(self): self.stop_worker() self.mocked_backend.bulk_write.side_effect = RuntimeError('mock') loops_count = 3 self.assertTrue(loops_count < self.backend.bulk_size) for _ in range(loops_count): go() self.backend.worker_limit = loops_count self.backend.worker() self.assertEqual(loops_count, self.backend.fetched_items) mocked_bulk_write = self.mocked_backend.bulk_write mocked_bulk_write.assert_called_once() self.assertEqual(loops_count, len(mocked_bulk_write.call_args[0][0]))
def test_time_execution(self): count = 4 for i in range(count): go() metrics = self._query_backend(go.get_fqn()) self.assertEqual(metrics["hits"]["total"], count) for metric in metrics["hits"]["hits"]: self.assertTrue("value" in metric["_source"]) self.assertFalse("origin" in metric["_source"])
def test_hook(self): def test_args(**kwargs): self.assertIn('response', kwargs) self.assertIn('exception', kwargs) self.assertIn('metric', kwargs) return dict() def test_metadata(*args, **kwargs): return dict(test_key='test value') with settings(hooks=[test_args, test_metadata]): go() for metric in self._query_backend(): assert metric.value['test_key'] == 'test value'
def test_hook(self): def test_args(**kwargs): self.assertIn("response", kwargs) self.assertIn("exception", kwargs) self.assertIn("metric", kwargs) return dict() def test_metadata(*args, **kwargs): return dict(test_key="test value") with settings(hooks=[test_args, test_metadata]): go() for metric in self._query_backend(go.get_fqn())["hits"]["hits"]: self.assertEqual(metric["_source"]["test_key"], "test value")
def test_decorator(self): now = datetime.now() with freeze_time(now): go() # ensure worker thread catches up time.sleep(2 * self.backend.bulk_timeout) mocked_write = self.mocked_backend.bulk_write self.assertEqual(1, self.backend.fetched_items) mocked_write.assert_called_with([{ 'timestamp': now, 'hostname': SHORT_HOSTNAME, 'name': 'tests.conftest.go', 'value': 0.0, }])
def test_hook(self): def test_args(**kwargs): self.assertIn('response', kwargs) self.assertIn('exception', kwargs) self.assertIn('metric', kwargs) return dict() def test_metadata(*args, **kwargs): return dict(test_key='test value') with settings(hooks=[test_args, test_metadata]): go() for metric in self._query_backend(go.fqn)['hits']['hits']: self.assertEqual(metric['_source']['test_key'], 'test value')
def test_hook(self): def test_args(**kwargs): assert 'response' in kwargs assert 'exception' in kwargs assert 'metric' in kwargs return dict() def test_metadata(*args, **kwargs): return dict(test_key='test value') def asserts(name, **data): assert data['test_key'] == 'test value' with settings(backends=[AssertBackend(asserts)], hooks=[test_args, test_metadata]): go()
def test_queue_congestion(self): # assure worker is stopped self.stop_worker() # fill in the queue for _ in range(self.qsize * 2): go() self.assertTrue(self.backend._queue.full()) self.resume_worker(bulk_timeout=self.qtimeout) # wait until all metrics are picked up time.sleep(self.qsize * self.qtimeout) # check that metrics in the queue were sent with bulk_write calls call_args_list = self.mocked_backend.bulk_write.call_args_list self.assertEqual(self.qsize, sum(len(args[0]) for args, _ in call_args_list))
def test_hook(self): def test_args(**kwargs): assert "response" in kwargs assert "exception" in kwargs assert "metric" in kwargs return dict() def test_metadata(*args, **kwargs): return dict(test_key="test value") def asserts(name, **data): assert data["test_key"] == "test value" with settings(backends=[AssertBackend(asserts)], hooks=[test_args, test_metadata]): go()
def test_hook(self): def test_args(**kwargs): self.assertIn("response", kwargs) self.assertIn("exception", kwargs) self.assertIn("metric", kwargs) return dict() def test_metadata(*args, **kwargs): return dict(test_key="test value") with settings(hooks=[test_args, test_metadata]): go() for metric in self._query_backend(go.fqn): self.assertEqual(metric["test_key"], "test value")
def test_hook(self): def test_args(**kwargs): self.assertIn('response', kwargs) self.assertIn('exception', kwargs) self.assertIn('metric', kwargs) return dict() def test_metadata(*args, **kwargs): return dict(test_key='test value') def asserts(name, **data): self.assertEqual(data['test_key'], 'test value') with settings(backends=[AssertBackend(asserts)], hooks=[test_args, test_metadata]): go()
def test_hook(self): def test_args(**kwargs): self.assertIn('response', kwargs) self.assertIn('exception', kwargs) self.assertIn('metric', kwargs) return dict() def test_metadata(*args, **kwargs): return dict(test_key='test value') configure(backends=[self.backend], hooks=[test_args, test_metadata]) go() for metric in self._query_backend(go.fqn): self.assertEqual(metric['test_key'], 'test value')
def test_worker_sends_remainder(self): self.stop_worker() self.mocked_backend.bulk_write.side_effect = RuntimeError('mock') loops_count = 3 self.assertTrue(loops_count < self.backend.bulk_size) for _ in range(loops_count): go() self.backend.worker_limit = loops_count self.backend.worker() self.assertEqual(loops_count, self.backend.fetched_items) mocked_bulk_write = self.mocked_backend.bulk_write mocked_bulk_write.assert_called_once() self.assertEqual( loops_count, len(mocked_bulk_write.call_args[0][0]) )
def test_queue_congestion(self): # assure worker is stopped self.stop_worker() # fill in the queue for _ in range(self.qsize * 2): go() self.assertTrue(self.backend._queue.full()) self.resume_worker(bulk_timeout=self.qtimeout) # wait until all metrics are picked up time.sleep(self.qsize * self.qtimeout) # check that metrics in the queue were sent with bulk_write calls call_args_list = self.mocked_backend.bulk_write.call_args_list self.assertEqual( self.qsize, sum(len(args[0]) for args, _ in call_args_list) )
def test_flush_metrics_when_parent_process_not_alive(self): self.stop_worker() loops = 3 with mock.patch.object(self.backend, 'parent_thread', spec=Thread) as parent_thread: parent_thread.is_alive.return_value = False for _ in range(loops): go() #: do not allow flush metrics before checking if parent_thread is alive self.backend.worker_limit = loops + 1 self.backend.worker() mocked_bulk_write = self.mocked_backend.bulk_write mocked_bulk_write.assert_called_once() self.assertEqual(loops, len(mocked_bulk_write.call_args[0][0]))
def test_hook_exception_args(self): message = 'exception message' class TimeExecutionException(Exception): def __init__(self, msg, required): super(TimeExecutionException, self).__init__(msg) def exception_hook(exception, **kwargs): self.assertIsInstance(exception, TimeExecutionException) return dict(exception_message=str(exception)) def asserts(name, **data): self.assertEqual(data['exception_message'], message) @time_execution def go(): raise TimeExecutionException(message, True) with settings(backends=[AssertBackend(asserts)], hooks=[exception_hook]): with self.assertRaises(TimeExecutionException): go()
def test_duration_field(self): with settings(duration_field='my_duration'): go() for metric in self._query_backend(go.fqn)['hits']['hits']: self.assertTrue('my_duration' in metric['_source'])
def test_write_method(self): go() time.sleep(2 * self.backend.bulk_timeout) metrics = self._query_backend(self.backend.backend, go.fqn) self.assertEqual(metrics['hits']['total'], 1)
def test_write_error(self): self.mocked_backend.write.side_effect = RuntimeError('mocked') go() time.sleep(2 * self.qtimeout)