refactor: rename Column class into ColumnInfo, refactor it and cover with unit tests (#520)

Author: Ilya Gurov

google/cloud/spanner_dbapi/cursor.py

@@ -219,7 +219,7 @@ def description(self):
         columns = []
         for field in row_type.fields:
             columns.append(
-                Column(
+                ColumnInfo(
                     name=field.name,
                     type_code=field.type.code,
                     # Size of the SQL type of the column.
@@ -352,7 +352,9 @@ def get_table_column_schema(self, table_name):
         return self._connection.get_table_column_schema(table_name)
 
 
-class Column:
+class ColumnInfo:
+    """Row column description object."""
+
     def __init__(
         self,
         name,
@@ -371,48 +373,41 @@ def __init__(
         self.scale = scale
         self.null_ok = null_ok
 
+        self.fields = (
+            self.name,
+            self.type_code,
+            self.display_size,
+            self.internal_size,
+            self.precision,
+            self.scale,
+            self.null_ok,
+        )
+
     def __repr__(self):
         return self.__str__()
 
     def __getitem__(self, index):
-        if index == 0:
-            return self.name
-        elif index == 1:
-            return self.type_code
-        elif index == 2:
-            return self.display_size
-        elif index == 3:
-            return self.internal_size
-        elif index == 4:
-            return self.precision
-        elif index == 5:
-            return self.scale
-        elif index == 6:
-            return self.null_ok
+        return self.fields[index]
 
     def __str__(self):
-        rstr = ", ".join(
-            [
-                field
-                for field in [
+        str_repr = ", ".join(
+            filter(
+                lambda part: part is not None,
+                [
                     "name='%s'" % self.name,
                     "type_code=%d" % self.type_code,
-                    None
-                    if not self.display_size
-                    else "display_size=%d" % self.display_size,
-                    None
-                    if not self.internal_size
-                    else "internal_size=%d" % self.internal_size,
-                    None
-                    if not self.precision
-                    else "precision='%s'" % self.precision,
-                    None if not self.scale else "scale='%s'" % self.scale,
-                    None
-                    if not self.null_ok
-                    else "null_ok='%s'" % self.null_ok,
-                ]
-                if field
-            ]
+                    "display_size=%d" % self.display_size
+                    if self.display_size
+                    else None,
+                    "internal_size=%d" % self.internal_size
+                    if self.internal_size
+                    else None,
+                    "precision='%s'" % self.precision
+                    if self.precision
+                    else None,
+                    "scale='%s'" % self.scale if self.scale else None,
+                    "null_ok='%s'" % self.null_ok if self.null_ok else None,
+                ],
+            )
         )
-
-        return "Column(%s)" % rstr
+        return "ColumnInfo(%s)" % str_repr

tests/spanner_dbapi/test_cursor.py

@@ -10,6 +10,7 @@
 from unittest import mock
 
 from google.cloud.spanner_dbapi import connect, InterfaceError
+from google.cloud.spanner_dbapi.cursor import ColumnInfo
 
 
 class TestCursor(unittest.TestCase):
@@ -95,3 +96,59 @@ def test_executemany(self):
         execute_mock.assert_has_calls(
             (mock.call(operation, (1,)), mock.call(operation, (2,)))
         )
+
+
+class TestColumns(unittest.TestCase):
+    def test_ctor(self):
+        name = "col-name"
+        type_code = 8
+        display_size = 5
+        internal_size = 10
+        precision = 3
+        scale = None
+        null_ok = False
+
+        cols = ColumnInfo(
+            name,
+            type_code,
+            display_size,
+            internal_size,
+            precision,
+            scale,
+            null_ok,
+        )
+
+        self.assertEqual(cols.name, name)
+        self.assertEqual(cols.type_code, type_code)
+        self.assertEqual(cols.display_size, display_size)
+        self.assertEqual(cols.internal_size, internal_size)
+        self.assertEqual(cols.precision, precision)
+        self.assertEqual(cols.scale, scale)
+        self.assertEqual(cols.null_ok, null_ok)
+        self.assertEqual(
+            cols.fields,
+            (
+                name,
+                type_code,
+                display_size,
+                internal_size,
+                precision,
+                scale,
+                null_ok,
+            ),
+        )
+
+    def test___get_item__(self):
+        fields = ("col-name", 8, 5, 10, 3, None, False)
+        cols = ColumnInfo(*fields)
+
+        for i in range(0, 7):
+            self.assertEqual(cols[i], fields[i])
+
+    def test___str__(self):
+        cols = ColumnInfo("col-name", 8, None, 10, 3, None, False)
+
+        self.assertEqual(
+            str(cols),
+            "ColumnInfo(name='col-name', type_code=8, internal_size=10, precision='3')",
+        )