testbed/googleapis__python-bigquery/tests/unit/test_external_config.py

# Copyright 2017 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import base64
import copy
import unittest

from google.cloud.bigquery import external_config
from google.cloud.bigquery import schema


class TestExternalConfig(unittest.TestCase):
    SOURCE_URIS = ["gs://foo", "gs://bar"]

    BASE_RESOURCE = {
        "sourceFormat": "",
        "sourceUris": SOURCE_URIS,
        "maxBadRecords": 17,
        "autodetect": True,
        "ignoreUnknownValues": False,
        "compression": "compression",
    }

    def test_from_api_repr_base(self):
        resource = copy.deepcopy(self.BASE_RESOURCE)
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self._verify_base(ec)
        self.assertEqual(ec.schema, [])
        self.assertIsNone(ec.options)

        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, self.BASE_RESOURCE)

        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "schema": {
                    "fields": [
                        {
                            "name": "full_name",
                            "type": "STRING",
                            "mode": "REQUIRED",
                            "description": None,
                        }
                    ]
                }
            },
        )
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self._verify_base(ec)
        exp_schema = [schema.SchemaField("full_name", "STRING", mode="REQUIRED")]
        self.assertEqual(ec.schema, exp_schema)
        self.assertIsNone(ec.options)

        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

    def test_to_api_repr_base(self):
        ec = external_config.ExternalConfig("")
        ec.source_uris = self.SOURCE_URIS
        ec.max_bad_records = 17
        ec.autodetect = True
        ec.ignore_unknown_values = False
        ec.compression = "compression"
        ec.connection_id = "path/to/connection"
        ec.schema = [schema.SchemaField("full_name", "STRING", mode="REQUIRED")]

        exp_schema = {
            "fields": [{"name": "full_name", "type": "STRING", "mode": "REQUIRED"}]
        }
        got_resource = ec.to_api_repr()
        exp_resource = {
            "sourceFormat": "",
            "sourceUris": self.SOURCE_URIS,
            "maxBadRecords": 17,
            "autodetect": True,
            "ignoreUnknownValues": False,
            "compression": "compression",
            "connectionId": "path/to/connection",
            "schema": exp_schema,
        }
        self.assertEqual(got_resource, exp_resource)

    def test_connection_id(self):
        ec = external_config.ExternalConfig("")
        self.assertIsNone(ec.connection_id)
        ec.connection_id = "path/to/connection"
        self.assertEqual(ec.connection_id, "path/to/connection")

    def test_reference_file_schema_uri(self):
        ec = external_config.ExternalConfig("")
        self.assertIsNone(ec.reference_file_schema_uri)
        ec.reference_file_schema_uri = "path/to/reference"
        self.assertEqual(ec.reference_file_schema_uri, "path/to/reference")

    def test_schema_None(self):
        ec = external_config.ExternalConfig("")
        ec.schema = None
        got = ec.to_api_repr()
        want = {"sourceFormat": "", "schema": None}
        self.assertEqual(got, want)

    def test_schema_empty(self):
        ec = external_config.ExternalConfig("")
        ec.schema = []
        got = ec.to_api_repr()
        want = {"sourceFormat": "", "schema": {"fields": []}}
        self.assertEqual(got, want)

    def _verify_base(self, ec):
        self.assertEqual(ec.autodetect, True)
        self.assertEqual(ec.compression, "compression")
        self.assertEqual(ec.ignore_unknown_values, False)
        self.assertEqual(ec.max_bad_records, 17)
        self.assertEqual(ec.source_uris, self.SOURCE_URIS)

    def test_to_api_repr_source_format(self):
        ec = external_config.ExternalConfig("CSV")
        got = ec.to_api_repr()
        want = {"sourceFormat": "CSV"}
        self.assertEqual(got, want)

    def test_from_api_repr_sheets(self):
        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "sourceFormat": "GOOGLE_SHEETS",
                "googleSheetsOptions": {
                    "skipLeadingRows": "123",
                    "range": "Sheet1!A5:B10",
                },
            },
        )

        ec = external_config.ExternalConfig.from_api_repr(resource)

        self._verify_base(ec)
        self.assertEqual(ec.source_format, "GOOGLE_SHEETS")
        self.assertIsInstance(ec.options, external_config.GoogleSheetsOptions)
        self.assertEqual(ec.options.skip_leading_rows, 123)
        self.assertEqual(ec.options.range, "Sheet1!A5:B10")

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, resource)

        del resource["googleSheetsOptions"]["skipLeadingRows"]
        del resource["googleSheetsOptions"]["range"]
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self.assertIsNone(ec.options.skip_leading_rows)
        self.assertIsNone(ec.options.range)
        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

    def test_to_api_repr_sheets(self):
        ec = external_config.ExternalConfig("GOOGLE_SHEETS")
        options = external_config.GoogleSheetsOptions()
        options.skip_leading_rows = 123
        options.range = "Sheet1!A5:B10"
        ec.google_sheets_options = options

        exp_resource = {
            "sourceFormat": "GOOGLE_SHEETS",
            "googleSheetsOptions": {"skipLeadingRows": "123", "range": "Sheet1!A5:B10"},
        }

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, exp_resource)

    def test_from_api_repr_hive_partitioning(self):
        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "sourceFormat": "FORMAT_FOO",
                "hivePartitioningOptions": {
                    "sourceUriPrefix": "http://foo/bar",
                    "mode": "STRINGS",
                    "requirePartitionFilter": True,
                },
            },
        )

        ec = external_config.ExternalConfig.from_api_repr(resource)

        self._verify_base(ec)
        self.assertEqual(ec.source_format, "FORMAT_FOO")
        self.assertIsInstance(
            ec.hive_partitioning, external_config.HivePartitioningOptions
        )
        self.assertEqual(ec.hive_partitioning.source_uri_prefix, "http://foo/bar")
        self.assertEqual(ec.hive_partitioning.mode, "STRINGS")
        self.assertEqual(ec.hive_partitioning.require_partition_filter, True)

        # converting back to API representation should yield the same result
        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

        del resource["hivePartitioningOptions"]
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self.assertIsNone(ec.hive_partitioning)

        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

    def test_to_api_repr_hive_partitioning(self):
        hive_partitioning = external_config.HivePartitioningOptions()
        hive_partitioning.source_uri_prefix = "http://foo/bar"
        hive_partitioning.mode = "STRINGS"
        hive_partitioning.require_partition_filter = False

        ec = external_config.ExternalConfig("FORMAT_FOO")
        ec.hive_partitioning = hive_partitioning

        got_resource = ec.to_api_repr()

        expected_resource = {
            "sourceFormat": "FORMAT_FOO",
            "hivePartitioningOptions": {
                "sourceUriPrefix": "http://foo/bar",
                "mode": "STRINGS",
                "requirePartitionFilter": False,
            },
        }
        self.assertEqual(got_resource, expected_resource)

    def test_from_api_repr_csv(self):
        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "sourceFormat": "CSV",
                "csvOptions": {
                    "fieldDelimiter": "fieldDelimiter",
                    "skipLeadingRows": "123",
                    "quote": "quote",
                    "allowQuotedNewlines": True,
                    "allowJaggedRows": False,
                    "encoding": "encoding",
                    "preserveAsciiControlCharacters": False,
                },
            },
        )

        ec = external_config.ExternalConfig.from_api_repr(resource)

        self._verify_base(ec)
        self.assertEqual(ec.source_format, "CSV")
        self.assertIsInstance(ec.options, external_config.CSVOptions)
        self.assertEqual(ec.options.field_delimiter, "fieldDelimiter")
        self.assertEqual(ec.options.skip_leading_rows, 123)
        self.assertEqual(ec.options.quote_character, "quote")
        self.assertEqual(ec.options.allow_quoted_newlines, True)
        self.assertEqual(ec.options.allow_jagged_rows, False)
        self.assertEqual(ec.options.encoding, "encoding")
        self.assertEqual(ec.options.preserve_ascii_control_characters, False)

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, resource)

        del resource["csvOptions"]["skipLeadingRows"]
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self.assertIsNone(ec.options.skip_leading_rows)
        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

    def test_to_api_repr_csv(self):
        ec = external_config.ExternalConfig("CSV")
        options = external_config.CSVOptions()
        options.allow_quoted_newlines = True
        options.encoding = "encoding"
        options.field_delimiter = "fieldDelimiter"
        options.quote_character = "quote"
        options.skip_leading_rows = 123
        options.allow_jagged_rows = False
        options.preserve_ascii_control_characters = False
        ec.csv_options = options

        exp_resource = {
            "sourceFormat": "CSV",
            "csvOptions": {
                "fieldDelimiter": "fieldDelimiter",
                "skipLeadingRows": "123",
                "quote": "quote",
                "allowQuotedNewlines": True,
                "allowJaggedRows": False,
                "encoding": "encoding",
                "preserveAsciiControlCharacters": False,
            },
        }

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, exp_resource)

    def test_from_api_repr_bigtable(self):
        qualifier_encoded = base64.standard_b64encode(b"q").decode("ascii")
        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "sourceFormat": "BIGTABLE",
                "bigtableOptions": {
                    "ignoreUnspecifiedColumnFamilies": True,
                    "readRowkeyAsString": False,
                    "columnFamilies": [
                        {
                            "familyId": "familyId",
                            "type": "type",
                            "encoding": "encoding",
                            "columns": [
                                {
                                    "qualifierString": "q",
                                    "fieldName": "fieldName1",
                                    "type": "type1",
                                    "encoding": "encoding1",
                                    "onlyReadLatest": True,
                                },
                                {
                                    "qualifierEncoded": qualifier_encoded,
                                    "fieldName": "fieldName2",
                                    "type": "type2",
                                    "encoding": "encoding2",
                                },
                            ],
                            "onlyReadLatest": False,
                        }
                    ],
                },
            },
        )

        ec = external_config.ExternalConfig.from_api_repr(resource)

        self._verify_base(ec)
        self.assertEqual(ec.source_format, "BIGTABLE")
        self.assertIsInstance(ec.options, external_config.BigtableOptions)
        self.assertEqual(ec.options.ignore_unspecified_column_families, True)
        self.assertEqual(ec.options.read_rowkey_as_string, False)
        self.assertEqual(len(ec.options.column_families), 1)
        fam1 = ec.options.column_families[0]
        self.assertIsInstance(fam1, external_config.BigtableColumnFamily)
        self.assertEqual(fam1.family_id, "familyId")
        self.assertEqual(fam1.type_, "type")
        self.assertEqual(fam1.encoding, "encoding")
        self.assertEqual(len(fam1.columns), 2)
        self.assertFalse(fam1.only_read_latest)
        col1 = fam1.columns[0]
        self.assertEqual(col1.qualifier_string, "q")
        self.assertEqual(col1.field_name, "fieldName1")
        self.assertEqual(col1.type_, "type1")
        self.assertEqual(col1.encoding, "encoding1")
        self.assertTrue(col1.only_read_latest)
        self.assertIsNone(col1.qualifier_encoded)
        col2 = ec.options.column_families[0].columns[1]
        self.assertEqual(col2.qualifier_encoded, b"q")
        self.assertEqual(col2.field_name, "fieldName2")
        self.assertEqual(col2.type_, "type2")
        self.assertEqual(col2.encoding, "encoding2")

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, resource)

    def test_to_api_repr_bigtable(self):
        ec = external_config.ExternalConfig("BIGTABLE")
        options = external_config.BigtableOptions()
        options.ignore_unspecified_column_families = True
        options.read_rowkey_as_string = False
        ec.bigtable_options = options

        fam1 = external_config.BigtableColumnFamily()
        fam1.family_id = "familyId"
        fam1.type_ = "type"
        fam1.encoding = "encoding"
        fam1.only_read_latest = False
        col1 = external_config.BigtableColumn()
        col1.qualifier_string = "q"
        col1.field_name = "fieldName1"
        col1.type_ = "type1"
        col1.encoding = "encoding1"
        col1.only_read_latest = True
        col2 = external_config.BigtableColumn()
        col2.qualifier_encoded = b"q"
        col2.field_name = "fieldName2"
        col2.type_ = "type2"
        col2.encoding = "encoding2"
        fam1.columns = [col1, col2]
        options.column_families = [fam1]

        qualifier_encoded = base64.standard_b64encode(b"q").decode("ascii")
        exp_resource = {
            "sourceFormat": "BIGTABLE",
            "bigtableOptions": {
                "ignoreUnspecifiedColumnFamilies": True,
                "readRowkeyAsString": False,
                "columnFamilies": [
                    {
                        "familyId": "familyId",
                        "type": "type",
                        "encoding": "encoding",
                        "columns": [
                            {
                                "qualifierString": "q",
                                "fieldName": "fieldName1",
                                "type": "type1",
                                "encoding": "encoding1",
                                "onlyReadLatest": True,
                            },
                            {
                                "qualifierEncoded": qualifier_encoded,
                                "fieldName": "fieldName2",
                                "type": "type2",
                                "encoding": "encoding2",
                            },
                        ],
                        "onlyReadLatest": False,
                    }
                ],
            },
        }

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, exp_resource)

    def test_avro_options_getter_and_setter(self):
        from google.cloud.bigquery.external_config import AvroOptions

        options = AvroOptions.from_api_repr({"useAvroLogicalTypes": True})
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.AVRO)

        self.assertIsNone(ec.avro_options.use_avro_logical_types)

        ec.avro_options = options

        self.assertTrue(ec.avro_options.use_avro_logical_types)
        self.assertIs(
            ec.options._properties, ec._properties[AvroOptions._RESOURCE_NAME]
        )
        self.assertIs(
            ec.avro_options._properties, ec._properties[AvroOptions._RESOURCE_NAME]
        )

    def test_avro_options_getter_empty(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.AVRO)
        self.assertIsNotNone(ec.avro_options)

    def test_avro_options_getter_wrong_format(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)
        self.assertIsNone(ec.avro_options)

    def test_avro_options_setter_wrong_format(self):
        from google.cloud.bigquery.format_options import AvroOptions

        options = AvroOptions()
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)

        with self.assertRaisesRegex(TypeError, "Cannot set.*source format is CSV"):
            ec.avro_options = options

    def test_bigtable_options_getter_and_setter(self):
        from google.cloud.bigquery.external_config import BigtableOptions

        options = BigtableOptions.from_api_repr(
            {"ignoreUnspecifiedColumnFamilies": True, "readRowkeyAsString": False}
        )
        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.BIGTABLE
        )

        self.assertIsNone(ec.bigtable_options.ignore_unspecified_column_families)
        self.assertIsNone(ec.bigtable_options.read_rowkey_as_string)

        ec.bigtable_options = options

        self.assertTrue(ec.bigtable_options.ignore_unspecified_column_families)
        self.assertFalse(ec.bigtable_options.read_rowkey_as_string)
        self.assertIs(
            ec.options._properties, ec._properties[BigtableOptions._RESOURCE_NAME]
        )
        self.assertIs(
            ec.bigtable_options._properties,
            ec._properties[BigtableOptions._RESOURCE_NAME],
        )

    def test_bigtable_options_getter_empty(self):
        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.BIGTABLE
        )
        self.assertIsNotNone(ec.bigtable_options)

    def test_bigtable_options_getter_wrong_format(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)
        self.assertIsNone(ec.bigtable_options)

    def test_bigtable_options_setter_wrong_format(self):
        from google.cloud.bigquery.external_config import BigtableOptions

        options = BigtableOptions()
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)

        with self.assertRaisesRegex(TypeError, "Cannot set.*source format is CSV"):
            ec.bigtable_options = options

    def test_csv_options_getter_and_setter(self):
        from google.cloud.bigquery.external_config import CSVOptions

        options = CSVOptions.from_api_repr(
            {
                "allowJaggedRows": True,
                "allowQuotedNewlines": False,
                "preserveAsciiControlCharacters": False,
            }
        )
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)

        self.assertIsNone(ec.csv_options.allow_jagged_rows)
        self.assertIsNone(ec.csv_options.allow_quoted_newlines)
        self.assertIsNone(ec.csv_options.preserve_ascii_control_characters)

        ec.csv_options = options

        self.assertTrue(ec.csv_options.allow_jagged_rows)
        self.assertFalse(ec.csv_options.allow_quoted_newlines)
        self.assertFalse(ec.csv_options.preserve_ascii_control_characters)
        self.assertIs(ec.options._properties, ec._properties[CSVOptions._RESOURCE_NAME])
        self.assertIs(
            ec.csv_options._properties, ec._properties[CSVOptions._RESOURCE_NAME]
        )

    def test_csv_options_getter_empty(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)
        self.assertIsNotNone(ec.csv_options)

    def test_csv_options_getter_wrong_format(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.AVRO)
        self.assertIsNone(ec.csv_options)

    def test_csv_options_setter_wrong_format(self):
        from google.cloud.bigquery.external_config import CSVOptions

        options = CSVOptions()
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.AVRO)

        with self.assertRaisesRegex(TypeError, "Cannot set.*source format is AVRO"):
            ec.csv_options = options

    def test_google_sheets_options_getter_and_setter(self):
        from google.cloud.bigquery.external_config import GoogleSheetsOptions

        options = GoogleSheetsOptions.from_api_repr({"skipLeadingRows": "123"})
        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.GOOGLE_SHEETS
        )

        self.assertIsNone(ec.google_sheets_options.skip_leading_rows)

        ec.google_sheets_options = options

        self.assertEqual(ec.google_sheets_options.skip_leading_rows, 123)
        self.assertIs(
            ec.options._properties, ec._properties[GoogleSheetsOptions._RESOURCE_NAME]
        )
        self.assertIs(
            ec.google_sheets_options._properties,
            ec._properties[GoogleSheetsOptions._RESOURCE_NAME],
        )

    def test_google_sheets_options_getter_empty(self):
        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.GOOGLE_SHEETS
        )
        self.assertIsNotNone(ec.google_sheets_options)

    def test_google_sheets_options_getter_wrong_format(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)
        self.assertIsNone(ec.google_sheets_options)

    def test_google_sheets_options_setter_wrong_format(self):
        from google.cloud.bigquery.external_config import GoogleSheetsOptions

        options = GoogleSheetsOptions()
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)

        with self.assertRaisesRegex(TypeError, "Cannot set.*source format is CSV"):
            ec.google_sheets_options = options

    def test_parquet_options_getter_and_setter(self):
        from google.cloud.bigquery.format_options import ParquetOptions

        options = ParquetOptions.from_api_repr(
            {"enumAsString": True, "enableListInference": False}
        )
        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.PARQUET
        )

        self.assertIsNone(ec.parquet_options.enum_as_string)
        self.assertIsNone(ec.parquet_options.enable_list_inference)

        ec.parquet_options = options

        self.assertTrue(ec.parquet_options.enum_as_string)
        self.assertFalse(ec.parquet_options.enable_list_inference)
        self.assertIs(
            ec.options._properties, ec._properties[ParquetOptions._RESOURCE_NAME]
        )
        self.assertIs(
            ec.parquet_options._properties,
            ec._properties[ParquetOptions._RESOURCE_NAME],
        )

    def test_parquet_options_set_properties(self):
        """Check that setting sub-properties works without having to create a
        new ParquetOptions instance.

        This is required for compatibility with previous
        ExternalConfig._options implementation.
        """

        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.PARQUET
        )

        self.assertIsNone(ec.parquet_options.enum_as_string)
        self.assertIsNone(ec.parquet_options.enable_list_inference)

        ec.parquet_options.enum_as_string = True
        ec.parquet_options.enable_list_inference = False

        self.assertTrue(ec.options.enum_as_string)
        self.assertFalse(ec.options.enable_list_inference)
        self.assertTrue(ec.parquet_options.enum_as_string)
        self.assertFalse(ec.parquet_options.enable_list_inference)

    def test_parquet_options_getter_empty(self):
        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.PARQUET
        )
        self.assertIsNotNone(ec.parquet_options)

    def test_parquet_options_getter_non_parquet_format(self):
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)
        self.assertIsNone(ec.parquet_options)

    def test_parquet_options_setter_non_parquet_format(self):
        from google.cloud.bigquery.format_options import ParquetOptions

        parquet_options = ParquetOptions.from_api_repr(
            {"enumAsString": False, "enableListInference": True}
        )
        ec = external_config.ExternalConfig(external_config.ExternalSourceFormat.CSV)

        with self.assertRaisesRegex(TypeError, "Cannot set.*source format is CSV"):
            ec.parquet_options = parquet_options

    def test_from_api_repr_parquet(self):
        from google.cloud.bigquery.format_options import ParquetOptions

        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "sourceFormat": "PARQUET",
                "parquetOptions": {"enumAsString": True, "enableListInference": False},
            },
        )

        ec = external_config.ExternalConfig.from_api_repr(resource)

        self._verify_base(ec)
        self.assertEqual(ec.source_format, external_config.ExternalSourceFormat.PARQUET)
        self.assertIsInstance(ec.options, ParquetOptions)
        self.assertTrue(ec.parquet_options.enum_as_string)
        self.assertFalse(ec.parquet_options.enable_list_inference)

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, resource)

        del resource["parquetOptions"]["enableListInference"]
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self.assertIsNone(ec.options.enable_list_inference)
        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

    def test_to_api_repr_parquet(self):
        from google.cloud.bigquery.format_options import ParquetOptions

        ec = external_config.ExternalConfig(
            external_config.ExternalSourceFormat.PARQUET
        )
        options = ParquetOptions.from_api_repr(
            dict(enumAsString=False, enableListInference=True)
        )
        ec.parquet_options = options

        exp_resource = {
            "sourceFormat": external_config.ExternalSourceFormat.PARQUET,
            "parquetOptions": {"enumAsString": False, "enableListInference": True},
        }

        got_resource = ec.to_api_repr()

        self.assertEqual(got_resource, exp_resource)

    def test_from_api_repr_decimal_target_types(self):
        from google.cloud.bigquery.enums import DecimalTargetType

        resource = _copy_and_update(
            self.BASE_RESOURCE,
            {
                "sourceFormat": "FORMAT_FOO",
                "decimalTargetTypes": [DecimalTargetType.NUMERIC],
            },
        )

        ec = external_config.ExternalConfig.from_api_repr(resource)

        self._verify_base(ec)
        self.assertEqual(ec.source_format, "FORMAT_FOO")
        self.assertEqual(
            ec.decimal_target_types, frozenset([DecimalTargetType.NUMERIC])
        )

        # converting back to API representation should yield the same result
        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

        del resource["decimalTargetTypes"]
        ec = external_config.ExternalConfig.from_api_repr(resource)
        self.assertIsNone(ec.decimal_target_types)

        got_resource = ec.to_api_repr()
        self.assertEqual(got_resource, resource)

    def test_to_api_repr_decimal_target_types(self):
        from google.cloud.bigquery.enums import DecimalTargetType

        ec = external_config.ExternalConfig("FORMAT_FOO")
        ec.decimal_target_types = [DecimalTargetType.NUMERIC, DecimalTargetType.STRING]

        got_resource = ec.to_api_repr()

        expected_resource = {
            "sourceFormat": "FORMAT_FOO",
            "decimalTargetTypes": [DecimalTargetType.NUMERIC, DecimalTargetType.STRING],
        }
        self.assertEqual(got_resource, expected_resource)

    def test_to_api_repr_decimal_target_types_unset(self):
        from google.cloud.bigquery.enums import DecimalTargetType

        ec = external_config.ExternalConfig("FORMAT_FOO")
        ec._properties["decimalTargetTypes"] = [DecimalTargetType.NUMERIC]
        ec.decimal_target_types = None

        got_resource = ec.to_api_repr()

        expected_resource = {"sourceFormat": "FORMAT_FOO"}
        self.assertEqual(got_resource, expected_resource)

        ec.decimal_target_types = None  # No error if unsetting when already unset.


class BigtableOptions(unittest.TestCase):
    def test_to_api_repr(self):
        options = external_config.BigtableOptions()
        family1 = external_config.BigtableColumnFamily()
        column1 = external_config.BigtableColumn()
        column1.qualifier_string = "col1"
        column1.field_name = "bqcol1"
        column1.type_ = "FLOAT"
        column1.encoding = "TEXT"
        column1.only_read_latest = True
        column2 = external_config.BigtableColumn()
        column2.qualifier_encoded = b"col2"
        column2.field_name = "bqcol2"
        column2.type_ = "STRING"
        column2.only_read_latest = False
        family1.family_id = "family1"
        family1.type_ = "INTEGER"
        family1.encoding = "BINARY"
        family1.columns = [column1, column2]
        family1.only_read_latest = False
        family2 = external_config.BigtableColumnFamily()
        column3 = external_config.BigtableColumn()
        column3.qualifier_string = "col3"
        family2.family_id = "family2"
        family2.type_ = "BYTES"
        family2.encoding = "TEXT"
        family2.columns = [column3]
        family2.only_read_latest = True
        options.column_families = [family1, family2]
        options.ignore_unspecified_column_families = False
        options.read_rowkey_as_string = True

        resource = options.to_api_repr()

        expected_column_families = [
            {
                "familyId": "family1",
                "type": "INTEGER",
                "encoding": "BINARY",
                "columns": [
                    {
                        "qualifierString": "col1",
                        "fieldName": "bqcol1",
                        "type": "FLOAT",
                        "encoding": "TEXT",
                        "onlyReadLatest": True,
                    },
                    {
                        "qualifierEncoded": "Y29sMg==",
                        "fieldName": "bqcol2",
                        "type": "STRING",
                        "onlyReadLatest": False,
                    },
                ],
                "onlyReadLatest": False,
            },
            {
                "familyId": "family2",
                "type": "BYTES",
                "encoding": "TEXT",
                "columns": [{"qualifierString": "col3"}],
                "onlyReadLatest": True,
            },
        ]
        self.maxDiff = None
        self.assertEqual(
            resource,
            {
                "columnFamilies": expected_column_families,
                "ignoreUnspecifiedColumnFamilies": False,
                "readRowkeyAsString": True,
            },
        )


class CSVOptions(unittest.TestCase):
    def test_to_api_repr(self):
        options = external_config.CSVOptions()
        options.field_delimiter = "\t"
        options.skip_leading_rows = 42
        options.quote_character = '"'
        options.allow_quoted_newlines = True
        options.allow_jagged_rows = False
        options.encoding = "UTF-8"
        options.preserve_ascii_control_characters = False

        resource = options.to_api_repr()

        self.assertEqual(
            resource,
            {
                "fieldDelimiter": "\t",
                "skipLeadingRows": "42",
                "quote": '"',
                "allowQuotedNewlines": True,
                "allowJaggedRows": False,
                "encoding": "UTF-8",
                "preserveAsciiControlCharacters": False,
            },
        )


class TestGoogleSheetsOptions(unittest.TestCase):
    def test_to_api_repr(self):
        options = external_config.GoogleSheetsOptions()
        options.range = "sheet1!A1:B20"
        options.skip_leading_rows = 107

        resource = options.to_api_repr()

        self.assertEqual(resource, {"range": "sheet1!A1:B20", "skipLeadingRows": "107"})


def _copy_and_update(d, u):
    d = copy.deepcopy(d)
    d.update(u)
    return d