diff options
Diffstat (limited to 'tests/test_parser.py')
| -rw-r--r-- | tests/test_parser.py | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/tests/test_parser.py b/tests/test_parser.py new file mode 100644 index 0000000..f207a22 --- /dev/null +++ b/tests/test_parser.py @@ -0,0 +1,188 @@ +from __future__ import unicode_literals + +import unittest + +from prometheus_client.core import * +from prometheus_client.exposition import * +from prometheus_client.parser import * + + +class TestParse(unittest.TestCase): + + def test_simple_counter(self): + families = text_string_to_metric_families("""# TYPE a counter +# HELP a help +a 1 +""") + self.assertEqual([CounterMetricFamily("a", "help", value=1)], list(families)) + + def test_simple_gauge(self): + families = text_string_to_metric_families("""# TYPE a gauge +# HELP a help +a 1 +""") + self.assertEqual([GaugeMetricFamily("a", "help", value=1)], list(families)) + + def test_simple_summary(self): + families = text_string_to_metric_families("""# TYPE a summary +# HELP a help +a_count 1 +a_sum 2 +""") + + def test_summary_quantiles(self): + families = text_string_to_metric_families("""# TYPE a summary +# HELP a help +a_count 1 +a_sum 2 +a{quantile="0.5"} 0.7 +""") + # The Python client doesn't support quantiles, but we + # still need to be able to parse them. + metric_family = SummaryMetricFamily("a", "help", count_value=1, sum_value=2) + metric_family.add_sample("a", {"quantile": "0.5"}, 0.7) + self.assertEqual([metric_family], list(families)) + + def test_simple_histogram(self): + families = text_string_to_metric_families("""# TYPE a histogram +# HELP a help +a_bucket{le="1"} 0 +a_bucket{le="+Inf"} 3 +a_count 3 +a_sum 2 +""") + self.assertEqual([HistogramMetricFamily("a", "help", sum_value=2, buckets=[("1", 0.0), ("+Inf", 3.0)])], list(families)) + + def test_no_metadata(self): + families = text_string_to_metric_families("""a 1 +""") + metric_family = Metric("a", "", "untyped") + metric_family.add_sample("a", {}, 1) + self.assertEqual([metric_family], list(families)) + + def test_type_help_switched(self): + families = text_string_to_metric_families("""# HELP a help +# TYPE a counter +a 1 +""") + self.assertEqual([CounterMetricFamily("a", "help", value=1)], list(families)) + + def test_blank_lines_and_comments(self): + families = text_string_to_metric_families(""" +# TYPE a counter +# FOO a +# BAR b +# HELP a help + +a 1 +""") + self.assertEqual([CounterMetricFamily("a", "help", value=1)], list(families)) + + def test_tabs(self): + families = text_string_to_metric_families("""#\tTYPE\ta\tcounter +#\tHELP\ta\thelp +a\t1 +""") + self.assertEqual([CounterMetricFamily("a", "help", value=1)], list(families)) + + def test_empty_help(self): + families = text_string_to_metric_families("""# TYPE a counter +# HELP a +a 1 +""") + self.assertEqual([CounterMetricFamily("a", "", value=1)], list(families)) + + def test_labels_and_infinite(self): + families = text_string_to_metric_families("""# TYPE a counter +# HELP a help +a{foo="bar"} +Inf +a{foo="baz"} -Inf +""") + metric_family = CounterMetricFamily("a", "help", labels=["foo"]) + metric_family.add_metric(["bar"], core._INF) + metric_family.add_metric(["baz"], core._MINUS_INF) + self.assertEqual([metric_family], list(families)) + + def test_spaces(self): + families = text_string_to_metric_families("""# TYPE a counter +# HELP a help +a{ foo = "bar" } 1 +a\t\t{\t\tfoo\t\t=\t\t"baz"\t\t}\t\t2 +""") + metric_family = CounterMetricFamily("a", "help", labels=["foo"]) + metric_family.add_metric(["bar"], 1) + metric_family.add_metric(["baz"], 2) + self.assertEqual([metric_family], list(families)) + + def test_nan(self): + families = text_string_to_metric_families("""a NaN +""") + # Can't use a simple comparison as nan != nan. + self.assertTrue(math.isnan(list(families)[0].samples[0][2])) + + def test_escaping(self): + families = text_string_to_metric_families("""# TYPE a counter +# HELP a he\\n\\\\l\\tp +a{foo="b\\"a\\nr"} 1 +a{foo="b\\\\a\\z"} 2 +""") + metric_family = CounterMetricFamily("a", "he\n\\l\\tp", labels=["foo"]) + metric_family.add_metric(["b\"a\nr"], 1) + metric_family.add_metric(["b\\a\\z"], 2) + self.assertEqual([metric_family], list(families)) + + def test_roundtrip(self): + text = """# HELP go_gc_duration_seconds A summary of the GC invocation durations. +# TYPE go_gc_duration_seconds summary +go_gc_duration_seconds{quantile="0"} 0.013300656000000001 +go_gc_duration_seconds{quantile="0.25"} 0.013638736 +go_gc_duration_seconds{quantile="0.5"} 0.013759906 +go_gc_duration_seconds{quantile="0.75"} 0.013962066 +go_gc_duration_seconds{quantile="1"} 0.021383540000000003 +go_gc_duration_seconds_sum 56.12904785 +go_gc_duration_seconds_count 7476.0 +# HELP go_goroutines Number of goroutines that currently exist. +# TYPE go_goroutines gauge +go_goroutines 166.0 +# HELP prometheus_local_storage_indexing_batch_duration_milliseconds Quantiles for batch indexing duration in milliseconds. +# TYPE prometheus_local_storage_indexing_batch_duration_milliseconds summary +prometheus_local_storage_indexing_batch_duration_milliseconds{quantile="0.5"} NaN +prometheus_local_storage_indexing_batch_duration_milliseconds{quantile="0.9"} NaN +prometheus_local_storage_indexing_batch_duration_milliseconds{quantile="0.99"} NaN +prometheus_local_storage_indexing_batch_duration_milliseconds_sum 871.5665949999999 +prometheus_local_storage_indexing_batch_duration_milliseconds_count 229.0 +# HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. +# TYPE process_cpu_seconds_total counter +process_cpu_seconds_total 29323.4 +# HELP process_virtual_memory_bytes Virtual memory size in bytes. +# TYPE process_virtual_memory_bytes gauge +process_virtual_memory_bytes 2478268416.0 +# HELP prometheus_build_info A metric with a constant '1' value labeled by version, revision, and branch from which Prometheus was built. +# TYPE prometheus_build_info gauge +prometheus_build_info{branch="HEAD",revision="ef176e5",version="0.16.0rc1"} 1.0 +# HELP prometheus_local_storage_chunk_ops_total The total number of chunk operations by their type. +# TYPE prometheus_local_storage_chunk_ops_total counter +prometheus_local_storage_chunk_ops_total{type="clone"} 28.0 +prometheus_local_storage_chunk_ops_total{type="create"} 997844.0 +prometheus_local_storage_chunk_ops_total{type="drop"} 1345758.0 +prometheus_local_storage_chunk_ops_total{type="load"} 1641.0 +prometheus_local_storage_chunk_ops_total{type="persist"} 981408.0 +prometheus_local_storage_chunk_ops_total{type="pin"} 32662.0 +prometheus_local_storage_chunk_ops_total{type="transcode"} 980180.0 +prometheus_local_storage_chunk_ops_total{type="unpin"} 32662.0 +""" + families = list(text_string_to_metric_families(text)) + + class TextCollector(object): + def collect(self): + return families + + + registry = CollectorRegistry() + registry.register(TextCollector()) + self.assertEqual(text.encode('utf-8'), generate_latest(registry)) + + + +if __name__ == '__main__': + unittest.main() |