Use pytest assertions

pytest monkeypatches the assert statement to make error messages much
friendlier.

tests/test_ddsketch.py

@@ -10,6 +10,7 @@
 from unittest import TestCase
 
 import numpy as np
+import pytest
 import six
 
 import ddsketch
@@ -78,11 +79,11 @@ def _evaluate_sketch_accuracy(self, sketch, data, eps, summary_stats=True):
             sketch_q = sketch.get_quantile_value(quantile)
             data_q = data.quantile(quantile)
             err = abs(sketch_q - data_q)
-            self.assertTrue(err - eps * abs(data_q) <= 1e-15)
-        self.assertEqual(sketch.num_values, size)
+            assert err - eps * abs(data_q) <= 1e-15
+        assert sketch.num_values == size
         if summary_stats:
-            self.assertAlmostEqual(sketch.sum, data.sum)
-            self.assertAlmostEqual(sketch.avg, data.avg)
+            assert sketch.sum == pytest.approx(data.sum)
+            assert sketch.avg == pytest.approx(data.avg)
 
     def test_distributions(self):
         """Test DDSketch on values from various distributions"""
@@ -112,10 +113,10 @@ def test_add_decimal(self):
         data_median = 99
         sketch_median = sketch.get_quantile_value(0.5)
         err = abs(sketch_median - data_median)
-        self.assertTrue(err - TEST_REL_ACC * abs(data_median) <= 1e-15)
-        self.assertAlmostEqual(sketch.num_values, 110 * 2)
-        self.assertAlmostEqual(sketch.sum, 5445 + 11000)
-        self.assertAlmostEqual(sketch.avg, 74.75)
+        assert err - TEST_REL_ACC * abs(data_median) <= 1e-15
+        assert sketch.num_values == pytest.approx(110 * 2)
+        assert sketch.sum == pytest.approx(5445 + 11000)
+        assert sketch.avg == pytest.approx(74.75)
 
     def test_merge_equal(self):
         """Test merging equal-sized DDSketches"""
@@ -175,7 +176,7 @@ def test_consistent_merge(self):
             sketch1.add(value)
         sketch1.merge(sketch2)
         # sketch2 is still empty
-        self.assertEqual(sketch2.num_values, 0)
+        assert sketch2.num_values == 0
 
         dataset = Normal(50)
         for value in dataset.data:
@@ -197,17 +198,15 @@ def test_consistent_merge(self):
             sketch2.avg,
             sketch2.num_values,
         ]
-        self.assertAlmostEqual(
-            sketch2_summary,
+        assert sketch2_summary == pytest.approx(
             [sketch2.get_quantile_value(q) for q in TEST_QUANTILES]
             + [sketch2.sum, sketch2.avg, sketch2.num_values],
         )
 
         sketch3 = self._new_dd_sketch()
         sketch3.merge(sketch2)
         # merging to an empty sketch does not change sketch2
-        self.assertAlmostEqual(
-            sketch2_summary,
+        assert sketch2_summary == pytest.approx(
             [sketch2.get_quantile_value(q) for q in TEST_QUANTILES]
             + [sketch2.sum, sketch2.avg, sketch2.num_values],
         )

tests/test_mapping.py

@@ -33,7 +33,7 @@ def _relative_error(expected_min, expected_max, actual):
     return (actual - expected_max) / expected_max
 
 
-def _test_value_rel_acc(mapping, tester):
+def _test_value_rel_acc(mapping):
     """Calculate the relative accuracy of a mapping on a large range of values"""
     value_mult = 2 - math.sqrt(2) * 1e-1
     max_relative_acc = 0.0
@@ -42,7 +42,7 @@ def _test_value_rel_acc(mapping, tester):
         value *= value_mult
         map_val = mapping.value(mapping.key(value))
         rel_err = _relative_error(value, value, map_val)
-        tester.assertLess(rel_err, mapping.relative_accuracy)
+        assert rel_err < mapping.relative_accuracy
         max_relative_acc = max(max_relative_acc, rel_err)
     max_relative_acc = max(
         max_relative_acc,
@@ -72,15 +72,15 @@ def test_accuracy(self):
 
         while rel_acc >= min_rel_acc:
             mapping = self.mapping(rel_acc, offset=0.0)
-            max_rel_acc = _test_value_rel_acc(mapping, self)
-            self.assertLess(max_rel_acc, mapping.relative_accuracy)
+            max_rel_acc = _test_value_rel_acc(mapping)
+            assert max_rel_acc < mapping.relative_accuracy
             rel_acc *= rel_acc_mult
 
     def test_offsets(self):
         """Test offsets"""
         for offset in self.offsets:
             mapping = self.mapping(0.01, offset=offset)
-            self.assertEqual(mapping.key(1), int(offset))
+            assert mapping.key(1) == int(offset)
 
 
 class TestLogarithmicMapping(BaseTestKeyMapping, TestCase):

tests/test_proto.py

@@ -1,6 +1,7 @@
 import abc
 from unittest import TestCase
 
+import pytest
 import six
 
 from ddsketch.mapping import CubicallyInterpolatedMapping
@@ -25,11 +26,11 @@ def test_round_trip(self):
                 round_trip_mapping = KeyMappingProto.from_proto(
                     KeyMappingProto.to_proto(mapping)
                 )
-                self.assertEqual(type(mapping), type(round_trip_mapping))
-                self.assertAlmostEqual(
-                    mapping.relative_accuracy, round_trip_mapping.relative_accuracy
+                assert type(mapping) == type(round_trip_mapping)
+                assert mapping.relative_accuracy == pytest.approx(
+                    round_trip_mapping.relative_accuracy
                 )
-                self.assertAlmostEqual(mapping.value(0), round_trip_mapping.value(0))
+                assert mapping.value(0) == pytest.approx(round_trip_mapping.value(0))
 
 
 class TestLogarithmicMapping(BaseTestKeyMappingProto, TestCase):

tests/test_store.py

@@ -121,15 +121,15 @@ def test_copying_empty(self):
         """Test copying empty stores"""
         store = CollapsingLowestDenseStore(10)
         store.copy(CollapsingLowestDenseStore(10))
-        self.assertEqual(store.count, 0)
+        assert store.count == 0
 
     def test_copying_non_empty(self):
         """Test copying stores"""
         store = CollapsingLowestDenseStore(10)
         new_store = CollapsingLowestDenseStore(10)
         new_store.add(0)
         store.copy(new_store)
-        self.assertEqual(store.count, 1)
+        assert store.count == 1
 
 
 class TestDenseStore(BaseTestStore, TestCase):
@@ -139,16 +139,16 @@ def _test_values(self, store, values):
         counter = Counter(values)
 
         expected_total_count = sum(counter.values())
-        self.assertEqual(expected_total_count, sum(store.bins))
+        assert expected_total_count == sum(store.bins)
         if expected_total_count == 0:
-            self.assertTrue(all([x == 0 for x in store.bins]))
+            assert all([x == 0 for x in store.bins])
         else:
-            self.assertFalse(all([x == 0 for x in store.bins]))
+            assert not all([x == 0 for x in store.bins])
 
             counter = Counter(values)
             for i, sbin in enumerate(store.bins):
                 if sbin != 0:
-                    self.assertEqual(counter[i + store.offset], sbin)
+                    assert counter[i + store.offset] == sbin
 
     def _test_store(self, values):
         store = DenseStore()
@@ -174,18 +174,18 @@ def test_key_at_rank(self):
         store.add(4)
         store.add(10)
         store.add(100)
-        self.assertEqual(store.key_at_rank(0), 4)
-        self.assertEqual(store.key_at_rank(1), 10)
-        self.assertEqual(store.key_at_rank(2), 100)
-        self.assertEqual(store.key_at_rank(0, lower=False), 4)
-        self.assertEqual(store.key_at_rank(1, lower=False), 10)
-        self.assertEqual(store.key_at_rank(2, lower=False), 100)
-        self.assertEqual(store.key_at_rank(0.5), 4)
-        self.assertEqual(store.key_at_rank(1.5), 10)
-        self.assertEqual(store.key_at_rank(2.5), 100)
-        self.assertEqual(store.key_at_rank(-0.5, lower=False), 4)
-        self.assertEqual(store.key_at_rank(0.5, lower=False), 10)
-        self.assertEqual(store.key_at_rank(1.5, lower=False), 100)
+        assert store.key_at_rank(0) == 4
+        assert store.key_at_rank(1) == 10
+        assert store.key_at_rank(2) == 100
+        assert store.key_at_rank(0, lower=False) == 4
+        assert store.key_at_rank(1, lower=False) == 10
+        assert store.key_at_rank(2, lower=False) == 100
+        assert store.key_at_rank(0.5) == 4
+        assert store.key_at_rank(1.5) == 10
+        assert store.key_at_rank(2.5) == 100
+        assert store.key_at_rank(-0.5, lower=False) == 4
+        assert store.key_at_rank(0.5, lower=False) == 10
+        assert store.key_at_rank(1.5, lower=False) == 100
 
     def test_extreme_values(self):
         """Override. DenseStore is not meant to be used with values that are extremely
@@ -206,20 +206,20 @@ class TestCollapsingLowestDenseStore(BaseTestStore, TestCase):
     def _test_values(self, store, values):
         counter = Counter(values)
         expected_total_count = sum(counter.values())
-        self.assertEqual(expected_total_count, sum(store.bins))
+        assert expected_total_count == sum(store.bins)
 
         if expected_total_count == 0:
-            self.assertTrue(all([x == 0 for x in store.bins]))
+            assert all([x == 0 for x in store.bins])
         else:
-            self.assertFalse(all([x == 0 for x in store.bins]))
+            assert not all([x == 0 for x in store.bins])
 
             max_index = max(counter)
             min_storable_index = max(float("-inf"), max_index - store.bin_limit + 1)
             counter = Counter([max(x, min_storable_index) for x in values])
 
             for i, sbin in enumerate(store.bins):
                 if sbin != 0:
-                    self.assertEqual(counter[i + store.offset], sbin)
+                    assert counter[i + store.offset] == sbin
 
     def _test_store(self, values):
         for bin_limit in TEST_BIN_LIMIT:
@@ -248,19 +248,19 @@ def _test_values(self, store, values):
         counter = Counter(values)
 
         expected_total_count = sum(counter.values())
-        self.assertEqual(expected_total_count, sum(store.bins))
+        assert expected_total_count == sum(store.bins)
         if expected_total_count == 0:
-            self.assertTrue(all([x == 0 for x in store.bins]))
+            assert all([x == 0 for x in store.bins])
         else:
-            self.assertFalse(all([x == 0 for x in store.bins]))
+            assert not all([x == 0 for x in store.bins])
 
             min_index = min(counter)
             max_storable_index = min(float("+inf"), min_index + store.bin_limit - 1)
             counter = Counter([min(x, max_storable_index) for x in values])
 
             for i, sbin in enumerate(store.bins):
                 if sbin != 0:
-                    self.assertEqual(counter[i + store.offset], sbin)
+                    assert counter[i + store.offset] == sbin
 
     def _test_store(self, values):
         for bin_limit in TEST_BIN_LIMIT[1:2]: