Removes client-side validation, simplifies some code

Author: chalmerlowe

google/cloud/bigquery/enums.py

@@ -360,7 +360,7 @@ class DeterminismLevel:
     """The UDF is not deterministic."""
 
 
-class RoundingMode(enum.Enum):
+class RoundingMode(str, enum.Enum):
     """Rounding mode options that can be used when storing NUMERIC or BIGNUMERIC
     values.
 
@@ -381,6 +381,9 @@ class RoundingMode(enum.Enum):
     * 2.5 => 2
     """
 
-    ROUNDING_MODE_UNSPECIFIED = 0
-    ROUND_HALF_AWAY_FROM_ZERO = 1
-    ROUND_HALF_EVEN = 2
+    def _generate_next_value_(name, start, count, last_values):
+        return name
+
+    ROUNDING_MODE_UNSPECIFIED = enum.auto()
+    ROUND_HALF_AWAY_FROM_ZERO = enum.auto()
+    ROUND_HALF_EVEN = enum.auto()

google/cloud/bigquery/schema.py

@@ -241,21 +241,10 @@ def __init__(
         if isinstance(range_element_type, FieldElementType):
             self._properties["rangeElementType"] = range_element_type.to_api_repr()
         if rounding_mode is not None:
-            if isinstance(rounding_mode, enums.RoundingMode):
-                rounding_mode = rounding_mode.name
             self._properties["roundingMode"] = rounding_mode
         if isinstance(foreign_type_definition, str):
             self._properties["foreignTypeDefinition"] = foreign_type_definition
 
-        # The order of operations is important:
-        # If field_type is FOREIGN, then foreign_type_definition must be set.
-        if field_type != "FOREIGN":
-            self._properties["type"] = field_type
-        else:
-            if self._properties.get("foreignTypeDefinition") is None:
-                raise ValueError(
-                    "If the 'field_type' is 'FOREIGN', then 'foreign_type_definition' is required."
-                )
         if fields:  # Don't set the property if it's not set.
             self._properties["fields"] = [field.to_api_repr() for field in fields]
 

tests/unit/test_schema.py

@@ -55,7 +55,6 @@ def test_constructor_defaults(self):
 
     def test_constructor_explicit(self):
         FIELD_DEFAULT_VALUE_EXPRESSION = "This is the default value for this field"
-        ROUNDINGMODE = enums.RoundingMode.ROUNDING_MODE_UNSPECIFIED
         field = self._make_one(
             "test",
             "STRING",
@@ -68,7 +67,7 @@ def test_constructor_explicit(self):
                 )
             ),
             default_value_expression=FIELD_DEFAULT_VALUE_EXPRESSION,
-            rounding_mode=ROUNDINGMODE,
+            rounding_mode=enums.RoundingMode.ROUNDING_MODE_UNSPECIFIED,
             foreign_type_definition="INTEGER",
         )
         self.assertEqual(field.name, "test")
@@ -86,7 +85,7 @@ def test_constructor_explicit(self):
                 )
             ),
         )
-        self.assertEqual(field.rounding_mode, ROUNDINGMODE.name)
+        self.assertEqual(field.rounding_mode, "ROUNDING_MODE_UNSPECIFIED")
         self.assertEqual(field.foreign_type_definition, "INTEGER")
 
     def test_constructor_explicit_none(self):
@@ -303,12 +302,10 @@ def test_fields_property(self):
         self.assertEqual(schema_field.fields, fields)
 
     def test_roundingmode_property_str(self):
-        # via init
         ROUNDINGMODE = "ROUND_HALF_AWAY_FROM_ZERO"
         schema_field = self._make_one("test", "STRING", rounding_mode=ROUNDINGMODE)
         self.assertEqual(schema_field.rounding_mode, ROUNDINGMODE)
 
-        # via _properties
         del schema_field
         schema_field = self._make_one("test", "STRING")
         schema_field._properties["roundingMode"] = ROUNDINGMODE
@@ -514,18 +511,6 @@ def test_to_standard_sql_foreign_type_valid(self):
         self.assertEqual(standard_field.name, "some_field")
         self.assertEqual(standard_field.type.type_kind, standard_type)
 
-    def test_to_standard_sql_foreign_type_invalid(self):
-        legacy_type = "FOREIGN"
-        foreign_type_definition = None
-
-        with self.assertRaises(ValueError) as context:
-            self._make_one(
-                "some_field",
-                field_type=legacy_type,
-                foreign_type_definition=foreign_type_definition,
-            )
-        self.assertTrue("If the 'field_type'" in context.exception.args[0])
-
     def test___eq___wrong_type(self):
         field = self._make_one("test", "STRING")
         other = object()