github_repo_scraped
/
repos
/googleapis-python-bigquery-e731b40
/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 | |