Making SchemaField immutable.

Author: dhermes

bigquery/google/cloud/bigquery/schema.py

@@ -26,7 +26,7 @@ class SchemaField(object):
                        'FLOAT', 'BOOLEAN', 'TIMESTAMP' or 'RECORD').
 
     :type mode: str
-    :param mode: the type of the field (one of 'NULLABLE', 'REQUIRED',
+    :param mode: the mode of the field (one of 'NULLABLE', 'REQUIRED',
                  or 'REPEATED').
 
     :type description: str
@@ -35,31 +35,75 @@ class SchemaField(object):
     :type fields: tuple of :class:`SchemaField`
     :param fields: subfields (requires ``field_type`` of 'RECORD').
     """
-    def __init__(self, name, field_type, mode='NULLABLE', description=None,
-                 fields=()):
-        self.name = name
-        self.field_type = field_type
-        self.mode = mode
-        self.description = description
-        self.fields = tuple(fields)
+    def __init__(self, name, field_type, mode='NULLABLE',
+                 description=None, fields=()):
+        self._name = name
+        self._field_type = field_type
+        self._mode = mode
+        self._description = description
+        self._fields = tuple(fields)
 
-    def _key(self):
+    @property
+    def name(self):
+        """str: The name of the field."""
+        return self._name
+
+    @property
+    def field_type(self):
+        """str: The type of the field.
+
+        Will be one of 'STRING', 'INTEGER', 'FLOAT', 'BOOLEAN',
+        'TIMESTAMP' or 'RECORD'.
+        """
+        return self._field_type
+
+    @property
+    def mode(self):
+        """str: The mode of the field.
+
+
+        Will be one of 'NULLABLE', 'REQUIRED', or 'REPEATED'.
         """
-        A tuple describing the contents of this :class:`SchemaField`.
+        return self._mode
+
+    @property
+    def description(self):
+        """Optional[str]: Description for the field."""
+        return self._description
+
+    @property
+    def fields(self):
+        """tuple: Subfields contained in this field.
+
+        If ``field_type`` is not 'RECORD', this property must be
+        empty / unset.
+        """
+        return self._fields
+
+    def _key(self):
+        """A tuple key that unique-ly describes this field.
+
         Used to compute this instance's hashcode and evaluate equality.
+
+        Returns:
+            tuple: The contents of this :class:`SchemaField`.
         """
         return (
-            self.name,
-            self.field_type.lower(),
-            self.mode,
-            self.description,
-            self.fields)
+            self._name,
+            self._field_type.lower(),
+            self._mode,
+            self._description,
+            self._fields,
+        )
 
     def __eq__(self, other):
-        return self._key() == other._key()
+        if isinstance(other, SchemaField):
+            return self._key() == other._key()
+        else:
+            return NotImplemented
 
     def __hash__(self):
         return hash(self._key())
 
     def __repr__(self):
-        return "SchemaField{}".format(self._key())
+        return 'SchemaField{}'.format(self._key())

bigquery/tests/unit/test_schema.py

@@ -26,43 +26,72 @@ def _get_target_class():
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
-    def test_ctor_defaults(self):
+    def test_constructor_defaults(self):
         field = self._make_one('test', 'STRING')
-        self.assertEqual(field.name, 'test')
-        self.assertEqual(field.field_type, 'STRING')
-        self.assertEqual(field.mode, 'NULLABLE')
-        self.assertIsNone(field.description)
-        self.assertEqual(field.fields, ())
+        self.assertEqual(field._name, 'test')
+        self.assertEqual(field._field_type, 'STRING')
+        self.assertEqual(field._mode, 'NULLABLE')
+        self.assertIsNone(field._description)
+        self.assertEqual(field._fields, ())
 
-    def test_ctor_explicit(self):
+    def test_constructor_explicit(self):
         field = self._make_one('test', 'STRING', mode='REQUIRED',
                                description='Testing')
-        self.assertEqual(field.name, 'test')
-        self.assertEqual(field.field_type, 'STRING')
-        self.assertEqual(field.mode, 'REQUIRED')
-        self.assertEqual(field.description, 'Testing')
-        self.assertEqual(field.fields, ())
-
-    def test_ctor_subfields(self):
+        self.assertEqual(field._name, 'test')
+        self.assertEqual(field._field_type, 'STRING')
+        self.assertEqual(field._mode, 'REQUIRED')
+        self.assertEqual(field._description, 'Testing')
+        self.assertEqual(field._fields, ())
+
+    def test_constructor_subfields(self):
+        sub_field1 = self._make_one('area_code', 'STRING')
+        sub_field2 = self._make_one('local_number', 'STRING')
         field = self._make_one(
-            'phone_number', 'RECORD',
-            fields=[self._make_one('area_code', 'STRING'),
-                    self._make_one('local_number', 'STRING')])
-        self.assertEqual(field.name, 'phone_number')
-        self.assertEqual(field.field_type, 'RECORD')
-        self.assertEqual(field.mode, 'NULLABLE')
-        self.assertIsNone(field.description)
-        self.assertEqual(len(field.fields), 2)
-        self.assertEqual(field.fields[0].name, 'area_code')
-        self.assertEqual(field.fields[0].field_type, 'STRING')
-        self.assertEqual(field.fields[0].mode, 'NULLABLE')
-        self.assertIsNone(field.fields[0].description)
-        self.assertEqual(field.fields[0].fields, ())
-        self.assertEqual(field.fields[1].name, 'local_number')
-        self.assertEqual(field.fields[1].field_type, 'STRING')
-        self.assertEqual(field.fields[1].mode, 'NULLABLE')
-        self.assertIsNone(field.fields[1].description)
-        self.assertEqual(field.fields[1].fields, ())
+            'phone_number',
+            'RECORD',
+            fields=[sub_field1, sub_field2],
+        )
+        self.assertEqual(field._name, 'phone_number')
+        self.assertEqual(field._field_type, 'RECORD')
+        self.assertEqual(field._mode, 'NULLABLE')
+        self.assertIsNone(field._description)
+        self.assertEqual(len(field._fields), 2)
+        self.assertIs(field._fields[0], sub_field1)
+        self.assertIs(field._fields[1], sub_field2)
+
+    def test_name_property(self):
+        name = 'lemon-ness'
+        schema_field = self._make_one(name, 'INTEGER')
+        self.assertIs(schema_field.name, name)
+
+    def test_field_type_property(self):
+        field_type = 'BOOLEAN'
+        schema_field = self._make_one('whether', field_type)
+        self.assertIs(schema_field.field_type, field_type)
+
+    def test_mode_property(self):
+        mode = 'REPEATED'
+        schema_field = self._make_one('again', 'FLOAT', mode=mode)
+        self.assertIs(schema_field.mode, mode)
+
+    def test_description_property(self):
+        description = 'It holds some data.'
+        schema_field = self._make_one(
+            'do', 'TIMESTAMP', description=description)
+        self.assertIs(schema_field.description, description)
+
+    def test_fields_property(self):
+        sub_field1 = self._make_one('one', 'STRING')
+        sub_field2 = self._make_one('fish', 'INTEGER')
+        fields = (sub_field1, sub_field2)
+        schema_field = self._make_one('boat', 'RECORD', fields=fields)
+        self.assertIs(schema_field.fields, fields)
+
+    def test___eq___wrong_type(self):
+        field = self._make_one('test', 'STRING')
+        other = object()
+        self.assertNotEqual(field, other)
+        self.assertIs(field.__eq__(other), NotImplemented)
 
     def test___eq___name_mismatch(self):
         field = self._make_one('test', 'STRING')