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

# Copyright 2015 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 datetime
import decimal
import unittest
from unittest import mock


class Test_UDFResource(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import UDFResource

        return UDFResource

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_ctor(self):
        udf = self._make_one("resourceUri", "gs://some_bucket/some_file")
        self.assertEqual(udf.udf_type, "resourceUri")
        self.assertEqual(udf.value, "gs://some_bucket/some_file")

    def test___eq__(self):
        udf = self._make_one("resourceUri", "gs://some_bucket/some_file")
        self.assertEqual(udf, udf)
        self.assertNotEqual(udf, object())
        wrong_val = self._make_one("resourceUri", "gs://some_bucket/other_file")
        self.assertNotEqual(udf, wrong_val)
        wrong_type = self._make_one("inlineCode", udf.value)
        self.assertNotEqual(udf, wrong_type)


class Test__AbstractQueryParameterType(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import _AbstractQueryParameterType

        return _AbstractQueryParameterType

    @classmethod
    def _make_one(cls, *args, **kw):
        return cls._get_target_class()(*args, **kw)

    def test_from_api_virtual(self):
        klass = self._get_target_class()
        with self.assertRaises(NotImplementedError):
            klass.from_api_repr({})

    def test_to_api_virtual(self):
        param_type = self._make_one()
        with self.assertRaises(NotImplementedError):
            param_type.to_api_repr()


class Test_ScalarQueryParameterType(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import ScalarQueryParameterType

        return ScalarQueryParameterType

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_from_api_repr(self):
        klass = self._get_target_class()
        result = klass.from_api_repr({"type": "BOOLEAN"})
        self.assertEqual(result._type, "BOOLEAN")
        self.assertIsNone(result.name)
        self.assertIsNone(result.description)

    def test_to_api_repr(self):
        param_type = self._make_one("BYTES", name="foo", description="bar")
        result = param_type.to_api_repr()
        self.assertEqual(result, {"type": "BYTES"})

    def test_repr_no_optional_attrs(self):
        param_type = self._make_one("BYTES")
        self.assertEqual(repr(param_type), "ScalarQueryParameterType('BYTES')")

    def test_repr_all_optional_attrs(self):
        param_type = self._make_one("BYTES", name="foo", description="this is foo")
        self.assertEqual(
            repr(param_type),
            "ScalarQueryParameterType('BYTES', name='foo', description='this is foo')",
        )

    def test_with_name_returns_copy_w_changed_name(self):
        param_type = self._make_one("BOOLEAN", name=None, description="Some checkbox.")
        modified_type = param_type.with_name("allow_emails")

        self.assertIsNot(modified_type, param_type)  # Result is a copy.
        self.assertEqual(modified_type.name, "allow_emails")

        # The rest of the The rest of the fields should have been preserved.
        self.assertEqual(modified_type._type, param_type._type)
        self.assertEqual(modified_type.description, param_type.description)

    def test_with_name_clearing_the_value(self):
        param_type = self._make_one(
            "BOOLEAN", name="allow_emails", description="Some checkbox."
        )
        modified_type = param_type.with_name(None)

        self.assertIsNone(modified_type.name)
        self.assertEqual(param_type.name, "allow_emails")  # original unchanged


class Test_ArrayQueryParameterType(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import ArrayQueryParameterType

        return ArrayQueryParameterType

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_from_api_repr(self):
        from google.cloud.bigquery.query import StructQueryParameterType

        api_resource = {
            "type": "ARRAY",
            "arrayType": {
                "type": "STRUCT",
                "structTypes": [
                    {
                        "name": "weight",
                        "type": {"type": "INTEGER"},
                        "description": "in kg",
                    },
                    {"name": "last_name", "type": {"type": "STRING"}},
                ],
            },
        }

        klass = self._get_target_class()
        result = klass.from_api_repr(api_resource)

        self.assertIsNone(result.name)
        self.assertIsNone(result.description)
        item_type = result._array_type
        self.assertIsInstance(item_type, StructQueryParameterType)

        self.assertIsNone(item_type.name)
        self.assertIsNone(item_type.description)

        field = item_type.fields[0]
        self.assertEqual(field.name, "weight")
        self.assertEqual(field.description, "in kg")
        self.assertEqual(field._type, "INTEGER")

        field = item_type.fields[1]
        self.assertEqual(field.name, "last_name")
        self.assertIsNone(field.description)
        self.assertEqual(field._type, "STRING")

    def test_to_api_repr(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType
        from google.cloud.bigquery.query import StructQueryParameterType

        array_item_type = StructQueryParameterType(
            ScalarQueryParameterType("INTEGER", name="weight", description="in kg"),
            ScalarQueryParameterType("STRING", name="last_name"),
        )
        param_type = self._make_one(array_item_type, name="foo", description="bar")

        result = param_type.to_api_repr()

        expected_result = {
            "type": "ARRAY",
            "arrayType": {
                "type": "STRUCT",
                "structTypes": [
                    {
                        "name": "weight",
                        "type": {"type": "INTEGER"},
                        "description": "in kg",
                    },
                    {"name": "last_name", "type": {"type": "STRING"}},
                ],
            },
        }
        self.assertEqual(result, expected_result)

    def test_repr_no_optional_attrs(self):
        param_type = self._make_one("BOOLEAN")
        self.assertEqual(repr(param_type), "ArrayQueryParameterType('BOOLEAN')")

    def test_repr_all_optional_attrs(self):
        param_type = self._make_one("INT64", name="bar", description="this is bar")
        self.assertEqual(
            repr(param_type),
            "ArrayQueryParameterType('INT64', name='bar', description='this is bar')",
        )


class Test_StructQueryParameterType(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import StructQueryParameterType

        return StructQueryParameterType

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_raises_error_without_any_fields(self):
        with self.assertRaisesRegex(ValueError, ".*at least one field.*"):
            self._make_one()

    def test_from_api_repr(self):
        from google.cloud.bigquery.query import ArrayQueryParameterType
        from google.cloud.bigquery.query import ScalarQueryParameterType

        api_resource = {
            "type": "STRUCT",
            "structTypes": [
                {
                    "name": "age",
                    "type": {"type": "INTEGER"},
                    "description": "in years",
                },
                {
                    "name": "aliases",
                    "type": {"type": "ARRAY", "arrayType": {"type": "STRING"}},
                },
                {
                    "description": "a nested struct",
                    "type": {
                        "type": "STRUCT",
                        "structTypes": [
                            {"type": {"type": "DATE"}, "name": "nested_date"},
                            {
                                "type": {"type": "BOOLEAN"},
                                "description": "nested bool field",
                            },
                        ],
                    },
                },
            ],
        }

        klass = self._get_target_class()
        result = klass.from_api_repr(api_resource)

        self.assertIsNone(result.name)
        self.assertIsNone(result.description)
        self.assertEqual(len(result.fields), 3)

        field = result.fields[0]
        self.assertIsInstance(field, ScalarQueryParameterType)
        self.assertEqual(field.name, "age")
        self.assertEqual(field.description, "in years")

        field = result.fields[1]
        self.assertIsInstance(field, ArrayQueryParameterType)
        self.assertEqual(field.name, "aliases")
        self.assertIsNone(field.description)
        self.assertIsInstance(field._array_type, ScalarQueryParameterType)
        self.assertEqual(field._array_type._type, "STRING")

        field = result.fields[2]
        self.assertIsInstance(field, self._get_target_class())
        self.assertIsNone(field.name)
        self.assertEqual(field.description, "a nested struct")

        date_field = field.fields[0]
        self.assertEqual(date_field._type, "DATE")
        self.assertEqual(date_field.name, "nested_date")
        self.assertIsNone(date_field.description)

        bool_field = field.fields[1]
        self.assertEqual(bool_field._type, "BOOLEAN")
        self.assertIsNone(bool_field.name)
        self.assertEqual(bool_field.description, "nested bool field")

    def test_to_api_repr(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType

        int_type = ScalarQueryParameterType("INTEGER", description="in years")
        date_type = ScalarQueryParameterType("DATE", name="day_of_birth")
        param_type = self._make_one(int_type, date_type, name="foo", description="bar")

        result = param_type.to_api_repr()

        expected_result = {
            "type": "STRUCT",
            "structTypes": [
                {"type": {"type": "INTEGER"}, "description": "in years"},
                {"name": "day_of_birth", "type": {"type": "DATE"}},
            ],
        }
        self.assertEqual(result, expected_result)

    def test_to_api_repr_nested(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType

        struct_class = self._get_target_class()

        int_type = ScalarQueryParameterType("INTEGER", description="in years")
        nested_struct_type = struct_class(
            ScalarQueryParameterType("DATE", name="nested_date"),
            ScalarQueryParameterType("BOOLEAN", description="nested bool field"),
            name="nested",
        )
        param_type = self._make_one(
            int_type, nested_struct_type, name="foo", description="bar"
        )

        result = param_type.to_api_repr()

        expected_result = {
            "type": "STRUCT",
            "structTypes": [
                {"type": {"type": "INTEGER"}, "description": "in years"},
                {
                    "name": "nested",
                    "type": {
                        "type": "STRUCT",
                        "structTypes": [
                            {"type": {"type": "DATE"}, "name": "nested_date"},
                            {
                                "type": {"type": "BOOLEAN"},
                                "description": "nested bool field",
                            },
                        ],
                    },
                },
            ],
        }
        self.assertEqual(result, expected_result)

    def test_repr_no_optional_attrs(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType

        param_type = self._make_one(
            ScalarQueryParameterType("BOOLEAN"), ScalarQueryParameterType("STRING")
        )
        expected = (
            "StructQueryParameterType("
            "ScalarQueryParameterType('BOOLEAN'), ScalarQueryParameterType('STRING')"
            ")"
        )
        self.assertEqual(repr(param_type), expected)

    def test_repr_all_optional_attrs(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType

        param_type = self._make_one(
            ScalarQueryParameterType("BOOLEAN"),
            ScalarQueryParameterType("STRING"),
            name="data_record",
            description="this is it",
        )
        expected = (
            "StructQueryParameterType("
            "ScalarQueryParameterType('BOOLEAN'), ScalarQueryParameterType('STRING'), "
            "name='data_record', description='this is it'"
            ")"
        )
        self.assertEqual(repr(param_type), expected)


class Test_RangeQueryParameterType(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import RangeQueryParameterType

        return RangeQueryParameterType

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_ctor_str(self):
        param_type = self._make_one("DATE", name="foo", description="bar")
        self.assertEqual(param_type.type_._type, "DATE")
        self.assertEqual(param_type.name, "foo")
        self.assertEqual(param_type.description, "bar")

    def test_ctor_type(self):
        from google.cloud.bigquery import ScalarQueryParameterType

        scalar_type = ScalarQueryParameterType("DATE")
        param_type = self._make_one(scalar_type, name="foo", description="bar")
        self.assertEqual(param_type.type_._type, "DATE")
        self.assertEqual(param_type.name, "foo")
        self.assertEqual(param_type.description, "bar")

    def test_ctor_unsupported_type_str(self):
        with self.assertRaises(ValueError):
            self._make_one("TIME")

    def test_ctor_unsupported_type_type(self):
        from google.cloud.bigquery import ScalarQueryParameterType

        scalar_type = ScalarQueryParameterType("TIME")
        with self.assertRaises(ValueError):
            self._make_one(scalar_type)

    def test_ctor_wrong_type(self):
        with self.assertRaises(ValueError):
            self._make_one(None)

    def test_from_api_repr(self):
        RESOURCE = {
            "type": "RANGE",
            "rangeElementType": {"type": "DATE"},
        }

        klass = self._get_target_class()
        result = klass.from_api_repr(RESOURCE)
        self.assertEqual(result.type_._type, "DATE")
        self.assertIsNone(result.name)
        self.assertIsNone(result.description)

    def test_to_api_repr(self):
        EXPECTED = {
            "type": "RANGE",
            "rangeElementType": {"type": "DATE"},
        }
        param_type = self._make_one("DATE", name="foo", description="bar")
        result = param_type.to_api_repr()
        self.assertEqual(result, EXPECTED)

    def test__repr__(self):
        param_type = self._make_one("DATE", name="foo", description="bar")
        param_repr = "RangeQueryParameterType(ScalarQueryParameterType('DATE'), name='foo', description='bar')"
        self.assertEqual(repr(param_type), param_repr)

    def test__eq__(self):
        param_type1 = self._make_one("DATE", name="foo", description="bar")
        self.assertEqual(param_type1, param_type1)
        self.assertNotEqual(param_type1, object())

        alias = self._make_one("DATE", name="foo", description="bar")
        self.assertIsNot(param_type1, alias)
        self.assertEqual(param_type1, alias)

        wrong_type = self._make_one("DATETIME", name="foo", description="bar")
        self.assertNotEqual(param_type1, wrong_type)

        wrong_name = self._make_one("DATETIME", name="foo2", description="bar")
        self.assertNotEqual(param_type1, wrong_name)

        wrong_description = self._make_one("DATETIME", name="foo", description="bar2")
        self.assertNotEqual(param_type1, wrong_description)

    def test_with_name(self):
        param_type1 = self._make_one("DATE", name="foo", description="bar")
        param_type2 = param_type1.with_name("foo2")

        self.assertIsNot(param_type1, param_type2)
        self.assertEqual(param_type2.type_._type, "DATE")
        self.assertEqual(param_type2.name, "foo2")
        self.assertEqual(param_type2.description, "bar")


class Test__AbstractQueryParameter(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import _AbstractQueryParameter

        return _AbstractQueryParameter

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_from_api_virtual(self):
        klass = self._get_target_class()
        with self.assertRaises(NotImplementedError):
            klass.from_api_repr({})

    def test_to_api_virtual(self):
        param = self._make_one()
        with self.assertRaises(NotImplementedError):
            param.to_api_repr()


class Test_ScalarQueryParameter(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import ScalarQueryParameter

        return ScalarQueryParameter

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_ctor(self):
        param = self._make_one(name="foo", type_="INT64", value=123)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.type_, "INT64")
        self.assertEqual(param.value, 123)

    def test___eq__(self):
        param = self._make_one(name="foo", type_="INT64", value=123)
        self.assertEqual(param, param)
        self.assertNotEqual(param, object())
        alias = self._make_one(name="bar", type_="INT64", value=123)
        self.assertNotEqual(param, alias)
        wrong_type = self._make_one(name="foo", type_="FLOAT64", value=123.0)
        self.assertNotEqual(param, wrong_type)
        wrong_val = self._make_one(name="foo", type_="INT64", value=234)
        self.assertNotEqual(param, wrong_val)

    def test_positional(self):
        klass = self._get_target_class()
        param = klass.positional(type_="INT64", value=123)
        self.assertEqual(param.name, None)
        self.assertEqual(param.type_, "INT64")
        self.assertEqual(param.value, 123)

    def test_ctor_w_scalar_query_parameter_type(self):
        from google.cloud.bigquery import query

        param = self._make_one(
            name="foo",
            type_=query.SqlParameterScalarTypes.BIGNUMERIC,
            value=decimal.Decimal("123.456"),
        )
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.type_, "BIGNUMERIC")
        self.assertEqual(param.value, decimal.Decimal("123.456"))

    def test_from_api_repr_w_name(self):
        RESOURCE = {
            "name": "foo",
            "parameterType": {"type": "INT64"},
            "parameterValue": {"value": 123},
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.type_, "INT64")
        self.assertEqual(param.value, 123)

    def test_from_api_repr_wo_name(self):
        RESOURCE = {
            "parameterType": {"type": "INT64"},
            "parameterValue": {"value": "123"},
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, None)
        self.assertEqual(param.type_, "INT64")
        self.assertEqual(param.value, 123)

    def test_from_api_repr_wo_value(self):
        # Back-end may not send back values for None params. See #9027
        RESOURCE = {"name": "foo", "parameterType": {"type": "INT64"}}
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.type_, "INT64")
        self.assertIs(param.value, None)

    def test_to_api_repr_w_name(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {"type": "INT64"},
            "parameterValue": {"value": "123"},
        }
        param = self._make_one(name="foo", type_="INT64", value=123)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_wo_name(self):
        EXPECTED = {
            "parameterType": {"type": "INT64"},
            "parameterValue": {"value": "123"},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="INT64", value=123)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_float(self):
        EXPECTED = {
            "parameterType": {"type": "FLOAT64"},
            "parameterValue": {"value": 12.345},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="FLOAT64", value=12.345)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_numeric(self):
        EXPECTED = {
            "parameterType": {"type": "NUMERIC"},
            "parameterValue": {"value": "123456789.123456789"},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="NUMERIC", value="123456789.123456789")
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_bignumeric(self):
        big_num_string = "{d38}.{d38}".format(d38="9" * 38)
        EXPECTED = {
            "parameterType": {"type": "BIGNUMERIC"},
            "parameterValue": {"value": big_num_string},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="BIGNUMERIC", value=big_num_string)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_bool(self):
        EXPECTED = {
            "parameterType": {"type": "BOOL"},
            "parameterValue": {"value": "false"},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="BOOL", value=False)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_timestamp_datetime(self):
        from google.cloud._helpers import UTC

        STAMP = "2016-12-20 15:58:27.339328+00:00"
        when = datetime.datetime(2016, 12, 20, 15, 58, 27, 339328, tzinfo=UTC)
        EXPECTED = {
            "parameterType": {"type": "TIMESTAMP"},
            "parameterValue": {"value": STAMP},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="TIMESTAMP", value=when)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_timestamp_micros(self):
        from google.cloud._helpers import _microseconds_from_datetime

        now = datetime.datetime.utcnow()
        seconds = _microseconds_from_datetime(now) / 1.0e6
        EXPECTED = {
            "parameterType": {"type": "TIMESTAMP"},
            "parameterValue": {"value": seconds},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="TIMESTAMP", value=seconds)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_datetime_datetime(self):
        from google.cloud._helpers import _datetime_to_rfc3339

        now = datetime.datetime.utcnow()
        EXPECTED = {
            "parameterType": {"type": "DATETIME"},
            "parameterValue": {
                "value": _datetime_to_rfc3339(now)[:-1]  # strip trailing 'Z'
            },
        }
        klass = self._get_target_class()
        param = klass.positional(type_="DATETIME", value=now)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_datetime_string(self):
        from google.cloud._helpers import _datetime_to_rfc3339

        now = datetime.datetime.utcnow()
        now_str = _datetime_to_rfc3339(now)
        EXPECTED = {
            "parameterType": {"type": "DATETIME"},
            "parameterValue": {"value": now_str},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="DATETIME", value=now_str)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_date_date(self):
        today = datetime.date.today()
        EXPECTED = {
            "parameterType": {"type": "DATE"},
            "parameterValue": {"value": today.isoformat()},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="DATE", value=today)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_date_string(self):
        today = datetime.date.today()
        today_str = (today.isoformat(),)
        EXPECTED = {
            "parameterType": {"type": "DATE"},
            "parameterValue": {"value": today_str},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="DATE", value=today_str)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_unknown_type(self):
        EXPECTED = {
            "parameterType": {"type": "UNKNOWN"},
            "parameterValue": {"value": "unknown"},
        }
        klass = self._get_target_class()
        param = klass.positional(type_="UNKNOWN", value="unknown")
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test___eq___wrong_type(self):
        field = self._make_one("test", "STRING", "value")
        other = object()
        self.assertNotEqual(field, other)
        self.assertEqual(field, mock.ANY)

    def test___eq___name_mismatch(self):
        field = self._make_one("test", "STRING", "value")
        other = self._make_one("other", "STRING", "value")
        self.assertNotEqual(field, other)

    def test___eq___field_type_mismatch(self):
        field = self._make_one("test", "STRING", None)
        other = self._make_one("test", "INT64", None)
        self.assertNotEqual(field, other)

    def test___eq___value_mismatch(self):
        field = self._make_one("test", "STRING", "hello")
        other = self._make_one("test", "STRING", "world")
        self.assertNotEqual(field, other)

    def test___eq___hit(self):
        field = self._make_one("test", "STRING", "gotcha")
        other = self._make_one("test", "STRING", "gotcha")
        self.assertEqual(field, other)

    def test___ne___wrong_type(self):
        field = self._make_one("toast", "INT64", 13)
        other = object()
        self.assertNotEqual(field, other)
        self.assertEqual(field, mock.ANY)

    def test___ne___same_value(self):
        field1 = self._make_one("test", "INT64", 12)
        field2 = self._make_one("test", "INT64", 12)
        # unittest ``assertEqual`` uses ``==`` not ``!=``.
        comparison_val = field1 != field2
        self.assertFalse(comparison_val)

    def test___ne___different_values(self):
        field1 = self._make_one("test", "INT64", 11)
        field2 = self._make_one("test", "INT64", 12)
        self.assertNotEqual(field1, field2)

    def test___repr__(self):
        field1 = self._make_one("field1", "STRING", "value")
        expected = "ScalarQueryParameter('field1', 'STRING', 'value')"
        self.assertEqual(repr(field1), expected)


class Test_RangeQueryParameter(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import RangeQueryParameter

        return RangeQueryParameter

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_ctor(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATE")
        param = self._make_one(
            range_element_type="DATE", start="2016-08-11", name="foo"
        )
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, "2016-08-11")
        self.assertIs(param.end, None)

    def test_ctor_w_datetime_query_parameter_type_str(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATETIME")
        start_datetime = datetime.datetime(year=2020, month=12, day=31, hour=12)
        end_datetime = datetime.datetime(year=2021, month=12, day=31, hour=12)
        param = self._make_one(
            range_element_type="DATETIME",
            start=start_datetime,
            end=end_datetime,
            name="foo",
        )
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, start_datetime)
        self.assertEqual(param.end, end_datetime)
        self.assertEqual(param.name, "foo")

    def test_ctor_w_datetime_query_parameter_type_type(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATETIME")
        param = self._make_one(range_element_type=range_element_type)
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, None)
        self.assertEqual(param.end, None)
        self.assertEqual(param.name, None)

    def test_ctor_w_timestamp_query_parameter_typ_str(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="TIMESTAMP")
        start_datetime = datetime.datetime(year=2020, month=12, day=31, hour=12)
        end_datetime = datetime.datetime(year=2021, month=12, day=31, hour=12)
        param = self._make_one(
            range_element_type="TIMESTAMP",
            start=start_datetime,
            end=end_datetime,
            name="foo",
        )
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, start_datetime)
        self.assertEqual(param.end, end_datetime)
        self.assertEqual(param.name, "foo")

    def test_ctor_w_timestamp_query_parameter_type_type(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="TIMESTAMP")
        param = self._make_one(range_element_type=range_element_type)
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, None)
        self.assertEqual(param.end, None)
        self.assertEqual(param.name, None)

    def test_ctor_w_date_query_parameter_type_str(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATE")
        start_date = datetime.date(year=2020, month=12, day=31)
        end_date = datetime.date(year=2021, month=12, day=31)
        param = self._make_one(
            range_element_type="DATE",
            start=start_date,
            end=end_date,
            name="foo",
        )
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, start_date)
        self.assertEqual(param.end, end_date)
        self.assertEqual(param.name, "foo")

    def test_ctor_w_date_query_parameter_type_type(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATE")
        param = self._make_one(range_element_type=range_element_type)
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, None)
        self.assertEqual(param.end, None)
        self.assertEqual(param.name, None)

    def test_ctor_w_name_empty_str(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATE")
        param = self._make_one(
            range_element_type="DATE",
            name="",
        )
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertIs(param.start, None)
        self.assertIs(param.end, None)
        self.assertEqual(param.name, "")

    def test_ctor_wo_value(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATETIME")
        param = self._make_one(range_element_type="DATETIME", name="foo")
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertIs(param.start, None)
        self.assertIs(param.end, None)
        self.assertEqual(param.name, "foo")

    def test_ctor_w_unsupported_query_parameter_type_str(self):
        with self.assertRaises(ValueError):
            self._make_one(range_element_type="TIME", name="foo")

    def test_ctor_w_unsupported_query_parameter_type_type(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATE")
        range_element_type.type_._type = "TIME"
        with self.assertRaises(ValueError):
            self._make_one(range_element_type=range_element_type, name="foo")

    def test_ctor_w_unsupported_query_parameter_type_input(self):
        with self.assertRaises(ValueError):
            self._make_one(range_element_type=None, name="foo")

    def test_positional(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        range_element_type = RangeQueryParameterType(type_="DATE")
        klass = self._get_target_class()
        param = klass.positional(
            range_element_type="DATE", start="2016-08-11", end="2016-08-12"
        )
        self.assertIs(param.name, None)
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, "2016-08-11")
        self.assertEqual(param.end, "2016-08-12")

    def test_from_api_repr_w_name(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        RESOURCE = {
            "name": "foo",
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": "2020-12-31"}}
            },
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        range_element_type = RangeQueryParameterType(type_="DATE")
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, None)
        self.assertEqual(param.end, "2020-12-31")

    def test_from_api_repr_wo_name(self):
        from google.cloud.bigquery.query import RangeQueryParameterType

        RESOURCE = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": "2020-12-31"}}
            },
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        range_element_type = RangeQueryParameterType(type_="DATE")
        self.assertEqual(param.name, None)
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertEqual(param.start, None)
        self.assertEqual(param.end, "2020-12-31")

    def test_from_api_repr_wo_value(self):
        # Back-end may not send back values for None params. See #9027
        from google.cloud.bigquery.query import RangeQueryParameterType

        RESOURCE = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
        }
        range_element_type = RangeQueryParameterType(type_="DATE")
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertIs(param.name, None)
        self.assertEqual(param.range_element_type, range_element_type)
        self.assertIs(param.start, None)
        self.assertIs(param.end, None)

    def test_to_api_repr_w_name(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": "2016-08-11"}}
            },
        }
        param = self._make_one(range_element_type="DATE", end="2016-08-11", name="foo")
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_wo_name(self):
        EXPECTED = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": "2016-08-11"}}
            },
        }
        klass = self._get_target_class()
        param = klass.positional(range_element_type="DATE", end="2016-08-11")
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_date_date(self):
        today = datetime.date.today()
        today_str = today.strftime("%Y-%m-%d")
        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": today_str}}
            },
        }
        param = self._make_one(range_element_type="DATE", end=today, name="foo")
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_datetime_str(self):
        EXPECTED = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATETIME",
                },
            },
            "parameterValue": {
                "rangeValue": {
                    "start": {"value": None},
                    "end": {"value": "2020-01-01T12:00:00.000000"},
                }
            },
        }
        klass = self._get_target_class()
        end_datetime = datetime.datetime(year=2020, month=1, day=1, hour=12)
        param = klass.positional(range_element_type="DATETIME", end=end_datetime)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_datetime_datetime(self):
        from google.cloud.bigquery._helpers import _RFC3339_MICROS_NO_ZULU

        now = datetime.datetime.utcnow()
        now_str = now.strftime(_RFC3339_MICROS_NO_ZULU)
        EXPECTED = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATETIME",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": now_str}}
            },
        }
        klass = self._get_target_class()
        param = klass.positional(range_element_type="DATETIME", end=now)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_timestamp_str(self):
        EXPECTED = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "TIMESTAMP",
                },
            },
            "parameterValue": {
                "rangeValue": {
                    "start": {"value": None},
                    "end": {"value": "2020-01-01 12:00:00+00:00"},
                }
            },
        }
        klass = self._get_target_class()
        end_timestamp = datetime.datetime(year=2020, month=1, day=1, hour=12)
        param = klass.positional(range_element_type="TIMESTAMP", end=end_timestamp)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_timestamp_timestamp(self):
        from google.cloud._helpers import UTC  # type: ignore

        now = datetime.datetime.utcnow()
        now = now.astimezone(UTC)
        now_str = str(now)
        EXPECTED = {
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "TIMESTAMP",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": now_str}}
            },
        }
        klass = self._get_target_class()
        param = klass.positional(range_element_type="TIMESTAMP", end=now)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_wo_values(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "RANGE",
                "rangeElementType": {
                    "type": "DATE",
                },
            },
            "parameterValue": {
                "rangeValue": {"start": {"value": None}, "end": {"value": None}}
            },
        }
        param = self._make_one(range_element_type="DATE", name="foo")
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_unsupported_value_type(self):
        with self.assertRaisesRegex(
            ValueError, "Cannot convert range element value from type"
        ):
            range_param = self._make_one(
                range_element_type="DATE", start=datetime.date.today()
            )
            range_param.range_element_type.type_._type = "LONG"
            range_param.to_api_repr()

    def test___eq__(self):
        param = self._make_one(
            range_element_type="DATE", start="2016-08-11", name="foo"
        )
        self.assertEqual(param, param)
        self.assertNotEqual(param, object())
        alias = self._make_one(
            range_element_type="DATE", start="2016-08-11", name="bar"
        )
        self.assertNotEqual(param, alias)
        wrong_type = self._make_one(
            range_element_type="DATETIME",
            start="2020-12-31 12:00:00.000000",
            name="foo",
        )
        self.assertNotEqual(param, wrong_type)
        wrong_val = self._make_one(
            range_element_type="DATE", start="2016-08-12", name="foo"
        )
        self.assertNotEqual(param, wrong_val)

    def test___eq___wrong_type(self):
        param = self._make_one(
            range_element_type="DATE", start="2016-08-11", name="foo"
        )
        other = object()
        self.assertNotEqual(param, other)
        self.assertEqual(param, mock.ANY)

    def test___eq___name_mismatch(self):
        param = self._make_one(
            range_element_type="DATE", start="2016-08-11", name="foo"
        )
        other = self._make_one(
            range_element_type="DATE", start="2016-08-11", name="bar"
        )
        self.assertNotEqual(param, other)

    def test___eq___field_type_mismatch(self):
        param = self._make_one(range_element_type="DATE")
        other = self._make_one(range_element_type="DATETIME")
        self.assertNotEqual(param, other)

    def test___eq___value_mismatch(self):
        param = self._make_one(range_element_type="DATE", start="2016-08-11")
        other = self._make_one(range_element_type="DATE", start="2016-08-12")
        self.assertNotEqual(param, other)

    def test___eq___hit(self):
        param = self._make_one(range_element_type="DATE", start="2016-08-12")
        other = self._make_one(range_element_type="DATE", start="2016-08-12")
        self.assertEqual(param, other)

    def test___ne___wrong_type(self):
        param = self._make_one(range_element_type="DATE")
        other = object()
        self.assertNotEqual(param, other)
        self.assertEqual(param, mock.ANY)

    def test___ne___same_value(self):
        param1 = self._make_one(range_element_type="DATE")
        param2 = self._make_one(range_element_type="DATE")
        # unittest ``assertEqual`` uses ``==`` not ``!=``.
        comparison_val = param1 != param2
        self.assertFalse(comparison_val)

    def test___ne___different_values(self):
        param1 = self._make_one(range_element_type="DATE", start="2016-08-12")
        param2 = self._make_one(range_element_type="DATE")
        self.assertNotEqual(param1, param2)

    def test___repr__(self):
        param1 = self._make_one(range_element_type="DATE", start="2016-08-12")
        expected = "RangeQueryParameter(None, {'type': 'RANGE', 'rangeElementType': {'type': 'DATE'}}, '2016-08-12', None)"
        self.assertEqual(repr(param1), expected)


def _make_subparam(name, type_, value):
    from google.cloud.bigquery.query import ScalarQueryParameter

    return ScalarQueryParameter(name, type_, value)


class Test_ArrayQueryParameter(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import ArrayQueryParameter

        return ArrayQueryParameter

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_ctor(self):
        param = self._make_one(name="foo", array_type="INT64", values=[1, 2])
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.array_type, "INT64")
        self.assertEqual(param.values, [1, 2])

    def test_ctor_empty_struct_array_wo_type_info(self):
        with self.assertRaisesRegex(ValueError, r"(?i)missing.*struct.*type info.*"):
            self._make_one(name="foo", array_type="STRUCT", values=[])

    def test___eq__(self):
        param = self._make_one(name="foo", array_type="INT64", values=[123])
        self.assertEqual(param, param)
        self.assertNotEqual(param, object())
        alias = self._make_one(name="bar", array_type="INT64", values=[123])
        self.assertNotEqual(param, alias)
        wrong_type = self._make_one(name="foo", array_type="FLOAT64", values=[123.0])
        self.assertNotEqual(param, wrong_type)
        wrong_val = self._make_one(name="foo", array_type="INT64", values=[234])
        self.assertNotEqual(param, wrong_val)

    def test_positional(self):
        klass = self._get_target_class()
        param = klass.positional(array_type="INT64", values=[1, 2])
        self.assertEqual(param.name, None)
        self.assertEqual(param.array_type, "INT64")
        self.assertEqual(param.values, [1, 2])

    def test_from_api_repr_w_name(self):
        RESOURCE = {
            "name": "foo",
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
            "parameterValue": {"arrayValues": [{"value": "1"}, {"value": "2"}]},
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.array_type, "INT64")
        self.assertEqual(param.values, [1, 2])

    def test_from_api_repr_wo_name(self):
        RESOURCE = {
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
            "parameterValue": {"arrayValues": [{"value": "1"}, {"value": "2"}]},
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, None)
        self.assertEqual(param.array_type, "INT64")
        self.assertEqual(param.values, [1, 2])

    def test_from_api_repr_wo_values(self):
        # Back-end may not send back values for empty array params. See #7309
        RESOURCE = {
            "name": "foo",
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.array_type, "INT64")
        self.assertEqual(param.values, [])

    def test_from_api_repr_w_none_values(self):
        RESOURCE = {
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
            "parameterValue": {"arrayValues": [{"value": "1"}, {"value": None}]},
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.array_type, "INT64")
        self.assertEqual(param.values, [1, None])

    def test_from_api_repr_w_struct_type(self):
        from google.cloud.bigquery.query import StructQueryParameter

        RESOURCE = {
            "parameterType": {
                "type": "ARRAY",
                "arrayType": {
                    "type": "STRUCT",
                    "structTypes": [
                        {"name": "name", "type": {"type": "STRING"}},
                        {"name": "age", "type": {"type": "INT64"}},
                    ],
                },
            },
            "parameterValue": {
                "arrayValues": [
                    {
                        "structValues": {
                            "name": {"value": "Phred Phlyntstone"},
                            "age": {"value": "32"},
                        }
                    },
                    {
                        "structValues": {
                            "name": {"value": "Bharney Rhubbyl"},
                            "age": {"value": "31"},
                        }
                    },
                ]
            },
        }

        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)

        phred = StructQueryParameter.positional(
            _make_subparam("name", "STRING", "Phred Phlyntstone"),
            _make_subparam("age", "INT64", 32),
        )
        bharney = StructQueryParameter.positional(
            _make_subparam("name", "STRING", "Bharney Rhubbyl"),
            _make_subparam("age", "INT64", 31),
        )
        self.assertEqual(param.array_type, "STRUCT")
        self.assertEqual(param.values, [phred, bharney])

    def test_to_api_repr_w_name(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
            "parameterValue": {"arrayValues": [{"value": "1"}, {"value": "2"}]},
        }
        param = self._make_one(name="foo", array_type="INT64", values=[1, 2])
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_wo_name(self):
        EXPECTED = {
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
            "parameterValue": {"arrayValues": [{"value": "1"}, {"value": "2"}]},
        }
        klass = self._get_target_class()
        param = klass.positional(array_type="INT64", values=[1, 2])
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_array_type_as_type_instance(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType

        EXPECTED = {
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "BOOLEAN"}},
            "parameterValue": {"arrayValues": [{"value": "true"}, {"value": "false"}]},
        }
        klass = self._get_target_class()
        param = klass.positional(
            array_type=ScalarQueryParameterType("BOOLEAN"),
            values=[True, False],
        )
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_unknown_type(self):
        EXPECTED = {
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "UNKNOWN"}},
            "parameterValue": {"arrayValues": [{"value": "unknown"}]},
        }
        klass = self._get_target_class()
        param = klass.positional(array_type="UNKNOWN", values=["unknown"])
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_record_type(self):
        from google.cloud.bigquery.query import StructQueryParameter

        EXPECTED = {
            "parameterType": {
                "type": "ARRAY",
                "arrayType": {
                    "type": "STRUCT",
                    "structTypes": [
                        {"name": "foo", "type": {"type": "STRING"}},
                        {"name": "bar", "type": {"type": "INT64"}},
                    ],
                },
            },
            "parameterValue": {
                "arrayValues": [
                    {"structValues": {"foo": {"value": "Foo"}, "bar": {"value": "123"}}}
                ]
            },
        }
        one = _make_subparam("foo", "STRING", "Foo")
        another = _make_subparam("bar", "INT64", 123)
        struct = StructQueryParameter.positional(one, another)
        klass = self._get_target_class()
        param = klass.positional(array_type="RECORD", values=[struct])
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_empty_array_of_records_type(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType
        from google.cloud.bigquery.query import StructQueryParameterType

        EXPECTED = {
            "parameterType": {
                "type": "ARRAY",
                "arrayType": {
                    "type": "STRUCT",
                    "structTypes": [
                        {"name": "foo", "type": {"type": "STRING"}},
                        {"name": "bar", "type": {"type": "INT64"}},
                    ],
                },
            },
            "parameterValue": {"arrayValues": []},
        }
        item_type = StructQueryParameterType(
            ScalarQueryParameterType("STRING", name="foo"),
            ScalarQueryParameterType("INT64", name="bar"),
        )
        klass = self._get_target_class()
        param = klass.positional(array_type=item_type, values=[])
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test___eq___wrong_type(self):
        field = self._make_one("test", "STRING", ["value"])
        other = object()
        self.assertNotEqual(field, other)
        self.assertEqual(field, mock.ANY)

    def test___eq___name_mismatch(self):
        field = self._make_one("field", "STRING", ["value"])
        other = self._make_one("other", "STRING", ["value"])
        self.assertNotEqual(field, other)

    def test___eq___field_type_mismatch(self):
        field = self._make_one("test", "STRING", [])
        other = self._make_one("test", "INT64", [])
        self.assertNotEqual(field, other)

    def test___eq___value_mismatch(self):
        field = self._make_one("test", "STRING", ["hello"])
        other = self._make_one("test", "STRING", ["hello", "world"])
        self.assertNotEqual(field, other)

    def test___eq___hit(self):
        field = self._make_one("test", "STRING", ["gotcha"])
        other = self._make_one("test", "STRING", ["gotcha"])
        self.assertEqual(field, other)

    def test___ne___wrong_type(self):
        field = self._make_one("toast", "INT64", [13])
        other = object()
        self.assertNotEqual(field, other)
        self.assertEqual(field, mock.ANY)

    def test___ne___same_value(self):
        field1 = self._make_one("test", "INT64", [12])
        field2 = self._make_one("test", "INT64", [12])
        # unittest ``assertEqual`` uses ``==`` not ``!=``.
        comparison_val = field1 != field2
        self.assertFalse(comparison_val)

    def test___ne___different_values(self):
        field1 = self._make_one("test", "INT64", [11])
        field2 = self._make_one("test", "INT64", [12])
        self.assertNotEqual(field1, field2)

    def test___repr__array_type_str(self):
        field1 = self._make_one("field1", "STRING", ["value"])
        expected = "ArrayQueryParameter('field1', 'STRING', ['value'])"
        self.assertEqual(repr(field1), expected)

    def test___repr__array_type_scalar_type_instance(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType

        int_items = self._make_one(
            "int_items", ScalarQueryParameterType("INTEGER"), [64]
        )
        expected = "ArrayQueryParameter('int_items', 'INTEGER', [64])"
        self.assertEqual(repr(int_items), expected)

    def test___repr__array_type_struct_type_instance(self):
        from google.cloud.bigquery.query import ScalarQueryParameterType
        from google.cloud.bigquery.query import StructQueryParameterType

        struct_items = self._make_one(
            "struct_items",
            StructQueryParameterType(
                ScalarQueryParameterType("INTEGER", name="age"),
                ScalarQueryParameterType("STRING", name="last_name"),
            ),
            [{"age": 18, "last_name": "Doe"}],
        )
        expected = (
            "ArrayQueryParameter('struct_items', 'STRUCT', "
            "[{'age': 18, 'last_name': 'Doe'}])"
        )
        self.assertEqual(repr(struct_items), expected)


class Test_StructQueryParameter(unittest.TestCase):
    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import StructQueryParameter

        return StructQueryParameter

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def test_ctor(self):
        sub_1 = _make_subparam("bar", "INT64", 123)
        sub_2 = _make_subparam("baz", "STRING", "abc")
        param = self._make_one("foo", sub_1, sub_2)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.struct_types, {"bar": "INT64", "baz": "STRING"})
        self.assertEqual(param.struct_values, {"bar": 123, "baz": "abc"})

    def test___eq__(self):
        sub_1 = _make_subparam("bar", "INT64", 123)
        sub_2 = _make_subparam("baz", "STRING", "abc")
        sub_3 = _make_subparam("baz", "STRING", "def")
        sub_1_float = _make_subparam("bar", "FLOAT64", 123.0)
        param = self._make_one("foo", sub_1, sub_2)
        self.assertEqual(param, param)
        self.assertNotEqual(param, object())
        alias = self._make_one("bar", sub_1, sub_2)
        self.assertNotEqual(param, alias)
        wrong_type = self._make_one("foo", sub_1_float, sub_2)
        self.assertNotEqual(param, wrong_type)
        wrong_val = self._make_one("foo", sub_2, sub_3)
        self.assertNotEqual(param, wrong_val)

    def test_positional(self):
        sub_1 = _make_subparam("bar", "INT64", 123)
        sub_2 = _make_subparam("baz", "STRING", "abc")
        klass = self._get_target_class()
        param = klass.positional(sub_1, sub_2)
        self.assertEqual(param.name, None)
        self.assertEqual(param.struct_types, {"bar": "INT64", "baz": "STRING"})
        self.assertEqual(param.struct_values, {"bar": 123, "baz": "abc"})

    def test_from_api_repr_w_name(self):
        RESOURCE = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "INT64"}},
                    {"name": "baz", "type": {"type": "STRING"}},
                ],
            },
            "parameterValue": {
                "structValues": {"bar": {"value": 123}, "baz": {"value": "abc"}}
            },
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.struct_types, {"bar": "INT64", "baz": "STRING"})
        self.assertEqual(param.struct_values, {"bar": 123, "baz": "abc"})

    def test_from_api_repr_wo_name(self):
        RESOURCE = {
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "INT64"}},
                    {"name": "baz", "type": {"type": "STRING"}},
                ],
            },
            "parameterValue": {
                "structValues": {"bar": {"value": 123}, "baz": {"value": "abc"}}
            },
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(param.name, None)
        self.assertEqual(param.struct_types, {"bar": "INT64", "baz": "STRING"})
        self.assertEqual(param.struct_values, {"bar": 123, "baz": "abc"})

    def test_from_api_repr_w_nested_array(self):
        from google.cloud.bigquery.query import ArrayQueryParameter

        RESOURCE = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "STRING"}},
                    {
                        "name": "baz",
                        "type": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
                    },
                ],
            },
            "parameterValue": {
                "structValues": {
                    "bar": {"value": "abc"},
                    "baz": {"arrayValues": [{"value": "123"}, {"value": "456"}]},
                }
            },
        }
        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)
        self.assertEqual(
            param,
            self._make_one(
                "foo",
                _make_subparam("bar", "STRING", "abc"),
                ArrayQueryParameter("baz", "INT64", [123, 456]),
            ),
        )

    def test_from_api_repr_w_nested_struct(self):
        RESOURCE = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "STRING"}},
                    {
                        "name": "baz",
                        "type": {
                            "type": "STRUCT",
                            "structTypes": [
                                {"name": "qux", "type": {"type": "INT64"}},
                                {"name": "spam", "type": {"type": "BOOL"}},
                            ],
                        },
                    },
                ],
            },
            "parameterValue": {
                "structValues": {
                    "bar": {"value": "abc"},
                    "baz": {
                        "structValues": {
                            "qux": {"value": "123"},
                            "spam": {"value": "true"},
                        }
                    },
                }
            },
        }

        klass = self._get_target_class()
        param = klass.from_api_repr(RESOURCE)

        expected = self._make_one(
            "foo",
            _make_subparam("bar", "STRING", "abc"),
            self._make_one(
                "baz",
                _make_subparam("qux", "INT64", 123),
                _make_subparam("spam", "BOOL", True),
            ),
        )
        self.assertEqual(param.name, "foo")
        self.assertEqual(param.struct_types, expected.struct_types)
        self.assertEqual(param.struct_values, expected.struct_values)

    def test_to_api_repr_w_name(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "INT64"}},
                    {"name": "baz", "type": {"type": "STRING"}},
                ],
            },
            "parameterValue": {
                "structValues": {"bar": {"value": "123"}, "baz": {"value": "abc"}}
            },
        }
        sub_1 = _make_subparam("bar", "INT64", 123)
        sub_2 = _make_subparam("baz", "STRING", "abc")
        param = self._make_one("foo", sub_1, sub_2)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_wo_name(self):
        EXPECTED = {
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "INT64"}},
                    {"name": "baz", "type": {"type": "STRING"}},
                ],
            },
            "parameterValue": {
                "structValues": {"bar": {"value": "123"}, "baz": {"value": "abc"}}
            },
        }
        sub_1 = _make_subparam("bar", "INT64", 123)
        sub_2 = _make_subparam("baz", "STRING", "abc")
        klass = self._get_target_class()
        param = klass.positional(sub_1, sub_2)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_nested_array(self):
        from google.cloud.bigquery.query import ArrayQueryParameter

        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "STRING"}},
                    {
                        "name": "baz",
                        "type": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
                    },
                ],
            },
            "parameterValue": {
                "structValues": {
                    "bar": {"value": "abc"},
                    "baz": {"arrayValues": [{"value": "123"}, {"value": "456"}]},
                }
            },
        }
        scalar = _make_subparam("bar", "STRING", "abc")
        array = ArrayQueryParameter("baz", "INT64", [123, 456])
        param = self._make_one("foo", scalar, array)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_nested_struct(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "STRING"}},
                    {
                        "name": "baz",
                        "type": {
                            "type": "STRUCT",
                            "structTypes": [
                                {"name": "qux", "type": {"type": "INT64"}},
                                {"name": "spam", "type": {"type": "BOOL"}},
                            ],
                        },
                    },
                ],
            },
            "parameterValue": {
                "structValues": {
                    "bar": {"value": "abc"},
                    "baz": {
                        "structValues": {
                            "qux": {"value": "123"},
                            "spam": {"value": "true"},
                        }
                    },
                }
            },
        }
        scalar_1 = _make_subparam("bar", "STRING", "abc")
        scalar_2 = _make_subparam("qux", "INT64", 123)
        scalar_3 = _make_subparam("spam", "BOOL", True)
        sub = self._make_one("baz", scalar_2, scalar_3)
        param = self._make_one("foo", scalar_1, sub)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test_to_api_repr_w_unknown_type(self):
        EXPECTED = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "bar", "type": {"type": "INT64"}},
                    {"name": "baz", "type": {"type": "UNKNOWN_TYPE"}},
                ],
            },
            "parameterValue": {
                "structValues": {"bar": {"value": "123"}, "baz": {"value": "abc"}}
            },
        }
        sub_1 = _make_subparam("bar", "INT64", 123)
        sub_2 = _make_subparam("baz", "UNKNOWN_TYPE", "abc")
        param = self._make_one("foo", sub_1, sub_2)
        self.assertEqual(param.to_api_repr(), EXPECTED)

    def test___eq___wrong_type(self):
        field = self._make_one("test", _make_subparam("bar", "STRING", "abc"))
        other = object()
        self.assertNotEqual(field, other)
        self.assertEqual(field, mock.ANY)

    def test___eq___name_mismatch(self):
        field = self._make_one("test", _make_subparam("bar", "STRING", "abc"))
        other = self._make_one("other ", _make_subparam("bar", "STRING", "abc"))
        self.assertNotEqual(field, other)

    def test___eq___field_type_mismatch(self):
        field = self._make_one("test", _make_subparam("bar", "STRING", None))
        other = self._make_one("test", _make_subparam("bar", "INT64", None))
        self.assertNotEqual(field, other)

    def test___eq___value_mismatch(self):
        field = self._make_one("test", _make_subparam("bar", "STRING", "hello"))
        other = self._make_one("test", _make_subparam("bar", "STRING", "world"))
        self.assertNotEqual(field, other)

    def test___eq___hit(self):
        field = self._make_one("test", _make_subparam("bar", "STRING", "gotcha"))
        other = self._make_one("test", _make_subparam("bar", "STRING", "gotcha"))
        self.assertEqual(field, other)

    def test___ne___wrong_type(self):
        field = self._make_one("test", _make_subparam("bar", "STRING", "hello"))
        other = object()
        self.assertNotEqual(field, other)
        self.assertEqual(field, mock.ANY)

    def test___ne___same_value(self):
        field1 = self._make_one("test", _make_subparam("bar", "STRING", "hello"))
        field2 = self._make_one("test", _make_subparam("bar", "STRING", "hello"))
        # unittest ``assertEqual`` uses ``==`` not ``!=``.
        comparison_val = field1 != field2
        self.assertFalse(comparison_val)

    def test___ne___different_values(self):
        field1 = self._make_one("test", _make_subparam("bar", "STRING", "hello"))
        field2 = self._make_one("test", _make_subparam("bar", "STRING", "world"))
        self.assertNotEqual(field1, field2)

    def test___repr__(self):
        field1 = self._make_one("test", _make_subparam("field1", "STRING", "hello"))
        got = repr(field1)
        self.assertIn("StructQueryParameter", got)
        self.assertIn("'field1': 'hello'", got)


class Test_QueryResults(unittest.TestCase):
    PROJECT = "project"
    JOB_ID = "test-synchronous-query"
    TOKEN = "TOKEN"

    @staticmethod
    def _get_target_class():
        from google.cloud.bigquery.query import _QueryResults

        return _QueryResults

    def _make_one(self, *args, **kw):
        return self._get_target_class()(*args, **kw)

    def _make_resource(self):
        return {"jobReference": {"projectId": self.PROJECT, "jobId": self.JOB_ID}}

    def _verifySchema(self, query, resource):
        from google.cloud.bigquery.schema import SchemaField

        if "schema" in resource:
            fields = resource["schema"]["fields"]
            self.assertEqual(len(query.schema), len(fields))
            for found, expected in zip(query.schema, fields):
                self.assertIsInstance(found, SchemaField)
                self.assertEqual(found.name, expected["name"])
                self.assertEqual(found.field_type, expected["type"])
                self.assertEqual(found.mode, expected["mode"])
                self.assertEqual(found.description, expected.get("description"))
                self.assertEqual(found.fields, expected.get("fields", ()))
        else:
            self.assertEqual(query.schema, [])

    def test_ctor_defaults(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.cache_hit)
        self.assertIsNone(query.complete)
        self.assertIsNone(query.errors)
        self.assertIsNone(query.page_token)
        self.assertEqual(query.project, self.PROJECT)
        self.assertEqual(query.rows, [])
        self.assertEqual(query.schema, [])
        self.assertIsNone(query.total_rows)
        self.assertIsNone(query.total_bytes_processed)

    def test_cache_hit_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.cache_hit)

    def test_cache_hit_present(self):
        resource = self._make_resource()
        resource["cacheHit"] = True
        query = self._make_one(resource)
        self.assertTrue(query.cache_hit)

    def test_complete_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.complete)

    def test_complete_present(self):
        resource = self._make_resource()
        resource["jobComplete"] = True
        query = self._make_one(resource)
        self.assertTrue(query.complete)

    def test_errors_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.errors)

    def test_errors_present(self):
        ERRORS = [{"reason": "testing"}]
        resource = self._make_resource()
        resource["errors"] = ERRORS
        query = self._make_one(resource)
        self.assertEqual(query.errors, ERRORS)

    def test_job_id_missing(self):
        query = self._make_one({})
        self.assertIsNone(query.job_id)

    def test_job_id_broken_job_reference(self):
        resource = {"jobReference": {"bogus": "BOGUS"}}
        query = self._make_one(resource)
        self.assertIsNone(query.job_id)

    def test_job_id_present(self):
        resource = self._make_resource()
        resource["jobReference"]["jobId"] = "custom-job"
        query = self._make_one(resource)
        self.assertEqual(query.job_id, "custom-job")

    def test_location_missing(self):
        query = self._make_one({})
        self.assertIsNone(query.location)

    def test_location_present(self):
        resource = self._make_resource()
        resource["jobReference"]["location"] = "test-location"
        query = self._make_one(resource)
        self.assertEqual(query.location, "test-location")

    def test_page_token_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.page_token)

    def test_page_token_present(self):
        resource = self._make_resource()
        resource["pageToken"] = "TOKEN"
        query = self._make_one(resource)
        self.assertEqual(query.page_token, "TOKEN")

    def test_query_id_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.query_id)

    def test_query_id_present(self):
        resource = self._make_resource()
        resource["queryId"] = "test-query-id"
        query = self._make_one(resource)
        self.assertEqual(query.query_id, "test-query-id")

    def test_total_rows_present_integer(self):
        resource = self._make_resource()
        resource["totalRows"] = 42
        query = self._make_one(resource)
        self.assertEqual(query.total_rows, 42)

    def test_total_rows_present_string(self):
        resource = self._make_resource()
        resource["totalRows"] = "42"
        query = self._make_one(resource)
        self.assertEqual(query.total_rows, 42)

    def test_total_bytes_processed_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.total_bytes_processed)

    def test_total_bytes_processed_present_integer(self):
        resource = self._make_resource()
        resource["totalBytesProcessed"] = 123456
        query = self._make_one(resource)
        self.assertEqual(query.total_bytes_processed, 123456)

    def test_total_bytes_processed_present_string(self):
        resource = self._make_resource()
        resource["totalBytesProcessed"] = "123456"
        query = self._make_one(resource)
        self.assertEqual(query.total_bytes_processed, 123456)

    def test_num_dml_affected_rows_missing(self):
        query = self._make_one(self._make_resource())
        self.assertIsNone(query.num_dml_affected_rows)

    def test_num_dml_affected_rows_present_integer(self):
        resource = self._make_resource()
        resource["numDmlAffectedRows"] = 123456
        query = self._make_one(resource)
        self.assertEqual(query.num_dml_affected_rows, 123456)

    def test_num_dml_affected_rows_present_string(self):
        resource = self._make_resource()
        resource["numDmlAffectedRows"] = "123456"
        query = self._make_one(resource)
        self.assertEqual(query.num_dml_affected_rows, 123456)

    def test_schema(self):
        query = self._make_one(self._make_resource())
        self._verifySchema(query, self._make_resource())
        resource = self._make_resource()
        resource["schema"] = {
            "fields": [
                {"name": "full_name", "type": "STRING", "mode": "REQURED"},
                {"name": "age", "type": "INTEGER", "mode": "REQURED"},
            ]
        }
        query._set_properties(resource)
        self._verifySchema(query, resource)


class Test__query_param_from_api_repr(unittest.TestCase):
    @staticmethod
    def _call_fut(resource):
        from google.cloud.bigquery.query import _query_param_from_api_repr

        return _query_param_from_api_repr(resource)

    def test_w_scalar(self):
        from google.cloud.bigquery.query import ScalarQueryParameter

        RESOURCE = {
            "name": "foo",
            "parameterType": {"type": "INT64"},
            "parameterValue": {"value": "123"},
        }

        parameter = self._call_fut(RESOURCE)

        self.assertIsInstance(parameter, ScalarQueryParameter)
        self.assertEqual(parameter.name, "foo")
        self.assertEqual(parameter.type_, "INT64")
        self.assertEqual(parameter.value, 123)

    def test_w_scalar_timestamp(self):
        from google.cloud._helpers import UTC
        from google.cloud.bigquery.query import ScalarQueryParameter

        RESOURCE = {
            "name": "zoned",
            "parameterType": {"type": "TIMESTAMP"},
            "parameterValue": {"value": "2012-03-04 05:06:07+00:00"},
        }

        parameter = self._call_fut(RESOURCE)

        self.assertIsInstance(parameter, ScalarQueryParameter)
        self.assertEqual(parameter.name, "zoned")
        self.assertEqual(parameter.type_, "TIMESTAMP")
        self.assertEqual(
            parameter.value, datetime.datetime(2012, 3, 4, 5, 6, 7, tzinfo=UTC)
        )

    def test_w_scalar_timestamp_micros(self):
        from google.cloud._helpers import UTC
        from google.cloud.bigquery.query import ScalarQueryParameter

        RESOURCE = {
            "name": "zoned",
            "parameterType": {"type": "TIMESTAMP"},
            "parameterValue": {"value": "2012-03-04 05:06:07.250000+00:00"},
        }

        parameter = self._call_fut(RESOURCE)

        self.assertIsInstance(parameter, ScalarQueryParameter)
        self.assertEqual(parameter.name, "zoned")
        self.assertEqual(parameter.type_, "TIMESTAMP")
        self.assertEqual(
            parameter.value, datetime.datetime(2012, 3, 4, 5, 6, 7, 250000, tzinfo=UTC)
        )

    def test_w_array(self):
        from google.cloud.bigquery.query import ArrayQueryParameter

        RESOURCE = {
            "name": "foo",
            "parameterType": {"type": "ARRAY", "arrayType": {"type": "INT64"}},
            "parameterValue": {"arrayValues": [{"value": "123"}]},
        }

        parameter = self._call_fut(RESOURCE)

        self.assertIsInstance(parameter, ArrayQueryParameter)
        self.assertEqual(parameter.name, "foo")
        self.assertEqual(parameter.array_type, "INT64")
        self.assertEqual(parameter.values, [123])

    def test_w_struct(self):
        from google.cloud.bigquery.query import StructQueryParameter

        RESOURCE = {
            "name": "foo",
            "parameterType": {
                "type": "STRUCT",
                "structTypes": [
                    {"name": "foo", "type": {"type": "STRING"}},
                    {"name": "bar", "type": {"type": "INT64"}},
                ],
            },
            "parameterValue": {
                "structValues": {"foo": {"value": "Foo"}, "bar": {"value": "123"}}
            },
        }

        parameter = self._call_fut(RESOURCE)

        self.assertIsInstance(parameter, StructQueryParameter)
        self.assertEqual(parameter.name, "foo")
        self.assertEqual(parameter.struct_types, {"foo": "STRING", "bar": "INT64"})
        self.assertEqual(parameter.struct_values, {"foo": "Foo", "bar": 123})