Improved test method naming

Author: lucasimi

tests/test_bench_cover.py

@@ -41,7 +41,7 @@ def run(X, r, dist, vp, **kwargs):
 
 class TestVpSettings(unittest.TestCase):
 
-    def testCoverRandom(self):
+    def test_cover_random(self):
         for r in [1.0, 10.0, 100.0]:
             for n in [100, 1000, 10000]:
                 print(f'============= n: {n}, r: {r} =============')
@@ -57,7 +57,7 @@ def testCoverRandom(self):
                 run(X, r, dist, SkBallTree, leaf_radius=r)
                 print('')
 
-    def testCoverDigits(self):
+    def test_cover_digits(self):
         X, _ = load_digits(return_X_y=True)
         #X = PCA(n_components=3).fit_transform(X)
         for r in [1.0, 10.0, 100.0]:

tests/test_core.py

@@ -18,7 +18,7 @@ def dataset(dim=10, num=1000):
 
 class TestMapper(unittest.TestCase):
 
-    def testTrivial(self):
+    def test_trivial(self):
         data = dataset()
         mp = MapperAlgorithm(TrivialCover(), TrivialClustering())
         g = mp.fit_transform(data, data)
@@ -29,7 +29,7 @@ def testTrivial(self):
         ccs2 = mapper_connected_components(data, data, TrivialCover(), TrivialClustering())
         self.assertEqual(len(data), len(ccs2))
 
-    def testBallSmallRadius(self):
+    def test_ball_small_radius(self):
         data = np.array([[float(i)] for i in range(1000)])
         cover = BallCover(0.5, metric=dist)
         clustering = TrivialClustering()
@@ -43,7 +43,7 @@ def testBallSmallRadius(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def testBallSmallRadiusList(self):
+    def test_ball_small_radius_list(self):
         data = [np.array([float(i)]) for i in range(1000)]
         cover = BallCover(0.5, metric=dist)
         clustering = DBSCAN(eps=1.0, min_samples=1)
@@ -59,7 +59,7 @@ def testBallSmallRadiusList(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def testBallLargeRadius(self):
+    def test_ball_large_radius(self):
         data = np.array([[float(i)] for i in range(1000)])
         cover = BallCover(1000.0, metric=dist)
         clustering = TrivialClustering()
@@ -75,7 +75,7 @@ def testBallLargeRadius(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def testTwoDisconnectedClusters(self):
+    def test_two_disconnected_clusters(self):
         data = [np.array([float(i), 0.0]) for i in range(100)]
         data.extend([np.array([float(i), 500.0]) for i in range(100)])
         data = np.array(data)
@@ -93,7 +93,7 @@ def testTwoDisconnectedClusters(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def testTwoConnectedClusters(self):
+    def test_two_connected_clusters(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.0, 0.0]),
             np.array([0.0, 0.0]), np.array([1.0, 1.0])]
@@ -111,7 +111,7 @@ def testTwoConnectedClusters(self):
         ccs2 = mapper_connected_components(data, data, cover, clustering)
         self.assertEqual(len(data), len(ccs2))
 
-    def testCCS(self):
+    def test_connected_components(self):
         data = [0, 1, 2, 3]
 
         class MockCover:
@@ -131,7 +131,7 @@ def apply(self, X):
         self.assertEqual(cc0, ccs[2])
         self.assertEqual(cc0, ccs[3])
 
-    def testLabels(self):
+    def test_labels(self):
         data = [0, 1, 2, 3]
 
         class MockCover:

tests/test_cover.py

@@ -10,39 +10,35 @@
 )
 
 
-def dist(x, y):
-    return np.linalg.norm(x - y)
-
-
 def dataset(dim=1, num=10000):
     return [np.random.rand(dim) for _ in range(num)]
 
 
 class TestCover(unittest.TestCase):
 
-    def testTrivialCover(self):
+    def test_trivial_cover(self):
         data = dataset()
         cover = TrivialCover()
         charts = list(cover.apply(data))
         self.assertEqual(1, len(charts))
 
-    def testBallCoverSimple(self):
+    def test_ball_cover_simple(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.0, 0.0]),
             np.array([0.0, 0.0]), np.array([1.0, 1.0])]
-        cover = BallCover(radius=1.1, metric=dist)
+        cover = BallCover(radius=1.1, metric='euclidean')
         charts = list(cover.apply(data))
         self.assertEqual(2, len(charts))
 
-    def testKNNCoverSimple(self):
+    def test_knn_cover_simple(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.1, 0.0]),
             np.array([0.0, 0.0]), np.array([1.1, 1.0])]
-        cover = KNNCover(neighbors=2, metric=dist)
+        cover = KNNCover(neighbors=2, metric='euclidean')
         charts = list(cover.apply(data))
         self.assertEqual(2, len(charts))
 
-    def testCubicalCoverSimple(self):
+    def test_cubical_cover_simple(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.1, 0.0]),
             np.array([0.0, 0.0]), np.array([1.1, 1.0])]

tests/test_heap.py

@@ -13,18 +13,18 @@ def maxheap(data):
 
 class TestMaxHeap(unittest.TestCase):
 
-    def testEmpty(self):
+    def test_empty(self):
         m = MaxHeap()
         self.assertEqual(0, len(m))
 
-    def testMax(self):
+    def test_max(self):
         data = list(range(10))
         random.shuffle(data)
         m = maxheap(data)
         self.assertEqual((9, 9), m.top())
         self.assertEqual(10, len(m))
 
-    def testMaxRandom(self):
+    def test_max_random(self):
         data = random.sample(list(range(1000)), 100)
         m = maxheap(data)
         self.assertEqual(100, len(m))

tests/test_knn.py

@@ -2,6 +2,7 @@
 import numpy as np
 
 from tdamapper.proximity import KNNProximity
+from tdamapper.utils.metrics import euclidean
 from tdamapper.utils.vptree_flat import VPTree
 
 
@@ -92,34 +93,33 @@
 x = np.array([ 99.73199663, 100.8024564 ])
 
 
-def euclidean(x, y):
-    return np.linalg.norm(x - y)
-
-
 class TestKNN(unittest.TestCase):
 
-    def testKNNSearch(self):
-        knn_prox = KNNProximity(neighbors=5, metric=euclidean)
+    def test_knn_search(self):
+        knn_prox = KNNProximity(neighbors=5, metric='euclidean')
         knn_prox.fit(X)
         neigh_ids = knn_prox.search(x)
-        dists = [euclidean(x, X[j]) for j in neigh_ids]
-        x_dist = euclidean(x, X[5])
+        d = euclidean()
+        dists = [d(x, X[j]) for j in neigh_ids]
+        x_dist = d(x, X[5])
         self.assertTrue(x_dist in dists)
 
-    def testVPTree(self):
-        vptree = VPTree(X[:80], metric=euclidean, leaf_capacity=5)
+    def test_vptree(self):
+        vptree = VPTree(X[:80], metric='euclidean', leaf_capacity=5)
         neigh = vptree.knn_search(x, 5)
-        dists = [euclidean(x, y) for y in neigh]
-        x_dist = euclidean(x, X[5])
+        d = euclidean()
+        dists = [d(x, y) for y in neigh]
+        x_dist = d(x, X[5])
         self.check_vptree(vptree)
         self.assertTrue(x_dist in dists)
 
-    def testVPTreeSimple(self):
+    def test_vptree_simple(self):
         XX = np.array([np.array([x, x/2]) for x in range(30)])
-        vptree = VPTree(XX, metric=euclidean, leaf_capacity=5, leaf_radius=0.0)
+        vptree = VPTree(XX, metric='euclidean', leaf_capacity=5, leaf_radius=0.0)
         xx = np.array([3, 3/2])
         neigh = vptree.knn_search(xx, 2)
-        dists = [euclidean(xx, y) for y in neigh]
+        d = euclidean()
+        dists = [d(xx, y) for y in neigh]
         self.check_vptree(vptree)
         self.assertTrue(0.0 in dists)
 
@@ -138,7 +138,7 @@ def check_sub(start, end):
                 _, y = data[i]
                 self.assertTrue(dist(v_point, y) >= v_radius)
         def check_rec(start, end):
-            v_radius, v_point = data[start]
+            v_radius, _ = data[start]
             if (end - start > leaf_capacity) and (v_radius > leaf_radius):
                 check_sub(start, end)
                 mid = (start + end) // 2

tests/test_plot.py

@@ -8,17 +8,13 @@
 from tdamapper.plot import MapperLayoutInteractive, MapperLayoutStatic
 
 
-def dist(x, y):
-    return np.linalg.norm(x - y)
-
-
 class TestMapperPlot(unittest.TestCase):
 
-    def testTwoConnectedClusters(self):
+    def test_two_connected_clusters(self):
         data = [
             np.array([0.0, 1.0]), np.array([1.0, 0.0]),
             np.array([0.0, 0.0]), np.array([1.0, 1.0])]
-        mp = MapperAlgorithm(cover=BallCover(1.1, metric=dist),
+        mp = MapperAlgorithm(cover=BallCover(1.1, metric='euclidean'),
             clustering=TrivialClustering())
         g = mp.fit_transform(data, data)
         mp_plot1 = MapperLayoutInteractive(g, dim=2,

tests/test_proximity.py

@@ -10,17 +10,13 @@
 )
 
 
-def dist(x, y):
-    return np.linalg.norm(x - y)
-
-
 def dataset(dim=1, num=10000):
     return [np.random.rand(dim) for _ in range(num)]
 
 
 class TestProximity(unittest.TestCase):
 
-    def testBallProximity(self):
+    def test_ball_proximity(self):
         data = list(range(100))
         prox = BallProximity(radius=10, metric=lambda x,y: abs(x - y))
         prox.fit(data)
@@ -29,7 +25,7 @@ def testBallProximity(self):
             expected = [y for y in data if abs(x - y) <= 10]
             self.assertEqual(len(expected), len(result))
 
-    def testKNNProximity(self):
+    def test_knn_proximity(self):
         data = list(range(100))
         prox = KNNProximity(neighbors=11, metric=lambda x,y: abs(x - y))
         prox.fit(data)
@@ -38,7 +34,7 @@ def testKNNProximity(self):
             expected = [x + i for i in range(-5, 6)]
             self.assertEqual(set(expected), set(result))
 
-    def testCubicalProximity(self):
+    def test_cubical_proximity(self):
         m, M = 0, 99
         n = 10
         p = 0.1

tests/test_readme.py

@@ -3,5 +3,5 @@
 
 class TestReadme(unittest.TestCase):
 
-    def testRun(self):
+    def test_run(self):
         import tests.example

tests/test_sklearn.py

@@ -97,17 +97,17 @@ def get_clustering(self):
 
 class TestSklearn(unittest.TestCase):
 
-    def testClustering(self):
+    def test_clustering(self):
         check_estimator(TrivialClusteringEstimator())
 
-    def testBall(self):
+    def test_ball(self):
         check_estimator(MapperClusteringEstimator(cover='ball'))
 
-    def testKNN(self):
+    def test_knn(self):
         check_estimator(MapperClusteringEstimator(cover='knn'))
 
-    def testCubical(self):
+    def test_cubical(self):
         check_estimator(MapperClusteringEstimator())
 
-    def testPermissive(self):
+    def test_permissive(self):
         check_estimator(PermissiveKMeans())

tests/test_unionfind.py

@@ -5,7 +5,7 @@
 
 class TestUnionFind(unittest.TestCase):
 
-    def testList(self):
+    def test_list(self):
         data = [1, 2, 3, 4]
         uf = UnionFind(data)
         for i in data: