Adds fixtures, tests, corrections to classes and tests

Author: chalmerlowe

google/cloud/bigquery/dataset.py

@@ -23,7 +23,7 @@
 import google.cloud._helpers  # type: ignore
 
 from google.cloud.bigquery import _helpers
-from google.cloud.bigquery._helpers import _isinstance_or_raise, _get_sub_prop
+from google.cloud.bigquery._helpers import _isinstance_or_raise
 from google.cloud.bigquery.model import ModelReference
 from google.cloud.bigquery.routine import Routine, RoutineReference
 from google.cloud.bigquery.table import Table, TableReference
@@ -955,15 +955,15 @@ def external_catalog_dataset_options(self):
             prop = ExternalCatalogDatasetOptions().from_api_repr(prop)
         return prop
 
-
     @external_catalog_dataset_options.setter
     def external_catalog_dataset_options(self, value):
-        value = _isinstance_or_raise(value, ExternalCatalogDatasetOptions)
+        value = _isinstance_or_raise(
+            value, ExternalCatalogDatasetOptions, none_allowed=True
+        )
         self._properties[
             self._PROPERTY_TO_API_FIELD["external_catalog_dataset_options"]
         ] = value.to_api_repr()
 
-
     table = _get_table_reference
     model = _get_model_reference
     routine = _get_routine_reference

google/cloud/bigquery/external_config.py

@@ -30,10 +30,10 @@
     _int_or_none,
     _str_or_none,
     _isinstance_or_raise,
-    _from_api_repr,
+    _get_sub_prop,
 )
 from google.cloud.bigquery.format_options import AvroOptions, ParquetOptions
-from google.cloud.bigquery.schema import SchemaField
+from google.cloud.bigquery.schema import SchemaField, StorageDescriptor
 
 
 class ExternalSourceFormat(object):
@@ -1067,7 +1067,7 @@ def to_api_repr(self) -> dict:
         return config
 
     @classmethod
-    def from_api_repr(cls, resource: dict) -> "TODO":
+    def from_api_repr(cls, resource: dict) -> ExternalCatalogDatasetOptions:
         """Factory: constructs an instance of the class (cls)
         given its API representation.
 
@@ -1082,6 +1082,7 @@ def from_api_repr(cls, resource: dict) -> "TODO":
         config._properties = copy.deepcopy(resource)
         return config
 
+
 class ExternalCatalogTableOptions:
     """Metadata about open source compatible table. The fields contained in these
     options correspond to hive metastore's table level properties.
@@ -1104,7 +1105,7 @@ def __init__(
         connection_id: Optional[str] = None,
         parameters: Union[Dict[str, Any], None] = None,
         storage_descriptor: Optional[
-            str
+            StorageDescriptor
         ] = None,  # TODO implement StorageDescriptor, then correct this type hint
     ):
         self._properties = {}  # type: Dict[str, Any]
@@ -1146,12 +1147,19 @@ def storage_descriptor(self) -> Any:
         """Optional. A storage descriptor containing information about the
         physical storage of this table."""
 
-        return self._properties.get("storageDescriptor")
+        prop = _get_sub_prop(self._properties, ["storageDescriptor"])
+
+        if prop is not None:
+            prop = StorageDescriptor().from_api_repr(prop)
+        return prop
 
     @storage_descriptor.setter
-    def storage_descriptor(self, value: Optional[str]):
-        value = _isinstance_or_raise(value, str, none_allowed=True)
-        self._properties["storageDescriptor"] = value
+    def storage_descriptor(self, value):
+        value = _isinstance_or_raise(value, StorageDescriptor, none_allowed=True)
+        if value is not None:
+            self._properties["storageDescriptor"] = value.to_api_repr()
+        else:
+            self._properties["storageDescriptor"] = value
 
     def to_api_repr(self) -> dict:
         """Build an API representation of this object.
@@ -1164,7 +1172,7 @@ def to_api_repr(self) -> dict:
         return config
 
     @classmethod
-    def from_api_repr(cls, resource: dict) -> "TODO":
+    def from_api_repr(cls, resource: dict) -> ExternalCatalogTableOptions:
         """Factory: constructs an instance of the class (cls)
         given its API representation.
 

google/cloud/bigquery/schema.py

@@ -25,6 +25,7 @@
 from google.cloud.bigquery._helpers import (
     _isinstance_or_raise,
     _from_api_repr,
+    _get_sub_prop,
 )
 from google.cloud.bigquery.enums import StandardSqlTypeNames
 
@@ -715,7 +716,7 @@ def __init__(
         input_format: Optional[str] = None,
         location_uri: Optional[str] = None,
         output_format: Optional[str] = None,
-        serde_info: Optional[Any] = None,
+        serde_info: Optional[SerDeInfo] = None,
     ):
         self._properties = {}
         self.input_format = input_format
@@ -766,14 +767,20 @@ def output_format(self, value: Optional[str]):
     def serde_info(self) -> Any:
         """Optional. Serializer and deserializer information."""
 
-        return self._properties.get("serdeInfo")
+        prop = _get_sub_prop(self._properties, ["serDeInfo"])
+        print(f"DINOSAUR in SD: {prop}\n\n{self._properties}")
+        if prop is not None:
+            prop = SerDeInfo().from_api_repr(prop)
+
+        return prop
 
     @serde_info.setter
-    def serde_info(self, value: Optional[Any]):
-        value = _isinstance_or_raise(
-            value, str, none_allowed=True
-        )  # TODO fix, when serde class is done
-        self._properties["serdeInfo"] = value
+    def serde_info(self, value):
+        value = _isinstance_or_raise(value, SerDeInfo, none_allowed=True)
+        if value is not None:
+            self._properties["serDeInfo"] = value.to_api_repr()
+        else:
+            self._properties["serDeInfo"] = value
 
     def to_api_repr(self) -> dict:
         """Build an API representation of this object.
@@ -784,8 +791,21 @@ def to_api_repr(self) -> dict:
         """
         return copy.deepcopy(self._properties)
 
-    def from_api_repr(self, resource):
-        return _from_api_repr(self, resource)
+    @classmethod
+    def from_api_repr(cls, resource: dict) -> StorageDescriptor:
+        """Factory: constructs an instance of the class (cls)
+        given its API representation.
+
+        Args:
+            resource (Dict[str, Any]):
+                API representation of the object to be instantiated.
+
+        Returns:
+            An instance of the class initialized with data from 'resource'.
+        """
+        config = cls()
+        config._properties = copy.deepcopy(resource)
+        return config
 
 
 class SerDeInfo:
@@ -825,7 +845,7 @@ def serialization_library(self) -> Any:
 
     @serialization_library.setter
     def serialization_library(self, value: str):
-        value = _isinstance_or_raise(value, str)
+        value = _isinstance_or_raise(value, str, none_allowed=False)
         self._properties["serializationLibrary"] = value
 
     @property
@@ -860,5 +880,18 @@ def to_api_repr(self) -> dict:
         """
         return copy.deepcopy(self._properties)
 
-    def from_api_repr(self, resource):
-        return _from_api_repr(self, resource)
+    @classmethod
+    def from_api_repr(cls, resource: dict) -> SerDeInfo:
+        """Factory: constructs an instance of the class (cls)
+        given its API representation.
+
+        Args:
+            resource (Dict[str, Any]):
+                API representation of the object to be instantiated.
+
+        Returns:
+            An instance of the class initialized with data from 'resource'.
+        """
+        config = cls()
+        config._properties = copy.deepcopy(resource)
+        return config

tests/unit/test_dataset.py

@@ -1048,12 +1048,10 @@ def test_external_catalog_dataset_options_getter(self):
         dataset.external_catalog_dataset_options = ecdo_obj
         expected = ecdo_obj._properties
         result = dataset.external_catalog_dataset_options._properties
-        
+
         assert result == expected
 
     def test_external_catalog_dataset_options_from_api_repr(self):
-        from google.cloud.bigquery.external_config import ExternalCatalogDatasetOptions
-
         resource = self.API_REPR
         klass = self._get_target_class()
         dataset = klass.from_api_repr(resource)

tests/unit/test_external_config.py

@@ -14,15 +14,16 @@
 
 import base64
 import copy
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 import unittest
 
 from google.cloud.bigquery import external_config
 from google.cloud.bigquery.external_config import (
     ExternalCatalogDatasetOptions,
-    ExternalCatalogTableOptions
+    ExternalCatalogTableOptions,
 )
 from google.cloud.bigquery import schema
+from google.cloud.bigquery.schema import StorageDescriptor, SerDeInfo
 
 import pytest
 
@@ -909,7 +910,6 @@ def _get_target_class():
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
-
     @pytest.mark.parametrize(
         "default_storage_location_uri,parameters",
         [
@@ -971,6 +971,23 @@ def test_from_api_repr(self):
         assert result._properties == resource
 
 
+@pytest.fixture
+def _make_storage_descriptor():
+    serdeinfo = SerDeInfo(
+        serialization_library="testpath.to.LazySimpleSerDe",
+        name="serde_lib_name",
+        parameters={"key": "value"},
+    )
+
+    obj = StorageDescriptor(
+        input_format="testpath.to.OrcInputFormat",
+        location_uri="gs://test/path/",
+        output_format="testpath.to.OrcOutputFormat",
+        serde_info=serdeinfo,
+    )
+    return obj
+
+
 class TestExternalCatalogTableOptions:
     @staticmethod
     def _get_target_class():
@@ -982,38 +999,52 @@ def _make_one(self, *args, **kw):
     @pytest.mark.parametrize(
         "connection_id,parameters,storage_descriptor",
         [
-            ("connection123", {"key": "value"}, "placeholder"),  # set all params
+            (
+                "connection123",
+                {"key": "value"},
+                "_make_storage_descriptor",
+            ),  # set all params
             ("connection123", None, None),  # set only one parameter at a time
             (None, {"key": "value"}, None),
-            (None, None, "placeholder"),
+            (None, None, "_make_storage_descriptor"),
             (None, None, None),  # use default parameters
         ],
     )
-    def test_ctor_initialization(self, connection_id, parameters, storage_descriptor):
+    def test_ctor_initialization(
+        self, connection_id, parameters, storage_descriptor, request
+    ):
+        if storage_descriptor == "_make_storage_descriptor":
+            storage_descriptor = request.getfixturevalue(storage_descriptor)
+
         instance = self._make_one(
             connection_id=connection_id,
             parameters=parameters,
             storage_descriptor=storage_descriptor,
         )
-        assert instance._properties == {
-            "connectionId": connection_id,
-            "parameters": parameters,
-            "storageDescriptor": storage_descriptor,
-        }
+
+        assert instance._properties["connectionId"] == connection_id
+        assert instance._properties["parameters"] == parameters
+        if storage_descriptor is not None:
+            assert (
+                instance._properties["storageDescriptor"]
+                == storage_descriptor.to_api_repr()
+            )
+        else:
+            assert instance._properties["storageDescriptor"] == storage_descriptor
 
     @pytest.mark.parametrize(
         "connection_id, parameters, storage_descriptor",
         [
             pytest.param(
                 123,
                 {"test_key": "test_value"},
-                "test placeholder",
+                "_make_storage_descriptor",
                 id="connection_id-invalid-type",
             ),
             pytest.param(
                 "connection123",
                 123,
-                "test placeholder",
+                "_make_storage_descriptor",
                 id="parameters-invalid-type",
             ),
             pytest.param(
@@ -1028,8 +1059,11 @@ def test_ctor_invalid_input(
         self,
         connection_id: str,
         parameters: Dict[str, Any],
-        storage_descriptor: str,
+        storage_descriptor: Optional[StorageDescriptor],
+        request,
     ):
+        if storage_descriptor == "_make_storage_descriptor":
+            storage_descriptor = request.getfixturevalue(storage_descriptor)
         with pytest.raises(TypeError) as e:
             external_config.ExternalCatalogTableOptions(
                 connection_id=connection_id,
@@ -1039,32 +1073,36 @@ def test_ctor_invalid_input(
 
         assert "Pass " in str(e.value)
 
-    def test_to_api_repr(self):
+    def test_to_api_repr(self, _make_storage_descriptor):
         instance = self._make_one()
+
         instance._properties = {
             "connectionId": "connection123",
             "parameters": {"key": "value"},
-            "storageDescriptor": "placeholder",
+            "storageDescriptor": _make_storage_descriptor.to_api_repr(),
         }
 
         resource = instance.to_api_repr()
-
-        assert resource == {
+        expected = {
             "connectionId": "connection123",
             "parameters": {"key": "value"},
-            "storageDescriptor": "placeholder",
+            "storageDescriptor": _make_storage_descriptor.to_api_repr(),
         }
+        assert resource == expected
 
-
-    def test_from_api_repr(self):
+    def test_from_api_repr(self, _make_storage_descriptor):
         instance = self._make_one()
+        storage_descriptor = _make_storage_descriptor
         resource = {
             "connectionId": "connection123",
             "parameters": {"key": "value"},
-            "storageDescriptor": "placeholder",
+            "storageDescriptor": storage_descriptor,
         }
         result = instance.from_api_repr(resource)
-        
         assert isinstance(result, ExternalCatalogTableOptions)
-        assert result._properties == resource
-        
+        assert result._properties["connectionId"] == "connection123"
+        assert result._properties["parameters"] == {"key": "value"}
+        assert (
+            result._properties["storageDescriptor"].to_api_repr()
+            == storage_descriptor.to_api_repr()
+        )