refactor tests for new code

Author: zero2cx

spiral_matrix/spiral_matrix.py

@@ -74,7 +74,7 @@ class SpiralMatrix():
     }
 
     def __init__(self, dimension=None, bearing='E', turn=False,
-            start=1, step=1, filename=None, words=None, test=False):
+            start=1, step=1, filename=None, words=None, testing=False):
         '''
         Generate a new instance of SpiralMatrix.
 
@@ -101,10 +101,10 @@ def __init__(self, dimension=None, bearing='E', turn=False,
         self.turn = 'right' if turn else 'left'
         self.series = self._series(
                 filename, words, self._start(start), self._step(step))
-        self.width = self._width()
+        self.width = self._width(self.series)
 
         # Build the matrix structure that conforms to the attributes.
-        if not test:
+        if not testing:
             self._build()
 
     def _dimension(self, dimension):
@@ -252,15 +252,13 @@ def _series_from_integers(self, start, step):
 
         return series
 
-    def _width(self):
+    def _width(self, series):
         '''
         Set cell-width for printing, equal to the widest element in the series.
 
         Return the width integer.
         '''
 
-        series = self.series
-
         width = 0
         for i in range(len(series)):
             if len(str(series[i])) > width:

test/test_spiral_matrix.py

@@ -8,9 +8,9 @@
 from spiral_matrix.spiral_matrix import SpiralMatrix
 
 ################################################################################
-class SpiralMatrixInstantiationTestCase(unittest.TestCase):
+class SpiralMatrixTestCase(unittest.TestCase):
 
-    def test_simple_instantiation(self):
+    def test_01_simple_instantiation(self):
 
         pass_configs = [3, 5, 23, 1.21e2, '3']
         for config in pass_configs:
@@ -55,94 +55,81 @@ def test_build(self):
 ################################################################################
 class SpiralMatrixMethodsTestCase(unittest.TestCase):
 
-    def setUp(self):
-
-        self.matrix_dimension = 5
-
-    def test_series(self):
-
-        m = SpiralMatrix(self.matrix_dimension)
+    def test_01_series_from_integers(self):
 
         pass_configs = [
-            { 'start': 1, 'step': 1,
+            { 'dimension': 5, 'start': 1, 'step': 1,
               'want_0_0_value': 17 },
-            { 'start': 1000, 'step': 2,
+            { 'dimension': 5, 'start': 1000, 'step': 2,
               'want_0_0_value': 1032 },
-            { 'start': -100, 'step': 3,
+            { 'dimension': 5, 'start': -100, 'step': 3,
               'want_0_0_value': -52 },
         ]
         for config in pass_configs:
             with self.subTest(config=config):
-                m.start, m.step, want_0_0_value = config.values()
-                m.series = m._series()
+                dimension, start, step, want_0_0_value = config.values()
+                m = SpiralMatrix(dimension)
+                m.series = m._series_from_integers(start, step)
                 self.assertIsInstance(m.series, range)
                 self.assertEqual(len(m.series), m.max)
                 m._build()
                 self.assertEqual(m.matrix[0][0], want_0_0_value)
 
-    def test_series_from_string(self):
-
-        m = SpiralMatrix(self.matrix_dimension)
+    def test_02_series_from_string(self):
 
         pass_configs = [
-            { 'words': 'vulture duck crocodile elephant tiger',
+            { 'dimension': 5, 'words': 'vulture duck crocodile elephant tiger',
               'want_0_0_value': 'duck' },
-            { 'words': '10 4 2 45 31 8.88 22 -7 0 94',
+            { 'dimension': 5, 'words': '10 4 2 45 31 8.88 22 -7 0 94',
               'want_0_0_value': '22' },
-            { 'words': '~ @#$ ) ( !*% +!',
+            { 'dimension': 5, 'words': '~ @#$ ) ( !*% +!',
               'want_0_0_value': '!*%' },
         ]
         for config in pass_configs:
             with self.subTest(config=config):
-                m.words, want_0_0_value = config.values()
-                m.series = m._series_from_string()
+                dimension, words, want_0_0_value = config.values()
+                m = SpiralMatrix(dimension)
+                m.series = m._series_from_string(words)
                 self.assertIsInstance(m.series, list)
                 self.assertEqual(len(m.series), m.max)
                 m._build()
                 self.assertEqual(m.matrix[0][0], want_0_0_value)
 
-    def test_series_from_file(self):
+    def test_03_series_from_file(self):
 
-        m = SpiralMatrix(self.matrix_dimension)
-
-        # import os
-        # file_path = '%s/input' % (os.path.dirname(os.path.abspath(__file__)))
-        # pass_configs = ['tests/input/%s' % (f) for f in os.listdir(file_path)]
+        from os import path
+        cwd = path.dirname(__file__)
 
         pass_configs = [
-            { 'filename': 'test/test-input/5-letter-words.txt',
-              'want_0_0_value': 'alike' },
-            { 'filename': 'test/test-input/3-letter-words.txt',
-              'want_0_0_value': 'alt' },
-            { 'filename': 'test/test-input/lorem-ipsum.txt',
-              'want_0_0_value': 'at.' },
+            { 'filename': f'{cwd}/test-input/3-letter-words.txt',
+              'want_77th_element': 'cam' },
+            { 'filename': f'{cwd}/test-input/5-letter-words.txt',
+              'want_77th_element': 'cable' },
+            { 'filename': f'{cwd}/test-input/lorem-ipsum.txt',
+              'want_77th_element': 'Integer' },
         ]
+
         for config in pass_configs:
             with self.subTest(config=config):
-                filename, want_0_0_value = config.values()
-                with open(filename) as file:
-                    m.file = file
-                    m.series = m._series_from_file()
-                    self.assertIsInstance(m.series, list)
-                    self.assertEqual(len(m.series), m.max)
-                    m._build()
-                    self.assertEqual(m.matrix[0][0], want_0_0_value)
-
-        # fail_configs = [
-        #     { 'filename': 'tests/input/binary.dat' },
-        #     { 'filename': 'tests/input/empty.txt' },
-        # ]
-        # for config in fail_configs:
-        #     with self.subTest(config=config):
-        #         filename, = config.values()
-        #         with open(filename) as file:
-        #             m.file = file
-        #             with self.assertRaises(argparse.ArgumentError):
-        #                 m.series = m._series_from_file()
-
-    def test_width(self):
-
-        m = SpiralMatrix(self.matrix_dimension)
+                filename, want_77th_element = config.values()
+                m = SpiralMatrix(9)
+                series = m._series_from_file(filename)
+                self.assertIsInstance(series, list)
+                self.assertEqual(len(series), m.max)
+                self.assertEqual(series[76], want_77th_element)
+
+        fail_configs = [
+            { 'filename': f'{cwd}/test-input/binary.dat' },
+            { 'filename': f'{cwd}/test-input/empty.txt' },
+        ]
+        for config in fail_configs:
+            with self.subTest(config=config):
+                filename, = config.values()
+                m = SpiralMatrix(3)
+                with self.assertRaises(AttributeError):
+                    series = m._series_from_file(filename)
+
+    def test_04_width(self):
 
         pass_configs = [
             { 'series': ['vulture', 'duck', 'crocodile', 'elephant', 'tiger'],
@@ -152,79 +139,82 @@ def test_width(self):
         ]
         for config in pass_configs:
             with self.subTest(config=config):
-                m.series, want_width = config.values()
-                m.width = m._width()
-                self.assertIsInstance(m.width, int)
-                self.assertEqual(m.width, want_width)
-
-    def test_fill(self):
+                series, want_width = config.values()
+                m = SpiralMatrix(5)
+                width = m._width(series)
+                self.assertIsInstance(width, int)
+                self.assertEqual(width, want_width)
 
-        m = SpiralMatrix(self.matrix_dimension)
+    def test_05_fill(self):
 
         pass_configs = [
-            { 'series': ['vulture', 'duck', 'crocodile', 'elephant', 'tiger'],
-              'index': 2, 'coords': (0, 2) },
+            { 'series': ['emu', 'duck', 'crocodile', 'shark', 'tiger', 'worm'],
+              'index': 12,
+              'want_coords': (1, 4) },
             { 'series': range(30, 50, 2),
-              'index': 7, 'coords': (1, 0) },
+              'index': 21,
+              'want_coords': (4, 0) },
         ]
         for config in pass_configs:
             with self.subTest(config=config):
-                m.series, index, coords = config.values()
-                new_index = m._fill(coords, index)
+                series, index, want_coords = config.values()
+                m = SpiralMatrix(5)
+                m.series = (list(series) * 5)[:m.max]
+                new_index = m._fill(want_coords, index)
                 self.assertIsInstance(new_index, int)
                 self.assertEqual(new_index, index + 1)
-                self.assertEqual(m.matrix[coords[0]][coords[1]],
-                        m.series[index])
-
-    def test_look(self):
+                self.assertEqual(m.series[index],
+                        m.matrix[want_coords[0]][want_coords[1]])
 
-        m = SpiralMatrix(self.matrix_dimension)
+    def test_06_look(self):
 
         pass_configs = [
-            { 'cell': (1, 2), 'bearing': m.N, 'look': 'left',
+            { 'cell': (1, 2), 'bearing': 'N', 'look': 'left',
               'want_cell': (1, 1) },
-            { 'cell': (0, 0), 'bearing': m.E, 'look': 'right',
+            { 'cell': (0, 0), 'bearing': 'E', 'look': 'right',
               'want_cell': (1, 0) },
-            ### TODO: better handle a look outside the matrix. expect error?
-            { 'cell': (0, 1), 'bearing': m.E, 'look': 'left',
+            { 'cell': (0, 1), 'bearing': 'E', 'look': 'left',
               'want_cell': (-1, 1) },
         ]
         for config in pass_configs:
             with self.subTest(config=config):
                 cell, bearing, look, want_cell = config.values()
+                m = SpiralMatrix(5)
+                bearing = m.compass[bearing]
                 y, x = m._look(cell, look, bearing)
                 self.assertEqual(y, want_cell[0])
                 self.assertEqual(x, want_cell[1])
 
-    def test_turn(self):
-
-        m = SpiralMatrix(self.matrix_dimension)
+    def test_07_turn(self):
 
         pass_configs = [
-            { 'cell': (1, 1), 'turn': 'left', 'bearing': m.N,
-              'want_bearing': m.W },
-            { 'cell': (1, 0), 'turn': 'right', 'bearing': m.S,
-              'want_bearing': m.W },
+            { 'cell': (1, 1), 'turn': 'left', 'bearing': 'N',
+              'want_bearing': 'W' },
+            { 'cell': (1, 0), 'turn': 'right', 'bearing': 'S',
+              'want_bearing': 'W' },
         ]
         for config in pass_configs:
             with self.subTest(config=config):
                 cell, turn, bearing, want_bearing = config.values()
+                m = SpiralMatrix(5)
+                bearing = m.compass[bearing]
+                want_bearing = m.compass[want_bearing]
                 new_bearing = m._turn(turn, bearing)
                 self.assertEqual(new_bearing, want_bearing)
 
-    def test_move(self):
-
-        m = SpiralMatrix(self.matrix_dimension)
+    def test_08_move(self):
 
         pass_configs = [
-            { 'cell': (1, 1), 'bearing': m.N,
+            { 'cell': (1, 1), 'bearing': 'N',
               'want_coords': (0, 1) },
-            { 'cell': (0, 2), 'bearing': m.S,
+            { 'cell': (0, 2), 'bearing': 'S',
               'want_coords': (1, 2) },
         ]
         for config in pass_configs:
             with self.subTest(config=config):
                 cell, bearing, want_coords = config.values()
+                m = SpiralMatrix(5)
+                bearing = m.compass[bearing]
                 y, x = m._move(cell, bearing)
                 self.assertEqual((y, x), want_coords)