diff --git a/.cross_sync/README.md b/.cross_sync/README.md
new file mode 100644
index 000000000..0d8a1cf8c
--- /dev/null
+++ b/.cross_sync/README.md
@@ -0,0 +1,75 @@
+# CrossSync
+
+CrossSync provides a simple way to share logic between async and sync code.
+It is made up of a small library that provides:
+1. a set of shims that provide a shared sync/async API surface
+2. annotations that are used to guide generation of a sync version from an async class
+
+Using CrossSync, the async code is treated as the source of truth, and sync code is generated from it.
+
+## Usage
+
+### CrossSync Shims
+
+Many Asyncio components have direct, 1:1 threaded counterparts for use in non-asyncio code. CrossSync
+provides a compatibility layer that works with both
+
+| CrossSync | Asyncio Version | Sync Version |
+| --- | --- | --- |
+| CrossSync.Queue | asyncio.Queue | queue.Queue |
+| CrossSync.Condition | asyncio.Condition | threading.Condition |
+| CrossSync.Future | asyncio.Future | Concurrent.futures.Future |
+| CrossSync.Task | asyncio.Task | Concurrent.futures.Future |
+| CrossSync.Event | asyncio.Event | threading.Event |
+| CrossSync.Semaphore | asyncio.Semaphore | threading.Semaphore |
+| CrossSync.Awaitable | typing.Awaitable | typing.Union (no-op type) |
+| CrossSync.Iterable | typing.AsyncIterable | typing.Iterable |
+| CrossSync.Iterator | typing.AsyncIterator | typing.Iterator |
+| CrossSync.Generator | typing.AsyncGenerator | typing.Generator |
+| CrossSync.Retry | google.api_core.retry.AsyncRetry | google.api_core.retry.Retry |
+| CrossSync.StopIteration | StopAsyncIteration | StopIteration |
+| CrossSync.Mock | unittest.mock.AsyncMock | unittest.mock.Mock |
+
+Custom aliases can be added using `CrossSync.add_mapping(class, name)`
+
+Additionally, CrossSync provides method implementations that work equivalently in async and sync code:
+- `CrossSync.sleep()`
+- `CrossSync.gather_partials()`
+- `CrossSync.wait()`
+- `CrossSync.condition_wait()`
+- `CrossSync,event_wait()`
+- `CrossSync.create_task()`
+- `CrossSync.retry_target()`
+- `CrossSync.retry_target_stream()`
+
+### Annotations
+
+CrossSync provides a set of annotations to mark up async classes, to guide the generation of sync code.
+
+- `@CrossSync.convert_sync`
+ - marks classes for conversion. Unmarked classes will be copied as-is
+ - if add_mapping is included, the async and sync classes can be accessed using a shared CrossSync.X alias
+- `@CrossSync.convert`
+ - marks async functions for conversion. Unmarked methods will be copied as-is
+- `@CrossSync.drop`
+ - marks functions or classes that should not be included in sync output
+- `@CrossSync.pytest`
+ - marks test functions. Test functions automatically have all async keywords stripped (i.e., rm_aio is unneeded)
+- `CrossSync.add_mapping`
+ - manually registers a new CrossSync.X alias, for custom types
+- `CrossSync.rm_aio`
+ - Marks regions of the code that include asyncio keywords that should be stripped during generation
+
+### Code Generation
+
+Generation can be initiated using `nox -s generate_sync`
+from the root of the project. This will find all classes with the `__CROSS_SYNC_OUTPUT__ = "path/to/output"`
+annotation, and generate a sync version of classes marked with `@CrossSync.convert_sync` at the output path.
+
+There is a unit test at `tests/unit/data/test_sync_up_to_date.py` that verifies that the generated code is up to date
+
+## Architecture
+
+CrossSync is made up of two parts:
+- the runtime shims and annotations live in `/google/cloud/bigtable/_cross_sync`
+- the code generation logic lives in `/.cross_sync/` in the repo root
diff --git a/.cross_sync/generate.py b/.cross_sync/generate.py
new file mode 100644
index 000000000..5158d0f37
--- /dev/null
+++ b/.cross_sync/generate.py
@@ -0,0 +1,107 @@
+# Copyright 2024 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.
+from __future__ import annotations
+from typing import Sequence
+import ast
+"""
+Entrypoint for initiating an async -> sync conversion using CrossSync
+
+Finds all python files rooted in a given directory, and uses
+transformers.CrossSyncFileProcessor to handle any files marked with
+__CROSS_SYNC_OUTPUT__
+"""
+
+
+def extract_header_comments(file_path) -> str:
+ """
+ Extract the file header. Header is defined as the top-level
+ comments before any code or imports
+ """
+ header = []
+ with open(file_path, "r") as f:
+ for line in f:
+ if line.startswith("#") or line.strip() == "":
+ header.append(line)
+ else:
+ break
+ header.append("\n# This file is automatically generated by CrossSync. Do not edit manually.\n\n")
+ return "".join(header)
+
+
+class CrossSyncOutputFile:
+
+ def __init__(self, output_path: str, ast_tree, header: str | None = None):
+ self.output_path = output_path
+ self.tree = ast_tree
+ self.header = header or ""
+
+ def render(self, with_formatter=True, save_to_disk: bool = True) -> str:
+ """
+ Render the file to a string, and optionally save to disk
+
+ Args:
+ with_formatter: whether to run the output through black before returning
+ save_to_disk: whether to write the output to the file path
+ """
+ full_str = self.header + ast.unparse(self.tree)
+ if with_formatter:
+ import black # type: ignore
+ import autoflake # type: ignore
+
+ full_str = black.format_str(
+ autoflake.fix_code(full_str, remove_all_unused_imports=True),
+ mode=black.FileMode(),
+ )
+ if save_to_disk:
+ import os
+ os.makedirs(os.path.dirname(self.output_path), exist_ok=True)
+ with open(self.output_path, "w") as f:
+ f.write(full_str)
+ return full_str
+
+
+def convert_files_in_dir(directory: str) -> set[CrossSyncOutputFile]:
+ import glob
+ from transformers import CrossSyncFileProcessor
+
+ # find all python files in the directory
+ files = glob.glob(directory + "/**/*.py", recursive=True)
+ # keep track of the output files pointed to by the annotated classes
+ artifacts: set[CrossSyncOutputFile] = set()
+ file_transformer = CrossSyncFileProcessor()
+ # run each file through ast transformation to find all annotated classes
+ for file_path in files:
+ ast_tree = ast.parse(open(file_path).read())
+ output_path = file_transformer.get_output_path(ast_tree)
+ if output_path is not None:
+ # contains __CROSS_SYNC_OUTPUT__ annotation
+ converted_tree = file_transformer.visit(ast_tree)
+ header = extract_header_comments(file_path)
+ artifacts.add(CrossSyncOutputFile(output_path, converted_tree, header))
+ # return set of output artifacts
+ return artifacts
+
+
+def save_artifacts(artifacts: Sequence[CrossSyncOutputFile]):
+ for a in artifacts:
+ a.render(save_to_disk=True)
+
+
+if __name__ == "__main__":
+ import sys
+
+ search_root = sys.argv[1]
+ outputs = convert_files_in_dir(search_root)
+ print(f"Generated {len(outputs)} artifacts: {[a.output_path for a in outputs]}")
+ save_artifacts(outputs)
diff --git a/.cross_sync/transformers.py b/.cross_sync/transformers.py
new file mode 100644
index 000000000..ab2d5dd63
--- /dev/null
+++ b/.cross_sync/transformers.py
@@ -0,0 +1,333 @@
+# Copyright 2024 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.
+"""
+Provides a set of ast.NodeTransformer subclasses that are composed to generate
+async code into sync code.
+
+At a high level:
+- The main entrypoint is CrossSyncFileProcessor, which is used to find files in
+ the codebase that include __CROSS_SYNC_OUTPUT__, and transform them
+ according to the `CrossSync` annotations they contains
+- SymbolReplacer is used to swap out CrossSync.X with CrossSync._Sync_Impl.X
+- RmAioFunctions is used to strip out asyncio keywords marked with CrossSync.rm_aio
+ (deferring to AsyncToSync to handle the actual transformation)
+- StripAsyncConditionalBranches finds `if CrossSync.is_async:` conditionals, and strips out
+ the unneeded branch for the sync output
+"""
+from __future__ import annotations
+
+import ast
+
+import sys
+# add cross_sync to path
+sys.path.append("google/cloud/bigtable/data/_cross_sync")
+from _decorators import AstDecorator
+
+
+class SymbolReplacer(ast.NodeTransformer):
+ """
+ Replaces all instances of a symbol in an AST with a replacement
+
+ Works for function signatures, method calls, docstrings, and type annotations
+ """
+ def __init__(self, replacements: dict[str, str]):
+ self.replacements = replacements
+
+ def visit_Name(self, node):
+ if node.id in self.replacements:
+ node.id = self.replacements[node.id]
+ return node
+
+ def visit_Attribute(self, node):
+ return ast.copy_location(
+ ast.Attribute(
+ self.visit(node.value),
+ self.replacements.get(node.attr, node.attr),
+ node.ctx,
+ ),
+ node,
+ )
+
+ def visit_AsyncFunctionDef(self, node):
+ """
+ Replace async function docstrings
+ """
+ # use same logic as FunctionDef
+ return self.visit_FunctionDef(node)
+
+ def visit_FunctionDef(self, node):
+ """
+ Replace function docstrings
+ """
+ docstring = ast.get_docstring(node)
+ if docstring and isinstance(node.body[0], ast.Expr) and isinstance(
+ node.body[0].value, ast.Str
+ ):
+ for key_word, replacement in self.replacements.items():
+ docstring = docstring.replace(key_word, replacement)
+ node.body[0].value.s = docstring
+ return self.generic_visit(node)
+
+ def visit_Constant(self, node):
+ """Replace string type annotations"""
+ node.s = self.replacements.get(node.s, node.s)
+ return node
+
+
+class AsyncToSync(ast.NodeTransformer):
+ """
+ Replaces or strips all async keywords from a given AST
+ """
+ def visit_Await(self, node):
+ """
+ Strips await keyword
+ """
+ return self.visit(node.value)
+
+ def visit_AsyncFor(self, node):
+ """
+ Replaces `async for` with `for`
+ """
+ return ast.copy_location(
+ ast.For(
+ self.visit(node.target),
+ self.visit(node.iter),
+ [self.visit(stmt) for stmt in node.body],
+ [self.visit(stmt) for stmt in node.orelse],
+ ),
+ node,
+ )
+
+ def visit_AsyncWith(self, node):
+ """
+ Replaces `async with` with `with`
+ """
+ return ast.copy_location(
+ ast.With(
+ [self.visit(item) for item in node.items],
+ [self.visit(stmt) for stmt in node.body],
+ ),
+ node,
+ )
+
+ def visit_AsyncFunctionDef(self, node):
+ """
+ Replaces `async def` with `def`
+ """
+ return ast.copy_location(
+ ast.FunctionDef(
+ node.name,
+ self.visit(node.args),
+ [self.visit(stmt) for stmt in node.body],
+ [self.visit(decorator) for decorator in node.decorator_list],
+ node.returns and self.visit(node.returns),
+ ),
+ node,
+ )
+
+ def visit_ListComp(self, node):
+ """
+ Replaces `async for` with `for` in list comprehensions
+ """
+ for generator in node.generators:
+ generator.is_async = False
+ return self.generic_visit(node)
+
+
+class RmAioFunctions(ast.NodeTransformer):
+ """
+ Visits all calls marked with CrossSync.rm_aio, and removes asyncio keywords
+ """
+ RM_AIO_FN_NAME = "rm_aio"
+ RM_AIO_CLASS_NAME = "CrossSync"
+
+ def __init__(self):
+ self.to_sync = AsyncToSync()
+
+ def _is_rm_aio_call(self, node) -> bool:
+ """
+ Check if a node is a CrossSync.rm_aio call
+ """
+ if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name):
+ if node.func.attr == self.RM_AIO_FN_NAME and node.func.value.id == self.RM_AIO_CLASS_NAME:
+ return True
+ return False
+
+ def visit_Call(self, node):
+ if self._is_rm_aio_call(node):
+ return self.visit(self.to_sync.visit(node.args[0]))
+ return self.generic_visit(node)
+
+ def visit_AsyncWith(self, node):
+ """
+ `async with` statements can contain multiple async context managers.
+
+ If any of them contains a CrossSync.rm_aio statement, convert into standard `with` statement
+ """
+ if any(self._is_rm_aio_call(item.context_expr) for item in node.items
+ ):
+ new_node = ast.copy_location(
+ ast.With(
+ [self.visit(item) for item in node.items],
+ [self.visit(stmt) for stmt in node.body],
+ ),
+ node,
+ )
+ return self.generic_visit(new_node)
+ return self.generic_visit(node)
+
+ def visit_AsyncFor(self, node):
+ """
+ Async for statements are not fully wrapped by calls
+ """
+ it = node.iter
+ if self._is_rm_aio_call(it):
+ return ast.copy_location(
+ ast.For(
+ self.visit(node.target),
+ self.visit(it),
+ [self.visit(stmt) for stmt in node.body],
+ [self.visit(stmt) for stmt in node.orelse],
+ ),
+ node,
+ )
+ return self.generic_visit(node)
+
+
+class StripAsyncConditionalBranches(ast.NodeTransformer):
+ """
+ Visits all if statements in an AST, and removes branches marked with CrossSync.is_async
+ """
+
+ def visit_If(self, node):
+ """
+ remove CrossSync.is_async branches from top-level if statements
+ """
+ kept_branch = None
+ # check for CrossSync.is_async
+ if self._is_async_check(node.test):
+ kept_branch = node.orelse
+ # check for not CrossSync.is_async
+ elif isinstance(node.test, ast.UnaryOp) and isinstance(node.test.op, ast.Not) and self._is_async_check(node.test.operand):
+ kept_branch = node.body
+ if kept_branch is not None:
+ # only keep the statements in the kept branch
+ return [self.visit(n) for n in kept_branch]
+ else:
+ # keep the entire if statement
+ return self.generic_visit(node)
+
+ def _is_async_check(self, node) -> bool:
+ """
+ Check for CrossSync.is_async or CrossSync.is_async == True checks
+ """
+ if isinstance(node, ast.Attribute):
+ # for CrossSync.is_async
+ return isinstance(node.value, ast.Name) and node.value.id == "CrossSync" and node.attr == "is_async"
+ elif isinstance(node, ast.Compare):
+ # for CrossSync.is_async == True
+ return self._is_async_check(node.left) and (isinstance(node.ops[0], ast.Eq) or isinstance(node.ops[0], ast.Is)) and len(node.comparators) == 1 and node.comparators[0].value == True
+ return False
+
+
+class CrossSyncFileProcessor(ast.NodeTransformer):
+ """
+ Visits a file, looking for __CROSS_SYNC_OUTPUT__ annotations
+
+ If found, the file is processed with the following steps:
+ - Strip out asyncio keywords within CrossSync.rm_aio calls
+ - transform classes and methods annotated with CrossSync decorators
+ - statements behind CrossSync.is_async conditional branches are removed
+ - Replace remaining CrossSync statements with corresponding CrossSync._Sync_Impl calls
+ - save changes in an output file at path specified by __CROSS_SYNC_OUTPUT__
+ """
+ FILE_ANNOTATION = "__CROSS_SYNC_OUTPUT__"
+
+ def get_output_path(self, node):
+ for n in node.body:
+ if isinstance(n, ast.Assign):
+ for target in n.targets:
+ if isinstance(target, ast.Name) and target.id == self.FILE_ANNOTATION:
+ # return the output path
+ return n.value.s.replace(".", "/") + ".py"
+
+ def visit_Module(self, node):
+ # look for __CROSS_SYNC_OUTPUT__ Assign statement
+ output_path = self.get_output_path(node)
+ if output_path:
+ # if found, process the file
+ converted = self.generic_visit(node)
+ # strip out CrossSync.rm_aio calls
+ converted = RmAioFunctions().visit(converted)
+ # strip out CrossSync.is_async branches
+ converted = StripAsyncConditionalBranches().visit(converted)
+ # replace CrossSync statements
+ converted = SymbolReplacer({"CrossSync": "CrossSync._Sync_Impl"}).visit(converted)
+ return converted
+ else:
+ # not cross_sync file. Return None
+ return None
+
+ def visit_ClassDef(self, node):
+ """
+ Called for each class in file. If class has a CrossSync decorator, it will be transformed
+ according to the decorator arguments. Otherwise, class is returned unchanged
+ """
+ orig_decorators = node.decorator_list
+ for decorator in orig_decorators:
+ try:
+ handler = AstDecorator.get_for_node(decorator)
+ # transformation is handled in sync_ast_transform method of the decorator
+ node = handler.sync_ast_transform(node, globals())
+ except ValueError:
+ # not cross_sync decorator
+ continue
+ return self.generic_visit(node) if node else None
+
+ def visit_Assign(self, node):
+ """
+ strip out __CROSS_SYNC_OUTPUT__ assignments
+ """
+ if isinstance(node.targets[0], ast.Name) and node.targets[0].id == self.FILE_ANNOTATION:
+ return None
+ return self.generic_visit(node)
+
+ def visit_FunctionDef(self, node):
+ """
+ Visit any sync methods marked with CrossSync decorators
+ """
+ return self.visit_AsyncFunctionDef(node)
+
+ def visit_AsyncFunctionDef(self, node):
+ """
+ Visit and transform any async methods marked with CrossSync decorators
+ """
+ try:
+ if hasattr(node, "decorator_list"):
+ found_list, node.decorator_list = node.decorator_list, []
+ for decorator in found_list:
+ try:
+ handler = AstDecorator.get_for_node(decorator)
+ node = handler.sync_ast_transform(node, globals())
+ if node is None:
+ return None
+ # recurse to any nested functions
+ node = self.generic_visit(node)
+ except ValueError:
+ # keep unknown decorators
+ node.decorator_list.append(decorator)
+ continue
+ return self.generic_visit(node)
+ except ValueError as e:
+ raise ValueError(f"node {node.name} failed") from e
diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml
index 597e0c326..26306af66 100644
--- a/.github/.OwlBot.lock.yaml
+++ b/.github/.OwlBot.lock.yaml
@@ -13,5 +13,5 @@
# limitations under the License.
docker:
image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest
- digest: sha256:e8dcfd7cbfd8beac3a3ff8d3f3185287ea0625d859168cc80faccfc9a7a00455
-# created: 2024-09-16T21:04:09.091105552Z
+ digest: sha256:8e3e7e18255c22d1489258d0374c901c01f9c4fd77a12088670cd73d580aa737
+# created: 2024-12-17T00:59:58.625514486Z
diff --git a/.github/release-trigger.yml b/.github/release-trigger.yml
index d4ca94189..0bbdd8e4c 100644
--- a/.github/release-trigger.yml
+++ b/.github/release-trigger.yml
@@ -1 +1,2 @@
enabled: true
+multiScmName: python-bigtable
diff --git a/.github/workflows/conformance.yaml b/.github/workflows/conformance.yaml
index 68545cbec..8445240c3 100644
--- a/.github/workflows/conformance.yaml
+++ b/.github/workflows/conformance.yaml
@@ -26,9 +26,17 @@ jobs:
matrix:
test-version: [ "v0.0.2" ]
py-version: [ 3.8 ]
- client-type: [ "Async v3", "Legacy" ]
+ client-type: [ "async", "sync", "legacy" ]
+ include:
+ - client-type: "sync"
+ # sync client does not support concurrent streams
+ test_args: "-skip _Generic_MultiStream"
+ - client-type: "legacy"
+ # legacy client is synchronous and does not support concurrent streams
+ # legacy client does not expose mutate_row. Disable those tests
+ test_args: "-skip _Generic_MultiStream -skip TestMutateRow_"
fail-fast: false
- name: "${{ matrix.client-type }} Client / Python ${{ matrix.py-version }} / Test Tag ${{ matrix.test-version }}"
+ name: "${{ matrix.client-type }} client / python ${{ matrix.py-version }} / test tag ${{ matrix.test-version }}"
steps:
- uses: actions/checkout@v4
name: "Checkout python-bigtable"
@@ -53,4 +61,6 @@ jobs:
env:
CLIENT_TYPE: ${{ matrix.client-type }}
PYTHONUNBUFFERED: 1
+ TEST_ARGS: ${{ matrix.test_args }}
+ PROXY_PORT: 9999
diff --git a/.github/workflows/unittest.yml b/.github/workflows/unittest.yml
index 04ade4f43..6eca3149c 100644
--- a/.github/workflows/unittest.yml
+++ b/.github/workflows/unittest.yml
@@ -8,7 +8,7 @@ jobs:
runs-on: ubuntu-latest
strategy:
matrix:
- python: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
+ python: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
steps:
- name: Checkout
uses: actions/checkout@v4
diff --git a/.kokoro/conformance.sh b/.kokoro/conformance.sh
index 1c0b3ee0d..fd585142e 100644
--- a/.kokoro/conformance.sh
+++ b/.kokoro/conformance.sh
@@ -19,19 +19,9 @@ set -eo pipefail
## cd to the parent directory, i.e. the root of the git repo
cd $(dirname $0)/..
-PROXY_ARGS=""
-TEST_ARGS=""
-if [[ "${CLIENT_TYPE^^}" == "LEGACY" ]]; then
- echo "Using legacy client"
- PROXY_ARGS="--legacy-client"
- # legacy client does not expose mutate_row. Disable those tests
- TEST_ARGS="-skip TestMutateRow_"
-fi
-
# Build and start the proxy in a separate process
-PROXY_PORT=9999
pushd test_proxy
-nohup python test_proxy.py --port $PROXY_PORT $PROXY_ARGS &
+nohup python test_proxy.py --port $PROXY_PORT --client_type=$CLIENT_TYPE &
proxyPID=$!
popd
@@ -43,6 +33,7 @@ function cleanup() {
trap cleanup EXIT
# Run the conformance test
+echo "running tests with args: $TEST_ARGS"
pushd cloud-bigtable-clients-test/tests
eval "go test -v -proxy_addr=:$PROXY_PORT $TEST_ARGS"
RETURN_CODE=$?
diff --git a/.kokoro/docker/docs/requirements.txt b/.kokoro/docker/docs/requirements.txt
index 7129c7715..f99a5c4aa 100644
--- a/.kokoro/docker/docs/requirements.txt
+++ b/.kokoro/docker/docs/requirements.txt
@@ -1,42 +1,72 @@
#
-# This file is autogenerated by pip-compile with Python 3.9
+# This file is autogenerated by pip-compile with Python 3.10
# by the following command:
#
-# pip-compile --allow-unsafe --generate-hashes requirements.in
+# pip-compile --allow-unsafe --generate-hashes synthtool/gcp/templates/python_library/.kokoro/docker/docs/requirements.in
#
-argcomplete==3.4.0 \
- --hash=sha256:69a79e083a716173e5532e0fa3bef45f793f4e61096cf52b5a42c0211c8b8aa5 \
- --hash=sha256:c2abcdfe1be8ace47ba777d4fce319eb13bf8ad9dace8d085dcad6eded88057f
+argcomplete==3.5.2 \
+ --hash=sha256:036d020d79048a5d525bc63880d7a4b8d1668566b8a76daf1144c0bbe0f63472 \
+ --hash=sha256:23146ed7ac4403b70bd6026402468942ceba34a6732255b9edf5b7354f68a6bb
# via nox
-colorlog==6.8.2 \
- --hash=sha256:3e3e079a41feb5a1b64f978b5ea4f46040a94f11f0e8bbb8261e3dbbeca64d44 \
- --hash=sha256:4dcbb62368e2800cb3c5abd348da7e53f6c362dda502ec27c560b2e58a66bd33
+colorlog==6.9.0 \
+ --hash=sha256:5906e71acd67cb07a71e779c47c4bcb45fb8c2993eebe9e5adcd6a6f1b283eff \
+ --hash=sha256:bfba54a1b93b94f54e1f4fe48395725a3d92fd2a4af702f6bd70946bdc0c6ac2
# via nox
-distlib==0.3.8 \
- --hash=sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784 \
- --hash=sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64
+distlib==0.3.9 \
+ --hash=sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87 \
+ --hash=sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403
# via virtualenv
-filelock==3.15.4 \
- --hash=sha256:2207938cbc1844345cb01a5a95524dae30f0ce089eba5b00378295a17e3e90cb \
- --hash=sha256:6ca1fffae96225dab4c6eaf1c4f4f28cd2568d3ec2a44e15a08520504de468e7
+filelock==3.16.1 \
+ --hash=sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0 \
+ --hash=sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435
# via virtualenv
-nox==2024.4.15 \
- --hash=sha256:6492236efa15a460ecb98e7b67562a28b70da006ab0be164e8821177577c0565 \
- --hash=sha256:ecf6700199cdfa9e5ea0a41ff5e6ef4641d09508eda6edb89d9987864115817f
- # via -r requirements.in
-packaging==24.1 \
- --hash=sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002 \
- --hash=sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124
+nox==2024.10.9 \
+ --hash=sha256:1d36f309a0a2a853e9bccb76bbef6bb118ba92fa92674d15604ca99adeb29eab \
+ --hash=sha256:7aa9dc8d1c27e9f45ab046ffd1c3b2c4f7c91755304769df231308849ebded95
+ # via -r synthtool/gcp/templates/python_library/.kokoro/docker/docs/requirements.in
+packaging==24.2 \
+ --hash=sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759 \
+ --hash=sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f
# via nox
-platformdirs==4.2.2 \
- --hash=sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee \
- --hash=sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3
+platformdirs==4.3.6 \
+ --hash=sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907 \
+ --hash=sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb
# via virtualenv
-tomli==2.0.1 \
- --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
- --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
+tomli==2.2.1 \
+ --hash=sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6 \
+ --hash=sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd \
+ --hash=sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c \
+ --hash=sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b \
+ --hash=sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8 \
+ --hash=sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6 \
+ --hash=sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77 \
+ --hash=sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff \
+ --hash=sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea \
+ --hash=sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192 \
+ --hash=sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249 \
+ --hash=sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee \
+ --hash=sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4 \
+ --hash=sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98 \
+ --hash=sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8 \
+ --hash=sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4 \
+ --hash=sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281 \
+ --hash=sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744 \
+ --hash=sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69 \
+ --hash=sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13 \
+ --hash=sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140 \
+ --hash=sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e \
+ --hash=sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e \
+ --hash=sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc \
+ --hash=sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff \
+ --hash=sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec \
+ --hash=sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2 \
+ --hash=sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222 \
+ --hash=sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106 \
+ --hash=sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272 \
+ --hash=sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a \
+ --hash=sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7
# via nox
-virtualenv==20.26.3 \
- --hash=sha256:4c43a2a236279d9ea36a0d76f98d84bd6ca94ac4e0f4a3b9d46d05e10fea542a \
- --hash=sha256:8cc4a31139e796e9a7de2cd5cf2489de1217193116a8fd42328f1bd65f434589
+virtualenv==20.28.0 \
+ --hash=sha256:23eae1b4516ecd610481eda647f3a7c09aea295055337331bb4e6892ecce47b0 \
+ --hash=sha256:2c9c3262bb8e7b87ea801d715fae4495e6032450c71d2309be9550e7364049aa
# via nox
diff --git a/.kokoro/docs/common.cfg b/.kokoro/docs/common.cfg
index 9b8937c57..5646c98aa 100644
--- a/.kokoro/docs/common.cfg
+++ b/.kokoro/docs/common.cfg
@@ -63,4 +63,4 @@ before_action {
keyname: "docuploader_service_account"
}
}
-}
\ No newline at end of file
+}
diff --git a/.kokoro/release.sh b/.kokoro/release.sh
index cfc431647..4f0d14588 100755
--- a/.kokoro/release.sh
+++ b/.kokoro/release.sh
@@ -23,7 +23,7 @@ python3 -m releasetool publish-reporter-script > /tmp/publisher-script; source /
export PYTHONUNBUFFERED=1
# Move into the package, build the distribution and upload.
-TWINE_PASSWORD=$(cat "${KOKORO_KEYSTORE_DIR}/73713_google-cloud-pypi-token-keystore-2")
+TWINE_PASSWORD=$(cat "${KOKORO_KEYSTORE_DIR}/73713_google-cloud-pypi-token-keystore-3")
cd github/python-bigtable
python3 setup.py sdist bdist_wheel
twine upload --username __token__ --password "${TWINE_PASSWORD}" dist/*
diff --git a/.kokoro/release/common.cfg b/.kokoro/release/common.cfg
index b79e3a67d..6b4c17d34 100644
--- a/.kokoro/release/common.cfg
+++ b/.kokoro/release/common.cfg
@@ -28,17 +28,11 @@ before_action {
fetch_keystore {
keystore_resource {
keystore_config_id: 73713
- keyname: "google-cloud-pypi-token-keystore-2"
+ keyname: "google-cloud-pypi-token-keystore-3"
}
}
}
-# Tokens needed to report release status back to GitHub
-env_vars: {
- key: "SECRET_MANAGER_KEYS"
- value: "releasetool-publish-reporter-app,releasetool-publish-reporter-googleapis-installation,releasetool-publish-reporter-pem"
-}
-
# Store the packages we uploaded to PyPI. That way, we have a record of exactly
# what we published, which we can use to generate SBOMs and attestations.
action {
diff --git a/.kokoro/requirements.txt b/.kokoro/requirements.txt
index 9622baf0b..006d8ef93 100644
--- a/.kokoro/requirements.txt
+++ b/.kokoro/requirements.txt
@@ -4,79 +4,94 @@
#
# pip-compile --allow-unsafe --generate-hashes requirements.in
#
-argcomplete==3.4.0 \
- --hash=sha256:69a79e083a716173e5532e0fa3bef45f793f4e61096cf52b5a42c0211c8b8aa5 \
- --hash=sha256:c2abcdfe1be8ace47ba777d4fce319eb13bf8ad9dace8d085dcad6eded88057f
+argcomplete==3.5.1 \
+ --hash=sha256:1a1d148bdaa3e3b93454900163403df41448a248af01b6e849edc5ac08e6c363 \
+ --hash=sha256:eb1ee355aa2557bd3d0145de7b06b2a45b0ce461e1e7813f5d066039ab4177b4
# via nox
-attrs==23.2.0 \
- --hash=sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30 \
- --hash=sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1
+attrs==24.2.0 \
+ --hash=sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346 \
+ --hash=sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2
# via gcp-releasetool
backports-tarfile==1.2.0 \
--hash=sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34 \
--hash=sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991
# via jaraco-context
-cachetools==5.3.3 \
- --hash=sha256:0abad1021d3f8325b2fc1d2e9c8b9c9d57b04c3932657a72465447332c24d945 \
- --hash=sha256:ba29e2dfa0b8b556606f097407ed1aa62080ee108ab0dc5ec9d6a723a007d105
+cachetools==5.5.0 \
+ --hash=sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292 \
+ --hash=sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a
# via google-auth
-certifi==2024.7.4 \
- --hash=sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b \
- --hash=sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90
+certifi==2024.8.30 \
+ --hash=sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8 \
+ --hash=sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9
# via requests
-cffi==1.16.0 \
- --hash=sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc \
- --hash=sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a \
- --hash=sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417 \
- --hash=sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab \
- --hash=sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520 \
- --hash=sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36 \
- --hash=sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743 \
- --hash=sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8 \
- --hash=sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed \
- --hash=sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684 \
- --hash=sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56 \
- --hash=sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324 \
- --hash=sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d \
- --hash=sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235 \
- --hash=sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e \
- --hash=sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088 \
- --hash=sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000 \
- --hash=sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7 \
- --hash=sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e \
- --hash=sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673 \
- --hash=sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c \
- --hash=sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe \
- --hash=sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2 \
- --hash=sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098 \
- --hash=sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8 \
- --hash=sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a \
- --hash=sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0 \
- --hash=sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b \
- --hash=sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896 \
- --hash=sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e \
- --hash=sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9 \
- --hash=sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2 \
- --hash=sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b \
- --hash=sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6 \
- --hash=sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404 \
- --hash=sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f \
- --hash=sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0 \
- --hash=sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4 \
- --hash=sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc \
- --hash=sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936 \
- --hash=sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba \
- --hash=sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872 \
- --hash=sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb \
- --hash=sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614 \
- --hash=sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1 \
- --hash=sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d \
- --hash=sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969 \
- --hash=sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b \
- --hash=sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4 \
- --hash=sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627 \
- --hash=sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956 \
- --hash=sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357
+cffi==1.17.1 \
+ --hash=sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8 \
+ --hash=sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2 \
+ --hash=sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1 \
+ --hash=sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15 \
+ --hash=sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36 \
+ --hash=sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824 \
+ --hash=sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8 \
+ --hash=sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36 \
+ --hash=sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17 \
+ --hash=sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf \
+ --hash=sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc \
+ --hash=sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3 \
+ --hash=sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed \
+ --hash=sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702 \
+ --hash=sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1 \
+ --hash=sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8 \
+ --hash=sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903 \
+ --hash=sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6 \
+ --hash=sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d \
+ --hash=sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b \
+ --hash=sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e \
+ --hash=sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be \
+ --hash=sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c \
+ --hash=sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683 \
+ --hash=sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9 \
+ --hash=sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c \
+ --hash=sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8 \
+ --hash=sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1 \
+ --hash=sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4 \
+ --hash=sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655 \
+ --hash=sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67 \
+ --hash=sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595 \
+ --hash=sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0 \
+ --hash=sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65 \
+ --hash=sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41 \
+ --hash=sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6 \
+ --hash=sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401 \
+ --hash=sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6 \
+ --hash=sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3 \
+ --hash=sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16 \
+ --hash=sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93 \
+ --hash=sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e \
+ --hash=sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4 \
+ --hash=sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964 \
+ --hash=sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c \
+ --hash=sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576 \
+ --hash=sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0 \
+ --hash=sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3 \
+ --hash=sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662 \
+ --hash=sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3 \
+ --hash=sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff \
+ --hash=sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5 \
+ --hash=sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd \
+ --hash=sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f \
+ --hash=sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5 \
+ --hash=sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14 \
+ --hash=sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d \
+ --hash=sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9 \
+ --hash=sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7 \
+ --hash=sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382 \
+ --hash=sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a \
+ --hash=sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e \
+ --hash=sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a \
+ --hash=sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4 \
+ --hash=sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99 \
+ --hash=sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87 \
+ --hash=sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b
# via cryptography
charset-normalizer==2.1.1 \
--hash=sha256:5a3d016c7c547f69d6f81fb0db9449ce888b418b5b9952cc5e6e66843e9dd845 \
@@ -97,72 +112,67 @@ colorlog==6.8.2 \
# via
# gcp-docuploader
# nox
-cryptography==42.0.8 \
- --hash=sha256:013629ae70b40af70c9a7a5db40abe5d9054e6f4380e50ce769947b73bf3caad \
- --hash=sha256:2346b911eb349ab547076f47f2e035fc8ff2c02380a7cbbf8d87114fa0f1c583 \
- --hash=sha256:2f66d9cd9147ee495a8374a45ca445819f8929a3efcd2e3df6428e46c3cbb10b \
- --hash=sha256:2f88d197e66c65be5e42cd72e5c18afbfae3f741742070e3019ac8f4ac57262c \
- --hash=sha256:31f721658a29331f895a5a54e7e82075554ccfb8b163a18719d342f5ffe5ecb1 \
- --hash=sha256:343728aac38decfdeecf55ecab3264b015be68fc2816ca800db649607aeee648 \
- --hash=sha256:5226d5d21ab681f432a9c1cf8b658c0cb02533eece706b155e5fbd8a0cdd3949 \
- --hash=sha256:57080dee41209e556a9a4ce60d229244f7a66ef52750f813bfbe18959770cfba \
- --hash=sha256:5a94eccb2a81a309806027e1670a358b99b8fe8bfe9f8d329f27d72c094dde8c \
- --hash=sha256:6b7c4f03ce01afd3b76cf69a5455caa9cfa3de8c8f493e0d3ab7d20611c8dae9 \
- --hash=sha256:7016f837e15b0a1c119d27ecd89b3515f01f90a8615ed5e9427e30d9cdbfed3d \
- --hash=sha256:81884c4d096c272f00aeb1f11cf62ccd39763581645b0812e99a91505fa48e0c \
- --hash=sha256:81d8a521705787afe7a18d5bfb47ea9d9cc068206270aad0b96a725022e18d2e \
- --hash=sha256:8d09d05439ce7baa8e9e95b07ec5b6c886f548deb7e0f69ef25f64b3bce842f2 \
- --hash=sha256:961e61cefdcb06e0c6d7e3a1b22ebe8b996eb2bf50614e89384be54c48c6b63d \
- --hash=sha256:9c0c1716c8447ee7dbf08d6db2e5c41c688544c61074b54fc4564196f55c25a7 \
- --hash=sha256:a0608251135d0e03111152e41f0cc2392d1e74e35703960d4190b2e0f4ca9c70 \
- --hash=sha256:a0c5b2b0585b6af82d7e385f55a8bc568abff8923af147ee3c07bd8b42cda8b2 \
- --hash=sha256:ad803773e9df0b92e0a817d22fd8a3675493f690b96130a5e24f1b8fabbea9c7 \
- --hash=sha256:b297f90c5723d04bcc8265fc2a0f86d4ea2e0f7ab4b6994459548d3a6b992a14 \
- --hash=sha256:ba4f0a211697362e89ad822e667d8d340b4d8d55fae72cdd619389fb5912eefe \
- --hash=sha256:c4783183f7cb757b73b2ae9aed6599b96338eb957233c58ca8f49a49cc32fd5e \
- --hash=sha256:c9bb2ae11bfbab395bdd072985abde58ea9860ed84e59dbc0463a5d0159f5b71 \
- --hash=sha256:cafb92b2bc622cd1aa6a1dce4b93307792633f4c5fe1f46c6b97cf67073ec961 \
- --hash=sha256:d45b940883a03e19e944456a558b67a41160e367a719833c53de6911cabba2b7 \
- --hash=sha256:dc0fdf6787f37b1c6b08e6dfc892d9d068b5bdb671198c72072828b80bd5fe4c \
- --hash=sha256:dea567d1b0e8bc5764b9443858b673b734100c2871dc93163f58c46a97a83d28 \
- --hash=sha256:dec9b018df185f08483f294cae6ccac29e7a6e0678996587363dc352dc65c842 \
- --hash=sha256:e3ec3672626e1b9e55afd0df6d774ff0e953452886e06e0f1eb7eb0c832e8902 \
- --hash=sha256:e599b53fd95357d92304510fb7bda8523ed1f79ca98dce2f43c115950aa78801 \
- --hash=sha256:fa76fbb7596cc5839320000cdd5d0955313696d9511debab7ee7278fc8b5c84a \
- --hash=sha256:fff12c88a672ab9c9c1cf7b0c80e3ad9e2ebd9d828d955c126be4fd3e5578c9e
+cryptography==43.0.1 \
+ --hash=sha256:014f58110f53237ace6a408b5beb6c427b64e084eb451ef25a28308270086494 \
+ --hash=sha256:1bbcce1a551e262dfbafb6e6252f1ae36a248e615ca44ba302df077a846a8806 \
+ --hash=sha256:203e92a75716d8cfb491dc47c79e17d0d9207ccffcbcb35f598fbe463ae3444d \
+ --hash=sha256:27e613d7077ac613e399270253259d9d53872aaf657471473ebfc9a52935c062 \
+ --hash=sha256:2bd51274dcd59f09dd952afb696bf9c61a7a49dfc764c04dd33ef7a6b502a1e2 \
+ --hash=sha256:38926c50cff6f533f8a2dae3d7f19541432610d114a70808f0926d5aaa7121e4 \
+ --hash=sha256:511f4273808ab590912a93ddb4e3914dfd8a388fed883361b02dea3791f292e1 \
+ --hash=sha256:58d4e9129985185a06d849aa6df265bdd5a74ca6e1b736a77959b498e0505b85 \
+ --hash=sha256:5b43d1ea6b378b54a1dc99dd8a2b5be47658fe9a7ce0a58ff0b55f4b43ef2b84 \
+ --hash=sha256:61ec41068b7b74268fa86e3e9e12b9f0c21fcf65434571dbb13d954bceb08042 \
+ --hash=sha256:666ae11966643886c2987b3b721899d250855718d6d9ce41b521252a17985f4d \
+ --hash=sha256:68aaecc4178e90719e95298515979814bda0cbada1256a4485414860bd7ab962 \
+ --hash=sha256:7c05650fe8023c5ed0d46793d4b7d7e6cd9c04e68eabe5b0aeea836e37bdcec2 \
+ --hash=sha256:80eda8b3e173f0f247f711eef62be51b599b5d425c429b5d4ca6a05e9e856baa \
+ --hash=sha256:8385d98f6a3bf8bb2d65a73e17ed87a3ba84f6991c155691c51112075f9ffc5d \
+ --hash=sha256:88cce104c36870d70c49c7c8fd22885875d950d9ee6ab54df2745f83ba0dc365 \
+ --hash=sha256:9d3cdb25fa98afdd3d0892d132b8d7139e2c087da1712041f6b762e4f807cc96 \
+ --hash=sha256:a575913fb06e05e6b4b814d7f7468c2c660e8bb16d8d5a1faf9b33ccc569dd47 \
+ --hash=sha256:ac119bb76b9faa00f48128b7f5679e1d8d437365c5d26f1c2c3f0da4ce1b553d \
+ --hash=sha256:c1332724be35d23a854994ff0b66530119500b6053d0bd3363265f7e5e77288d \
+ --hash=sha256:d03a475165f3134f773d1388aeb19c2d25ba88b6a9733c5c590b9ff7bbfa2e0c \
+ --hash=sha256:d75601ad10b059ec832e78823b348bfa1a59f6b8d545db3a24fd44362a1564cb \
+ --hash=sha256:de41fd81a41e53267cb020bb3a7212861da53a7d39f863585d13ea11049cf277 \
+ --hash=sha256:e710bf40870f4db63c3d7d929aa9e09e4e7ee219e703f949ec4073b4294f6172 \
+ --hash=sha256:ea25acb556320250756e53f9e20a4177515f012c9eaea17eb7587a8c4d8ae034 \
+ --hash=sha256:f98bf604c82c416bc829e490c700ca1553eafdf2912a91e23a79d97d9801372a \
+ --hash=sha256:fba1007b3ef89946dbbb515aeeb41e30203b004f0b4b00e5e16078b518563289
# via
# -r requirements.in
# gcp-releasetool
# secretstorage
-distlib==0.3.8 \
- --hash=sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784 \
- --hash=sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64
+distlib==0.3.9 \
+ --hash=sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87 \
+ --hash=sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403
# via virtualenv
docutils==0.21.2 \
--hash=sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f \
--hash=sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2
# via readme-renderer
-filelock==3.15.4 \
- --hash=sha256:2207938cbc1844345cb01a5a95524dae30f0ce089eba5b00378295a17e3e90cb \
- --hash=sha256:6ca1fffae96225dab4c6eaf1c4f4f28cd2568d3ec2a44e15a08520504de468e7
+filelock==3.16.1 \
+ --hash=sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0 \
+ --hash=sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435
# via virtualenv
gcp-docuploader==0.6.5 \
--hash=sha256:30221d4ac3e5a2b9c69aa52fdbef68cc3f27d0e6d0d90e220fc024584b8d2318 \
--hash=sha256:b7458ef93f605b9d46a4bf3a8dc1755dad1f31d030c8679edf304e343b347eea
# via -r requirements.in
-gcp-releasetool==2.0.1 \
- --hash=sha256:34314a910c08e8911d9c965bd44f8f2185c4f556e737d719c33a41f6a610de96 \
- --hash=sha256:b0d5863c6a070702b10883d37c4bdfd74bf930fe417f36c0c965d3b7c779ae62
+gcp-releasetool==2.1.1 \
+ --hash=sha256:25639269f4eae510094f9dbed9894977e1966933211eb155a451deebc3fc0b30 \
+ --hash=sha256:845f4ded3d9bfe8cc7fdaad789e83f4ea014affa77785259a7ddac4b243e099e
# via -r requirements.in
-google-api-core==2.19.1 \
- --hash=sha256:f12a9b8309b5e21d92483bbd47ce2c445861ec7d269ef6784ecc0ea8c1fa6125 \
- --hash=sha256:f4695f1e3650b316a795108a76a1c416e6afb036199d1c1f1f110916df479ffd
+google-api-core==2.21.0 \
+ --hash=sha256:4a152fd11a9f774ea606388d423b68aa7e6d6a0ffe4c8266f74979613ec09f81 \
+ --hash=sha256:6869eacb2a37720380ba5898312af79a4d30b8bca1548fb4093e0697dc4bdf5d
# via
# google-cloud-core
# google-cloud-storage
-google-auth==2.31.0 \
- --hash=sha256:042c4702efa9f7d3c48d3a69341c209381b125faa6dbf3ebe56bc7e40ae05c23 \
- --hash=sha256:87805c36970047247c8afe614d4e3af8eceafc1ebba0c679fe75ddd1d575e871
+google-auth==2.35.0 \
+ --hash=sha256:25df55f327ef021de8be50bad0dfd4a916ad0de96da86cd05661c9297723ad3f \
+ --hash=sha256:f4c64ed4e01e8e8b646ef34c018f8bf3338df0c8e37d8b3bba40e7f574a3278a
# via
# gcp-releasetool
# google-api-core
@@ -172,97 +182,56 @@ google-cloud-core==2.4.1 \
--hash=sha256:9b7749272a812bde58fff28868d0c5e2f585b82f37e09a1f6ed2d4d10f134073 \
--hash=sha256:a9e6a4422b9ac5c29f79a0ede9485473338e2ce78d91f2370c01e730eab22e61
# via google-cloud-storage
-google-cloud-storage==2.17.0 \
- --hash=sha256:49378abff54ef656b52dca5ef0f2eba9aa83dc2b2c72c78714b03a1a95fe9388 \
- --hash=sha256:5b393bc766b7a3bc6f5407b9e665b2450d36282614b7945e570b3480a456d1e1
+google-cloud-storage==2.18.2 \
+ --hash=sha256:97a4d45c368b7d401ed48c4fdfe86e1e1cb96401c9e199e419d289e2c0370166 \
+ --hash=sha256:aaf7acd70cdad9f274d29332673fcab98708d0e1f4dceb5a5356aaef06af4d99
# via gcp-docuploader
-google-crc32c==1.5.0 \
- --hash=sha256:024894d9d3cfbc5943f8f230e23950cd4906b2fe004c72e29b209420a1e6b05a \
- --hash=sha256:02c65b9817512edc6a4ae7c7e987fea799d2e0ee40c53ec573a692bee24de876 \
- --hash=sha256:02ebb8bf46c13e36998aeaad1de9b48f4caf545e91d14041270d9dca767b780c \
- --hash=sha256:07eb3c611ce363c51a933bf6bd7f8e3878a51d124acfc89452a75120bc436289 \
- --hash=sha256:1034d91442ead5a95b5aaef90dbfaca8633b0247d1e41621d1e9f9db88c36298 \
- --hash=sha256:116a7c3c616dd14a3de8c64a965828b197e5f2d121fedd2f8c5585c547e87b02 \
- --hash=sha256:19e0a019d2c4dcc5e598cd4a4bc7b008546b0358bd322537c74ad47a5386884f \
- --hash=sha256:1c7abdac90433b09bad6c43a43af253e688c9cfc1c86d332aed13f9a7c7f65e2 \
- --hash=sha256:1e986b206dae4476f41bcec1faa057851f3889503a70e1bdb2378d406223994a \
- --hash=sha256:272d3892a1e1a2dbc39cc5cde96834c236d5327e2122d3aaa19f6614531bb6eb \
- --hash=sha256:278d2ed7c16cfc075c91378c4f47924c0625f5fc84b2d50d921b18b7975bd210 \
- --hash=sha256:2ad40e31093a4af319dadf503b2467ccdc8f67c72e4bcba97f8c10cb078207b5 \
- --hash=sha256:2e920d506ec85eb4ba50cd4228c2bec05642894d4c73c59b3a2fe20346bd00ee \
- --hash=sha256:3359fc442a743e870f4588fcf5dcbc1bf929df1fad8fb9905cd94e5edb02e84c \
- --hash=sha256:37933ec6e693e51a5b07505bd05de57eee12f3e8c32b07da7e73669398e6630a \
- --hash=sha256:398af5e3ba9cf768787eef45c803ff9614cc3e22a5b2f7d7ae116df8b11e3314 \
- --hash=sha256:3b747a674c20a67343cb61d43fdd9207ce5da6a99f629c6e2541aa0e89215bcd \
- --hash=sha256:461665ff58895f508e2866824a47bdee72497b091c730071f2b7575d5762ab65 \
- --hash=sha256:4c6fdd4fccbec90cc8a01fc00773fcd5fa28db683c116ee3cb35cd5da9ef6c37 \
- --hash=sha256:5829b792bf5822fd0a6f6eb34c5f81dd074f01d570ed7f36aa101d6fc7a0a6e4 \
- --hash=sha256:596d1f98fc70232fcb6590c439f43b350cb762fb5d61ce7b0e9db4539654cc13 \
- --hash=sha256:5ae44e10a8e3407dbe138984f21e536583f2bba1be9491239f942c2464ac0894 \
- --hash=sha256:635f5d4dd18758a1fbd1049a8e8d2fee4ffed124462d837d1a02a0e009c3ab31 \
- --hash=sha256:64e52e2b3970bd891309c113b54cf0e4384762c934d5ae56e283f9a0afcd953e \
- --hash=sha256:66741ef4ee08ea0b2cc3c86916ab66b6aef03768525627fd6a1b34968b4e3709 \
- --hash=sha256:67b741654b851abafb7bc625b6d1cdd520a379074e64b6a128e3b688c3c04740 \
- --hash=sha256:6ac08d24c1f16bd2bf5eca8eaf8304812f44af5cfe5062006ec676e7e1d50afc \
- --hash=sha256:6f998db4e71b645350b9ac28a2167e6632c239963ca9da411523bb439c5c514d \
- --hash=sha256:72218785ce41b9cfd2fc1d6a017dc1ff7acfc4c17d01053265c41a2c0cc39b8c \
- --hash=sha256:74dea7751d98034887dbd821b7aae3e1d36eda111d6ca36c206c44478035709c \
- --hash=sha256:759ce4851a4bb15ecabae28f4d2e18983c244eddd767f560165563bf9aefbc8d \
- --hash=sha256:77e2fd3057c9d78e225fa0a2160f96b64a824de17840351b26825b0848022906 \
- --hash=sha256:7c074fece789b5034b9b1404a1f8208fc2d4c6ce9decdd16e8220c5a793e6f61 \
- --hash=sha256:7c42c70cd1d362284289c6273adda4c6af8039a8ae12dc451dcd61cdabb8ab57 \
- --hash=sha256:7f57f14606cd1dd0f0de396e1e53824c371e9544a822648cd76c034d209b559c \
- --hash=sha256:83c681c526a3439b5cf94f7420471705bbf96262f49a6fe546a6db5f687a3d4a \
- --hash=sha256:8485b340a6a9e76c62a7dce3c98e5f102c9219f4cfbf896a00cf48caf078d438 \
- --hash=sha256:84e6e8cd997930fc66d5bb4fde61e2b62ba19d62b7abd7a69920406f9ecca946 \
- --hash=sha256:89284716bc6a5a415d4eaa11b1726d2d60a0cd12aadf5439828353662ede9dd7 \
- --hash=sha256:8b87e1a59c38f275c0e3676fc2ab6d59eccecfd460be267ac360cc31f7bcde96 \
- --hash=sha256:8f24ed114432de109aa9fd317278518a5af2d31ac2ea6b952b2f7782b43da091 \
- --hash=sha256:98cb4d057f285bd80d8778ebc4fde6b4d509ac3f331758fb1528b733215443ae \
- --hash=sha256:998679bf62b7fb599d2878aa3ed06b9ce688b8974893e7223c60db155f26bd8d \
- --hash=sha256:9ba053c5f50430a3fcfd36f75aff9caeba0440b2d076afdb79a318d6ca245f88 \
- --hash=sha256:9c99616c853bb585301df6de07ca2cadad344fd1ada6d62bb30aec05219c45d2 \
- --hash=sha256:a1fd716e7a01f8e717490fbe2e431d2905ab8aa598b9b12f8d10abebb36b04dd \
- --hash=sha256:a2355cba1f4ad8b6988a4ca3feed5bff33f6af2d7f134852cf279c2aebfde541 \
- --hash=sha256:b1f8133c9a275df5613a451e73f36c2aea4fe13c5c8997e22cf355ebd7bd0728 \
- --hash=sha256:b8667b48e7a7ef66afba2c81e1094ef526388d35b873966d8a9a447974ed9178 \
- --hash=sha256:ba1eb1843304b1e5537e1fca632fa894d6f6deca8d6389636ee5b4797affb968 \
- --hash=sha256:be82c3c8cfb15b30f36768797a640e800513793d6ae1724aaaafe5bf86f8f346 \
- --hash=sha256:c02ec1c5856179f171e032a31d6f8bf84e5a75c45c33b2e20a3de353b266ebd8 \
- --hash=sha256:c672d99a345849301784604bfeaeba4db0c7aae50b95be04dd651fd2a7310b93 \
- --hash=sha256:c6c777a480337ac14f38564ac88ae82d4cd238bf293f0a22295b66eb89ffced7 \
- --hash=sha256:cae0274952c079886567f3f4f685bcaf5708f0a23a5f5216fdab71f81a6c0273 \
- --hash=sha256:cd67cf24a553339d5062eff51013780a00d6f97a39ca062781d06b3a73b15462 \
- --hash=sha256:d3515f198eaa2f0ed49f8819d5732d70698c3fa37384146079b3799b97667a94 \
- --hash=sha256:d5280312b9af0976231f9e317c20e4a61cd2f9629b7bfea6a693d1878a264ebd \
- --hash=sha256:de06adc872bcd8c2a4e0dc51250e9e65ef2ca91be023b9d13ebd67c2ba552e1e \
- --hash=sha256:e1674e4307fa3024fc897ca774e9c7562c957af85df55efe2988ed9056dc4e57 \
- --hash=sha256:e2096eddb4e7c7bdae4bd69ad364e55e07b8316653234a56552d9c988bd2d61b \
- --hash=sha256:e560628513ed34759456a416bf86b54b2476c59144a9138165c9a1575801d0d9 \
- --hash=sha256:edfedb64740750e1a3b16152620220f51d58ff1b4abceb339ca92e934775c27a \
- --hash=sha256:f13cae8cc389a440def0c8c52057f37359014ccbc9dc1f0827936bcd367c6100 \
- --hash=sha256:f314013e7dcd5cf45ab1945d92e713eec788166262ae8deb2cfacd53def27325 \
- --hash=sha256:f583edb943cf2e09c60441b910d6a20b4d9d626c75a36c8fcac01a6c96c01183 \
- --hash=sha256:fd8536e902db7e365f49e7d9029283403974ccf29b13fc7028b97e2295b33556 \
- --hash=sha256:fe70e325aa68fa4b5edf7d1a4b6f691eb04bbccac0ace68e34820d283b5f80d4
+google-crc32c==1.6.0 \
+ --hash=sha256:05e2d8c9a2f853ff116db9706b4a27350587f341eda835f46db3c0a8c8ce2f24 \
+ --hash=sha256:18e311c64008f1f1379158158bb3f0c8d72635b9eb4f9545f8cf990c5668e59d \
+ --hash=sha256:236c87a46cdf06384f614e9092b82c05f81bd34b80248021f729396a78e55d7e \
+ --hash=sha256:35834855408429cecf495cac67ccbab802de269e948e27478b1e47dfb6465e57 \
+ --hash=sha256:386122eeaaa76951a8196310432c5b0ef3b53590ef4c317ec7588ec554fec5d2 \
+ --hash=sha256:40b05ab32a5067525670880eb5d169529089a26fe35dce8891127aeddc1950e8 \
+ --hash=sha256:48abd62ca76a2cbe034542ed1b6aee851b6f28aaca4e6551b5599b6f3ef175cc \
+ --hash=sha256:50cf2a96da226dcbff8671233ecf37bf6e95de98b2a2ebadbfdf455e6d05df42 \
+ --hash=sha256:51c4f54dd8c6dfeb58d1df5e4f7f97df8abf17a36626a217f169893d1d7f3e9f \
+ --hash=sha256:5bcc90b34df28a4b38653c36bb5ada35671ad105c99cfe915fb5bed7ad6924aa \
+ --hash=sha256:62f6d4a29fea082ac4a3c9be5e415218255cf11684ac6ef5488eea0c9132689b \
+ --hash=sha256:6eceb6ad197656a1ff49ebfbbfa870678c75be4344feb35ac1edf694309413dc \
+ --hash=sha256:7aec8e88a3583515f9e0957fe4f5f6d8d4997e36d0f61624e70469771584c760 \
+ --hash=sha256:91ca8145b060679ec9176e6de4f89b07363d6805bd4760631ef254905503598d \
+ --hash=sha256:a184243544811e4a50d345838a883733461e67578959ac59964e43cca2c791e7 \
+ --hash=sha256:a9e4b426c3702f3cd23b933436487eb34e01e00327fac20c9aebb68ccf34117d \
+ --hash=sha256:bb0966e1c50d0ef5bc743312cc730b533491d60585a9a08f897274e57c3f70e0 \
+ --hash=sha256:bb8b3c75bd157010459b15222c3fd30577042a7060e29d42dabce449c087f2b3 \
+ --hash=sha256:bd5e7d2445d1a958c266bfa5d04c39932dc54093fa391736dbfdb0f1929c1fb3 \
+ --hash=sha256:c87d98c7c4a69066fd31701c4e10d178a648c2cac3452e62c6b24dc51f9fcc00 \
+ --hash=sha256:d2952396dc604544ea7476b33fe87faedc24d666fb0c2d5ac971a2b9576ab871 \
+ --hash=sha256:d8797406499f28b5ef791f339594b0b5fdedf54e203b5066675c406ba69d705c \
+ --hash=sha256:d9e9913f7bd69e093b81da4535ce27af842e7bf371cde42d1ae9e9bd382dc0e9 \
+ --hash=sha256:e2806553238cd076f0a55bddab37a532b53580e699ed8e5606d0de1f856b5205 \
+ --hash=sha256:ebab974b1687509e5c973b5c4b8b146683e101e102e17a86bd196ecaa4d099fc \
+ --hash=sha256:ed767bf4ba90104c1216b68111613f0d5926fb3780660ea1198fc469af410e9d \
+ --hash=sha256:f7a1fc29803712f80879b0806cb83ab24ce62fc8daf0569f2204a0cfd7f68ed4
# via
# google-cloud-storage
# google-resumable-media
-google-resumable-media==2.7.1 \
- --hash=sha256:103ebc4ba331ab1bfdac0250f8033627a2cd7cde09e7ccff9181e31ba4315b2c \
- --hash=sha256:eae451a7b2e2cdbaaa0fd2eb00cc8a1ee5e95e16b55597359cbc3d27d7d90e33
+google-resumable-media==2.7.2 \
+ --hash=sha256:3ce7551e9fe6d99e9a126101d2536612bb73486721951e9562fee0f90c6ababa \
+ --hash=sha256:5280aed4629f2b60b847b0d42f9857fd4935c11af266744df33d8074cae92fe0
# via google-cloud-storage
-googleapis-common-protos==1.63.2 \
- --hash=sha256:27a2499c7e8aff199665b22741997e485eccc8645aa9176c7c988e6fae507945 \
- --hash=sha256:27c5abdffc4911f28101e635de1533fb4cfd2c37fbaa9174587c799fac90aa87
+googleapis-common-protos==1.65.0 \
+ --hash=sha256:2972e6c496f435b92590fd54045060867f3fe9be2c82ab148fc8885035479a63 \
+ --hash=sha256:334a29d07cddc3aa01dee4988f9afd9b2916ee2ff49d6b757155dc0d197852c0
# via google-api-core
-idna==3.7 \
- --hash=sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc \
- --hash=sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0
+idna==3.10 \
+ --hash=sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9 \
+ --hash=sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3
# via requests
-importlib-metadata==8.0.0 \
- --hash=sha256:15584cf2b1bf449d98ff8a6ff1abef57bf20f3ac6454f431736cd3e660921b2f \
- --hash=sha256:188bd24e4c346d3f0a933f275c2fec67050326a856b9a359881d7c2a697e8812
+importlib-metadata==8.5.0 \
+ --hash=sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b \
+ --hash=sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7
# via
# -r requirements.in
# keyring
@@ -271,13 +240,13 @@ jaraco-classes==3.4.0 \
--hash=sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd \
--hash=sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790
# via keyring
-jaraco-context==5.3.0 \
- --hash=sha256:3e16388f7da43d384a1a7cd3452e72e14732ac9fe459678773a3608a812bf266 \
- --hash=sha256:c2f67165ce1f9be20f32f650f25d8edfc1646a8aeee48ae06fb35f90763576d2
+jaraco-context==6.0.1 \
+ --hash=sha256:9bae4ea555cf0b14938dc0aee7c9f32ed303aa20a3b73e7dc80111628792d1b3 \
+ --hash=sha256:f797fc481b490edb305122c9181830a3a5b76d84ef6d1aef2fb9b47ab956f9e4
# via keyring
-jaraco-functools==4.0.1 \
- --hash=sha256:3b24ccb921d6b593bdceb56ce14799204f473976e2a9d4b15b04d0f2c2326664 \
- --hash=sha256:d33fa765374c0611b52f8b3a795f8900869aa88c84769d4d1746cd68fb28c3e8
+jaraco-functools==4.1.0 \
+ --hash=sha256:70f7e0e2ae076498e212562325e805204fc092d7b4c17e0e86c959e249701a9d \
+ --hash=sha256:ad159f13428bc4acbf5541ad6dec511f91573b90fba04df61dafa2a1231cf649
# via keyring
jeepney==0.8.0 \
--hash=sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806 \
@@ -289,9 +258,9 @@ jinja2==3.1.4 \
--hash=sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369 \
--hash=sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d
# via gcp-releasetool
-keyring==25.2.1 \
- --hash=sha256:2458681cdefc0dbc0b7eb6cf75d0b98e59f9ad9b2d4edd319d18f68bdca95e50 \
- --hash=sha256:daaffd42dbda25ddafb1ad5fec4024e5bbcfe424597ca1ca452b299861e49f1b
+keyring==25.4.1 \
+ --hash=sha256:5426f817cf7f6f007ba5ec722b1bcad95a75b27d780343772ad76b17cb47b0bf \
+ --hash=sha256:b07ebc55f3e8ed86ac81dd31ef14e81ace9dd9c3d4b5d77a6e9a2016d0d71a1b
# via
# gcp-releasetool
# twine
@@ -299,75 +268,76 @@ markdown-it-py==3.0.0 \
--hash=sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1 \
--hash=sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb
# via rich
-markupsafe==2.1.5 \
- --hash=sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf \
- --hash=sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff \
- --hash=sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f \
- --hash=sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3 \
- --hash=sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532 \
- --hash=sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f \
- --hash=sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617 \
- --hash=sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df \
- --hash=sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4 \
- --hash=sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906 \
- --hash=sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f \
- --hash=sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4 \
- --hash=sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8 \
- --hash=sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371 \
- --hash=sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2 \
- --hash=sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465 \
- --hash=sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52 \
- --hash=sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6 \
- --hash=sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169 \
- --hash=sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad \
- --hash=sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2 \
- --hash=sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0 \
- --hash=sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029 \
- --hash=sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f \
- --hash=sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a \
- --hash=sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced \
- --hash=sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5 \
- --hash=sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c \
- --hash=sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf \
- --hash=sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9 \
- --hash=sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb \
- --hash=sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad \
- --hash=sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3 \
- --hash=sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1 \
- --hash=sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46 \
- --hash=sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc \
- --hash=sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a \
- --hash=sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee \
- --hash=sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900 \
- --hash=sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5 \
- --hash=sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea \
- --hash=sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f \
- --hash=sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5 \
- --hash=sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e \
- --hash=sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a \
- --hash=sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f \
- --hash=sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50 \
- --hash=sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a \
- --hash=sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b \
- --hash=sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4 \
- --hash=sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff \
- --hash=sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2 \
- --hash=sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46 \
- --hash=sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b \
- --hash=sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf \
- --hash=sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5 \
- --hash=sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5 \
- --hash=sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab \
- --hash=sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd \
- --hash=sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68
+markupsafe==3.0.1 \
+ --hash=sha256:0778de17cff1acaeccc3ff30cd99a3fd5c50fc58ad3d6c0e0c4c58092b859396 \
+ --hash=sha256:0f84af7e813784feb4d5e4ff7db633aba6c8ca64a833f61d8e4eade234ef0c38 \
+ --hash=sha256:17b2aea42a7280db02ac644db1d634ad47dcc96faf38ab304fe26ba2680d359a \
+ --hash=sha256:242d6860f1fd9191aef5fae22b51c5c19767f93fb9ead4d21924e0bcb17619d8 \
+ --hash=sha256:244dbe463d5fb6d7ce161301a03a6fe744dac9072328ba9fc82289238582697b \
+ --hash=sha256:26627785a54a947f6d7336ce5963569b5d75614619e75193bdb4e06e21d447ad \
+ --hash=sha256:2a4b34a8d14649315c4bc26bbfa352663eb51d146e35eef231dd739d54a5430a \
+ --hash=sha256:2ae99f31f47d849758a687102afdd05bd3d3ff7dbab0a8f1587981b58a76152a \
+ --hash=sha256:312387403cd40699ab91d50735ea7a507b788091c416dd007eac54434aee51da \
+ --hash=sha256:3341c043c37d78cc5ae6e3e305e988532b072329639007fd408a476642a89fd6 \
+ --hash=sha256:33d1c36b90e570ba7785dacd1faaf091203d9942bc036118fab8110a401eb1a8 \
+ --hash=sha256:3e683ee4f5d0fa2dde4db77ed8dd8a876686e3fc417655c2ece9a90576905344 \
+ --hash=sha256:3ffb4a8e7d46ed96ae48805746755fadd0909fea2306f93d5d8233ba23dda12a \
+ --hash=sha256:40621d60d0e58aa573b68ac5e2d6b20d44392878e0bfc159012a5787c4e35bc8 \
+ --hash=sha256:40f1e10d51c92859765522cbd79c5c8989f40f0419614bcdc5015e7b6bf97fc5 \
+ --hash=sha256:45d42d132cff577c92bfba536aefcfea7e26efb975bd455db4e6602f5c9f45e7 \
+ --hash=sha256:48488d999ed50ba8d38c581d67e496f955821dc183883550a6fbc7f1aefdc170 \
+ --hash=sha256:4935dd7883f1d50e2ffecca0aa33dc1946a94c8f3fdafb8df5c330e48f71b132 \
+ --hash=sha256:4c2d64fdba74ad16138300815cfdc6ab2f4647e23ced81f59e940d7d4a1469d9 \
+ --hash=sha256:4c8817557d0de9349109acb38b9dd570b03cc5014e8aabf1cbddc6e81005becd \
+ --hash=sha256:4ffaaac913c3f7345579db4f33b0020db693f302ca5137f106060316761beea9 \
+ --hash=sha256:5a4cb365cb49b750bdb60b846b0c0bc49ed62e59a76635095a179d440540c346 \
+ --hash=sha256:62fada2c942702ef8952754abfc1a9f7658a4d5460fabe95ac7ec2cbe0d02abc \
+ --hash=sha256:67c519635a4f64e495c50e3107d9b4075aec33634272b5db1cde839e07367589 \
+ --hash=sha256:6a54c43d3ec4cf2a39f4387ad044221c66a376e58c0d0e971d47c475ba79c6b5 \
+ --hash=sha256:7044312a928a66a4c2a22644147bc61a199c1709712069a344a3fb5cfcf16915 \
+ --hash=sha256:730d86af59e0e43ce277bb83970530dd223bf7f2a838e086b50affa6ec5f9295 \
+ --hash=sha256:800100d45176652ded796134277ecb13640c1a537cad3b8b53da45aa96330453 \
+ --hash=sha256:80fcbf3add8790caddfab6764bde258b5d09aefbe9169c183f88a7410f0f6dea \
+ --hash=sha256:82b5dba6eb1bcc29cc305a18a3c5365d2af06ee71b123216416f7e20d2a84e5b \
+ --hash=sha256:852dc840f6d7c985603e60b5deaae1d89c56cb038b577f6b5b8c808c97580f1d \
+ --hash=sha256:8ad4ad1429cd4f315f32ef263c1342166695fad76c100c5d979c45d5570ed58b \
+ --hash=sha256:8ae369e84466aa70f3154ee23c1451fda10a8ee1b63923ce76667e3077f2b0c4 \
+ --hash=sha256:93e8248d650e7e9d49e8251f883eed60ecbc0e8ffd6349e18550925e31bd029b \
+ --hash=sha256:973a371a55ce9ed333a3a0f8e0bcfae9e0d637711534bcb11e130af2ab9334e7 \
+ --hash=sha256:9ba25a71ebf05b9bb0e2ae99f8bc08a07ee8e98c612175087112656ca0f5c8bf \
+ --hash=sha256:a10860e00ded1dd0a65b83e717af28845bb7bd16d8ace40fe5531491de76b79f \
+ --hash=sha256:a4792d3b3a6dfafefdf8e937f14906a51bd27025a36f4b188728a73382231d91 \
+ --hash=sha256:a7420ceda262dbb4b8d839a4ec63d61c261e4e77677ed7c66c99f4e7cb5030dd \
+ --hash=sha256:ad91738f14eb8da0ff82f2acd0098b6257621410dcbd4df20aaa5b4233d75a50 \
+ --hash=sha256:b6a387d61fe41cdf7ea95b38e9af11cfb1a63499af2759444b99185c4ab33f5b \
+ --hash=sha256:b954093679d5750495725ea6f88409946d69cfb25ea7b4c846eef5044194f583 \
+ --hash=sha256:bbde71a705f8e9e4c3e9e33db69341d040c827c7afa6789b14c6e16776074f5a \
+ --hash=sha256:beeebf760a9c1f4c07ef6a53465e8cfa776ea6a2021eda0d0417ec41043fe984 \
+ --hash=sha256:c91b394f7601438ff79a4b93d16be92f216adb57d813a78be4446fe0f6bc2d8c \
+ --hash=sha256:c97ff7fedf56d86bae92fa0a646ce1a0ec7509a7578e1ed238731ba13aabcd1c \
+ --hash=sha256:cb53e2a99df28eee3b5f4fea166020d3ef9116fdc5764bc5117486e6d1211b25 \
+ --hash=sha256:cbf445eb5628981a80f54087f9acdbf84f9b7d862756110d172993b9a5ae81aa \
+ --hash=sha256:d06b24c686a34c86c8c1fba923181eae6b10565e4d80bdd7bc1c8e2f11247aa4 \
+ --hash=sha256:d98e66a24497637dd31ccab090b34392dddb1f2f811c4b4cd80c230205c074a3 \
+ --hash=sha256:db15ce28e1e127a0013dfb8ac243a8e392db8c61eae113337536edb28bdc1f97 \
+ --hash=sha256:db842712984e91707437461930e6011e60b39136c7331e971952bb30465bc1a1 \
+ --hash=sha256:e24bfe89c6ac4c31792793ad9f861b8f6dc4546ac6dc8f1c9083c7c4f2b335cd \
+ --hash=sha256:e81c52638315ff4ac1b533d427f50bc0afc746deb949210bc85f05d4f15fd772 \
+ --hash=sha256:e9393357f19954248b00bed7c56f29a25c930593a77630c719653d51e7669c2a \
+ --hash=sha256:ee3941769bd2522fe39222206f6dd97ae83c442a94c90f2b7a25d847d40f4729 \
+ --hash=sha256:f31ae06f1328595d762c9a2bf29dafd8621c7d3adc130cbb46278079758779ca \
+ --hash=sha256:f94190df587738280d544971500b9cafc9b950d32efcb1fba9ac10d84e6aa4e6 \
+ --hash=sha256:fa7d686ed9883f3d664d39d5a8e74d3c5f63e603c2e3ff0abcba23eac6542635 \
+ --hash=sha256:fb532dd9900381d2e8f48172ddc5a59db4c445a11b9fab40b3b786da40d3b56b \
+ --hash=sha256:fe32482b37b4b00c7a52a07211b479653b7fe4f22b2e481b9a9b099d8a430f2f
# via jinja2
mdurl==0.1.2 \
--hash=sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8 \
--hash=sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba
# via markdown-it-py
-more-itertools==10.3.0 \
- --hash=sha256:e5d93ef411224fbcef366a6e8ddc4c5781bc6359d43412a65dd5964e46111463 \
- --hash=sha256:ea6a02e24a9161e51faad17a8782b92a0df82c12c1c8886fec7f0c3fa1a1b320
+more-itertools==10.5.0 \
+ --hash=sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef \
+ --hash=sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6
# via
# jaraco-classes
# jaraco-functools
@@ -389,9 +359,9 @@ nh3==0.2.18 \
--hash=sha256:de3ceed6e661954871d6cd78b410213bdcb136f79aafe22aa7182e028b8c7307 \
--hash=sha256:f0eca9ca8628dbb4e916ae2491d72957fdd35f7a5d326b7032a345f111ac07fe
# via readme-renderer
-nox==2024.4.15 \
- --hash=sha256:6492236efa15a460ecb98e7b67562a28b70da006ab0be164e8821177577c0565 \
- --hash=sha256:ecf6700199cdfa9e5ea0a41ff5e6ef4641d09508eda6edb89d9987864115817f
+nox==2024.10.9 \
+ --hash=sha256:1d36f309a0a2a853e9bccb76bbef6bb118ba92fa92674d15604ca99adeb29eab \
+ --hash=sha256:7aa9dc8d1c27e9f45ab046ffd1c3b2c4f7c91755304769df231308849ebded95
# via -r requirements.in
packaging==24.1 \
--hash=sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002 \
@@ -403,41 +373,41 @@ pkginfo==1.10.0 \
--hash=sha256:5df73835398d10db79f8eecd5cd86b1f6d29317589ea70796994d49399af6297 \
--hash=sha256:889a6da2ed7ffc58ab5b900d888ddce90bce912f2d2de1dc1c26f4cb9fe65097
# via twine
-platformdirs==4.2.2 \
- --hash=sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee \
- --hash=sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3
+platformdirs==4.3.6 \
+ --hash=sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907 \
+ --hash=sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb
# via virtualenv
proto-plus==1.24.0 \
--hash=sha256:30b72a5ecafe4406b0d339db35b56c4059064e69227b8c3bda7462397f966445 \
--hash=sha256:402576830425e5f6ce4c2a6702400ac79897dab0b4343821aa5188b0fab81a12
# via google-api-core
-protobuf==5.27.2 \
- --hash=sha256:0e341109c609749d501986b835f667c6e1e24531096cff9d34ae411595e26505 \
- --hash=sha256:176c12b1f1c880bf7a76d9f7c75822b6a2bc3db2d28baa4d300e8ce4cde7409b \
- --hash=sha256:354d84fac2b0d76062e9b3221f4abbbacdfd2a4d8af36bab0474f3a0bb30ab38 \
- --hash=sha256:4fadd8d83e1992eed0248bc50a4a6361dc31bcccc84388c54c86e530b7f58863 \
- --hash=sha256:54330f07e4949d09614707c48b06d1a22f8ffb5763c159efd5c0928326a91470 \
- --hash=sha256:610e700f02469c4a997e58e328cac6f305f649826853813177e6290416e846c6 \
- --hash=sha256:7fc3add9e6003e026da5fc9e59b131b8f22b428b991ccd53e2af8071687b4fce \
- --hash=sha256:9e8f199bf7f97bd7ecebffcae45ebf9527603549b2b562df0fbc6d4d688f14ca \
- --hash=sha256:a109916aaac42bff84702fb5187f3edadbc7c97fc2c99c5ff81dd15dcce0d1e5 \
- --hash=sha256:b848dbe1d57ed7c191dfc4ea64b8b004a3f9ece4bf4d0d80a367b76df20bf36e \
- --hash=sha256:f3ecdef226b9af856075f28227ff2c90ce3a594d092c39bee5513573f25e2714
+protobuf==5.28.2 \
+ --hash=sha256:2c69461a7fcc8e24be697624c09a839976d82ae75062b11a0972e41fd2cd9132 \
+ --hash=sha256:35cfcb15f213449af7ff6198d6eb5f739c37d7e4f1c09b5d0641babf2cc0c68f \
+ --hash=sha256:52235802093bd8a2811abbe8bf0ab9c5f54cca0a751fdd3f6ac2a21438bffece \
+ --hash=sha256:59379674ff119717404f7454647913787034f03fe7049cbef1d74a97bb4593f0 \
+ --hash=sha256:5e8a95246d581eef20471b5d5ba010d55f66740942b95ba9b872d918c459452f \
+ --hash=sha256:87317e9bcda04a32f2ee82089a204d3a2f0d3c8aeed16568c7daf4756e4f1fe0 \
+ --hash=sha256:8ddc60bf374785fb7cb12510b267f59067fa10087325b8e1855b898a0d81d276 \
+ --hash=sha256:a8b9403fc70764b08d2f593ce44f1d2920c5077bf7d311fefec999f8c40f78b7 \
+ --hash=sha256:c0ea0123dac3399a2eeb1a1443d82b7afc9ff40241433296769f7da42d142ec3 \
+ --hash=sha256:ca53faf29896c526863366a52a8f4d88e69cd04ec9571ed6082fa117fac3ab36 \
+ --hash=sha256:eeea10f3dc0ac7e6b4933d32db20662902b4ab81bf28df12218aa389e9c2102d
# via
# gcp-docuploader
# gcp-releasetool
# google-api-core
# googleapis-common-protos
# proto-plus
-pyasn1==0.6.0 \
- --hash=sha256:3a35ab2c4b5ef98e17dfdec8ab074046fbda76e281c5a706ccd82328cfc8f64c \
- --hash=sha256:cca4bb0f2df5504f02f6f8a775b6e416ff9b0b3b16f7ee80b5a3153d9b804473
+pyasn1==0.6.1 \
+ --hash=sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629 \
+ --hash=sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034
# via
# pyasn1-modules
# rsa
-pyasn1-modules==0.4.0 \
- --hash=sha256:831dbcea1b177b28c9baddf4c6d1013c24c3accd14a1873fffaa6a2e905f17b6 \
- --hash=sha256:be04f15b66c206eed667e0bb5ab27e2b1855ea54a842e5037738099e8ca4ae0b
+pyasn1-modules==0.4.1 \
+ --hash=sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd \
+ --hash=sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c
# via google-auth
pycparser==2.22 \
--hash=sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6 \
@@ -449,9 +419,9 @@ pygments==2.18.0 \
# via
# readme-renderer
# rich
-pyjwt==2.8.0 \
- --hash=sha256:57e28d156e3d5c10088e0c68abb90bfac3df82b40a71bd0daa20c65ccd5c23de \
- --hash=sha256:59127c392cc44c2da5bb3192169a91f429924e17aff6534d70fdc02ab3e04320
+pyjwt==2.9.0 \
+ --hash=sha256:3b02fb0f44517787776cf48f2ae25d8e14f300e6d7545a4315cee571a415e850 \
+ --hash=sha256:7e1e5b56cc735432a7369cbfa0efe50fa113ebecdc04ae6922deba8b84582d0c
# via gcp-releasetool
pyperclip==1.9.0 \
--hash=sha256:b7de0142ddc81bfc5c7507eea19da920b92252b548b96186caf94a5e2527d310
@@ -481,9 +451,9 @@ rfc3986==2.0.0 \
--hash=sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd \
--hash=sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c
# via twine
-rich==13.7.1 \
- --hash=sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222 \
- --hash=sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432
+rich==13.9.2 \
+ --hash=sha256:51a2c62057461aaf7152b4d611168f93a9fc73068f8ded2790f29fe2b5366d0c \
+ --hash=sha256:8c82a3d3f8dcfe9e734771313e606b39d8247bb6b826e196f4914b333b743cf1
# via twine
rsa==4.9 \
--hash=sha256:90260d9058e514786967344d0ef75fa8727eed8a7d2e43ce9f4bcf1b536174f7 \
@@ -499,9 +469,9 @@ six==1.16.0 \
# via
# gcp-docuploader
# python-dateutil
-tomli==2.0.1 \
- --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
- --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
+tomli==2.0.2 \
+ --hash=sha256:2ebe24485c53d303f690b0ec092806a085f07af5a5aa1464f3931eec36caaa38 \
+ --hash=sha256:d46d457a85337051c36524bc5349dd91b1877838e2979ac5ced3e710ed8a60ed
# via nox
twine==5.1.1 \
--hash=sha256:215dbe7b4b94c2c50a7315c0275d2258399280fbb7d04182c7e55e24b5f93997 \
@@ -510,28 +480,30 @@ twine==5.1.1 \
typing-extensions==4.12.2 \
--hash=sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d \
--hash=sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8
- # via -r requirements.in
-urllib3==2.2.2 \
- --hash=sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472 \
- --hash=sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168
+ # via
+ # -r requirements.in
+ # rich
+urllib3==2.2.3 \
+ --hash=sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac \
+ --hash=sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9
# via
# requests
# twine
-virtualenv==20.26.3 \
- --hash=sha256:4c43a2a236279d9ea36a0d76f98d84bd6ca94ac4e0f4a3b9d46d05e10fea542a \
- --hash=sha256:8cc4a31139e796e9a7de2cd5cf2489de1217193116a8fd42328f1bd65f434589
+virtualenv==20.26.6 \
+ --hash=sha256:280aede09a2a5c317e409a00102e7077c6432c5a38f0ef938e643805a7ad2c48 \
+ --hash=sha256:7345cc5b25405607a624d8418154577459c3e0277f5466dd79c49d5e492995f2
# via nox
-wheel==0.43.0 \
- --hash=sha256:465ef92c69fa5c5da2d1cf8ac40559a8c940886afcef87dcf14b9470862f1d85 \
- --hash=sha256:55c570405f142630c6b9f72fe09d9b67cf1477fcf543ae5b8dcb1f5b7377da81
+wheel==0.44.0 \
+ --hash=sha256:2376a90c98cc337d18623527a97c31797bd02bad0033d41547043a1cbfbe448f \
+ --hash=sha256:a29c3f2817e95ab89aa4660681ad547c0e9547f20e75b0562fe7723c9a2a9d49
# via -r requirements.in
-zipp==3.19.2 \
- --hash=sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19 \
- --hash=sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c
+zipp==3.20.2 \
+ --hash=sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350 \
+ --hash=sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29
# via importlib-metadata
# The following packages are considered to be unsafe in a requirements file:
-setuptools==70.2.0 \
- --hash=sha256:b8b8060bb426838fbe942479c90296ce976249451118ef566a5a0b7d8b78fb05 \
- --hash=sha256:bd63e505105011b25c3c11f753f7e3b8465ea739efddaccef8f0efac2137bac1
+setuptools==75.1.0 \
+ --hash=sha256:35ab7fd3bcd95e6b7fd704e4a1539513edad446c097797f2985e0e4b960772f2 \
+ --hash=sha256:d59a21b17a275fb872a9c3dae73963160ae079f1049ed956880cd7c09b120538
# via -r requirements.in
diff --git a/.kokoro/samples/python3.13/common.cfg b/.kokoro/samples/python3.13/common.cfg
new file mode 100644
index 000000000..15ba807cb
--- /dev/null
+++ b/.kokoro/samples/python3.13/common.cfg
@@ -0,0 +1,40 @@
+# Format: //devtools/kokoro/config/proto/build.proto
+
+# Build logs will be here
+action {
+ define_artifacts {
+ regex: "**/*sponge_log.xml"
+ }
+}
+
+# Specify which tests to run
+env_vars: {
+ key: "RUN_TESTS_SESSION"
+ value: "py-3.13"
+}
+
+# Declare build specific Cloud project.
+env_vars: {
+ key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
+ value: "python-docs-samples-tests-313"
+}
+
+env_vars: {
+ key: "TRAMPOLINE_BUILD_FILE"
+ value: "github/python-bigtable/.kokoro/test-samples.sh"
+}
+
+# Configure the docker image for kokoro-trampoline.
+env_vars: {
+ key: "TRAMPOLINE_IMAGE"
+ value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
+}
+
+# Download secrets for samples
+gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
+
+# Download trampoline resources.
+gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
+
+# Use the trampoline script to run in docker.
+build_file: "python-bigtable/.kokoro/trampoline_v2.sh"
diff --git a/.kokoro/samples/python3.13/continuous.cfg b/.kokoro/samples/python3.13/continuous.cfg
new file mode 100644
index 000000000..a1c8d9759
--- /dev/null
+++ b/.kokoro/samples/python3.13/continuous.cfg
@@ -0,0 +1,6 @@
+# Format: //devtools/kokoro/config/proto/build.proto
+
+env_vars: {
+ key: "INSTALL_LIBRARY_FROM_SOURCE"
+ value: "True"
+}
\ No newline at end of file
diff --git a/.kokoro/samples/python3.13/periodic-head.cfg b/.kokoro/samples/python3.13/periodic-head.cfg
new file mode 100644
index 000000000..be25a34f9
--- /dev/null
+++ b/.kokoro/samples/python3.13/periodic-head.cfg
@@ -0,0 +1,11 @@
+# Format: //devtools/kokoro/config/proto/build.proto
+
+env_vars: {
+ key: "INSTALL_LIBRARY_FROM_SOURCE"
+ value: "True"
+}
+
+env_vars: {
+ key: "TRAMPOLINE_BUILD_FILE"
+ value: "github/python-bigtable/.kokoro/test-samples-against-head.sh"
+}
diff --git a/.kokoro/samples/python3.13/periodic.cfg b/.kokoro/samples/python3.13/periodic.cfg
new file mode 100644
index 000000000..71cd1e597
--- /dev/null
+++ b/.kokoro/samples/python3.13/periodic.cfg
@@ -0,0 +1,6 @@
+# Format: //devtools/kokoro/config/proto/build.proto
+
+env_vars: {
+ key: "INSTALL_LIBRARY_FROM_SOURCE"
+ value: "False"
+}
diff --git a/.kokoro/samples/python3.13/presubmit.cfg b/.kokoro/samples/python3.13/presubmit.cfg
new file mode 100644
index 000000000..a1c8d9759
--- /dev/null
+++ b/.kokoro/samples/python3.13/presubmit.cfg
@@ -0,0 +1,6 @@
+# Format: //devtools/kokoro/config/proto/build.proto
+
+env_vars: {
+ key: "INSTALL_LIBRARY_FROM_SOURCE"
+ value: "True"
+}
\ No newline at end of file
diff --git a/.kokoro/test-samples-impl.sh b/.kokoro/test-samples-impl.sh
index 55910c8ba..53e365bc4 100755
--- a/.kokoro/test-samples-impl.sh
+++ b/.kokoro/test-samples-impl.sh
@@ -33,7 +33,8 @@ export PYTHONUNBUFFERED=1
env | grep KOKORO
# Install nox
-python3.9 -m pip install --upgrade --quiet nox
+# `virtualenv==20.26.6` is added for Python 3.7 compatibility
+python3.9 -m pip install --upgrade --quiet nox virtualenv==20.26.6
# Use secrets acessor service account to get secrets
if [[ -f "${KOKORO_GFILE_DIR}/secrets_viewer_service_account.json" ]]; then
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index d6de1e7f8..2da95504a 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
{
- ".": "2.26.0"
+ ".": "2.27.0"
}
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 09bffa32d..8abd58f89 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,19 @@
[1]: https://pypi.org/project/google-cloud-bigtable/#history
+## [2.27.0](https://github.com/googleapis/python-bigtable/compare/v2.26.0...v2.27.0) (2024-11-12)
+
+
+### Features
+
+* Add support for Cloud Bigtable Node Scaling Factor for CBT Clusters ([#1023](https://github.com/googleapis/python-bigtable/issues/1023)) ([0809c6a](https://github.com/googleapis/python-bigtable/commit/0809c6ac274e909103ad160a8bcab95f8bb46f31))
+* Surface `retry` param to `Table.read_row` api ([#982](https://github.com/googleapis/python-bigtable/issues/982)) ([a8286d2](https://github.com/googleapis/python-bigtable/commit/a8286d2a510f654f9c270c3c761c02e4ab3817d4))
+
+
+### Bug Fixes
+
+* Registering duplicate instance ([#1033](https://github.com/googleapis/python-bigtable/issues/1033)) ([2bca8fb](https://github.com/googleapis/python-bigtable/commit/2bca8fb220eeb1906fc6a3cf1f879f3d41fbbff8))
+
## [2.26.0](https://github.com/googleapis/python-bigtable/compare/v2.25.0...v2.26.0) (2024-08-12)
diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index 947c129b7..985538f48 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -22,7 +22,7 @@ In order to add a feature:
documentation.
- The feature must work fully on the following CPython versions:
- 3.7, 3.8, 3.9, 3.10, 3.11 and 3.12 on both UNIX and Windows.
+ 3.7, 3.8, 3.9, 3.10, 3.11, 3.12 and 3.13 on both UNIX and Windows.
- The feature must not add unnecessary dependencies (where
"unnecessary" is of course subjective, but new dependencies should
@@ -72,7 +72,7 @@ We use `nox `__ to instrument our tests.
- To run a single unit test::
- $ nox -s unit-3.12 -- -k
+ $ nox -s unit-3.13 -- -k
.. note::
@@ -227,6 +227,7 @@ We support:
- `Python 3.10`_
- `Python 3.11`_
- `Python 3.12`_
+- `Python 3.13`_
.. _Python 3.7: https://docs.python.org/3.7/
.. _Python 3.8: https://docs.python.org/3.8/
@@ -234,6 +235,7 @@ We support:
.. _Python 3.10: https://docs.python.org/3.10/
.. _Python 3.11: https://docs.python.org/3.11/
.. _Python 3.12: https://docs.python.org/3.12/
+.. _Python 3.13: https://docs.python.org/3.13/
Supported versions can be found in our ``noxfile.py`` `config`_.
diff --git a/docs/async_data_client/async_data_usage.rst b/docs/async_data_client/async_data_usage.rst
deleted file mode 100644
index 61d5837fd..000000000
--- a/docs/async_data_client/async_data_usage.rst
+++ /dev/null
@@ -1,18 +0,0 @@
-Async Data Client
-=================
-
-.. toctree::
- :maxdepth: 2
-
- async_data_client
- async_data_table
- async_data_mutations_batcher
- async_data_read_rows_query
- async_data_row
- async_data_row_filters
- async_data_mutations
- async_data_read_modify_write_rules
- async_data_exceptions
- async_data_execute_query_iterator
- async_data_execute_query_values
- async_data_execute_query_metadata
diff --git a/docs/async_data_client/async_data_client.rst b/docs/data_client/async_data_client.rst
similarity index 79%
rename from docs/async_data_client/async_data_client.rst
rename to docs/data_client/async_data_client.rst
index 0e1d9e23e..2ddcc090c 100644
--- a/docs/async_data_client/async_data_client.rst
+++ b/docs/data_client/async_data_client.rst
@@ -7,6 +7,6 @@ Bigtable Data Client Async
performance benefits, the codebase should be designed to be async from the ground up.
-.. autoclass:: google.cloud.bigtable.data._async.client.BigtableDataClientAsync
+.. autoclass:: google.cloud.bigtable.data.BigtableDataClientAsync
:members:
:show-inheritance:
diff --git a/docs/async_data_client/async_data_execute_query_iterator.rst b/docs/data_client/async_data_execute_query_iterator.rst
similarity index 100%
rename from docs/async_data_client/async_data_execute_query_iterator.rst
rename to docs/data_client/async_data_execute_query_iterator.rst
diff --git a/docs/async_data_client/async_data_mutations_batcher.rst b/docs/data_client/async_data_mutations_batcher.rst
similarity index 100%
rename from docs/async_data_client/async_data_mutations_batcher.rst
rename to docs/data_client/async_data_mutations_batcher.rst
diff --git a/docs/async_data_client/async_data_table.rst b/docs/data_client/async_data_table.rst
similarity index 100%
rename from docs/async_data_client/async_data_table.rst
rename to docs/data_client/async_data_table.rst
diff --git a/docs/async_data_client/async_data_exceptions.rst b/docs/data_client/common_data_exceptions.rst
similarity index 100%
rename from docs/async_data_client/async_data_exceptions.rst
rename to docs/data_client/common_data_exceptions.rst
diff --git a/docs/async_data_client/async_data_execute_query_metadata.rst b/docs/data_client/common_data_execute_query_metadata.rst
similarity index 100%
rename from docs/async_data_client/async_data_execute_query_metadata.rst
rename to docs/data_client/common_data_execute_query_metadata.rst
diff --git a/docs/async_data_client/async_data_execute_query_values.rst b/docs/data_client/common_data_execute_query_values.rst
similarity index 100%
rename from docs/async_data_client/async_data_execute_query_values.rst
rename to docs/data_client/common_data_execute_query_values.rst
diff --git a/docs/async_data_client/async_data_mutations.rst b/docs/data_client/common_data_mutations.rst
similarity index 100%
rename from docs/async_data_client/async_data_mutations.rst
rename to docs/data_client/common_data_mutations.rst
diff --git a/docs/async_data_client/async_data_read_modify_write_rules.rst b/docs/data_client/common_data_read_modify_write_rules.rst
similarity index 100%
rename from docs/async_data_client/async_data_read_modify_write_rules.rst
rename to docs/data_client/common_data_read_modify_write_rules.rst
diff --git a/docs/async_data_client/async_data_read_rows_query.rst b/docs/data_client/common_data_read_rows_query.rst
similarity index 100%
rename from docs/async_data_client/async_data_read_rows_query.rst
rename to docs/data_client/common_data_read_rows_query.rst
diff --git a/docs/async_data_client/async_data_row.rst b/docs/data_client/common_data_row.rst
similarity index 100%
rename from docs/async_data_client/async_data_row.rst
rename to docs/data_client/common_data_row.rst
diff --git a/docs/async_data_client/async_data_row_filters.rst b/docs/data_client/common_data_row_filters.rst
similarity index 100%
rename from docs/async_data_client/async_data_row_filters.rst
rename to docs/data_client/common_data_row_filters.rst
diff --git a/docs/data_client/data_client_usage.rst b/docs/data_client/data_client_usage.rst
new file mode 100644
index 000000000..f5bbac278
--- /dev/null
+++ b/docs/data_client/data_client_usage.rst
@@ -0,0 +1,39 @@
+Data Client
+===========
+
+Sync Surface
+------------
+
+.. toctree::
+ :maxdepth: 3
+
+ sync_data_client
+ sync_data_table
+ sync_data_mutations_batcher
+ sync_data_execute_query_iterator
+
+Async Surface
+-------------
+
+.. toctree::
+ :maxdepth: 3
+
+ async_data_client
+ async_data_table
+ async_data_mutations_batcher
+ async_data_execute_query_iterator
+
+Common Classes
+--------------
+
+.. toctree::
+ :maxdepth: 3
+
+ common_data_read_rows_query
+ common_data_row
+ common_data_row_filters
+ common_data_mutations
+ common_data_read_modify_write_rules
+ common_data_exceptions
+ common_data_execute_query_values
+ common_data_execute_query_metadata
diff --git a/docs/data_client/sync_data_client.rst b/docs/data_client/sync_data_client.rst
new file mode 100644
index 000000000..cf7c00dad
--- /dev/null
+++ b/docs/data_client/sync_data_client.rst
@@ -0,0 +1,6 @@
+Bigtable Data Client
+~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: google.cloud.bigtable.data.BigtableDataClient
+ :members:
+ :show-inheritance:
diff --git a/docs/data_client/sync_data_execute_query_iterator.rst b/docs/data_client/sync_data_execute_query_iterator.rst
new file mode 100644
index 000000000..6eb9f84db
--- /dev/null
+++ b/docs/data_client/sync_data_execute_query_iterator.rst
@@ -0,0 +1,6 @@
+Execute Query Iterator
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: google.cloud.bigtable.data.execute_query.ExecuteQueryIterator
+ :members:
+ :show-inheritance:
diff --git a/docs/data_client/sync_data_mutations_batcher.rst b/docs/data_client/sync_data_mutations_batcher.rst
new file mode 100644
index 000000000..2b7d1bfe0
--- /dev/null
+++ b/docs/data_client/sync_data_mutations_batcher.rst
@@ -0,0 +1,6 @@
+Mutations Batcher
+~~~~~~~~~~~~~~~~~
+
+.. automodule:: google.cloud.bigtable.data._sync_autogen.mutations_batcher
+ :members:
+ :show-inheritance:
diff --git a/docs/data_client/sync_data_table.rst b/docs/data_client/sync_data_table.rst
new file mode 100644
index 000000000..95c91eb27
--- /dev/null
+++ b/docs/data_client/sync_data_table.rst
@@ -0,0 +1,6 @@
+Table
+~~~~~
+
+.. autoclass:: google.cloud.bigtable.data.Table
+ :members:
+ :show-inheritance:
diff --git a/docs/index.rst b/docs/index.rst
index 4204e981d..c7f9721f3 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -5,10 +5,10 @@
Client Types
-------------
.. toctree::
- :maxdepth: 2
+ :maxdepth: 3
+ data_client/data_client_usage
classic_client/usage
- async_data_client/async_data_usage
Changelog
diff --git a/docs/scripts/patch_devsite_toc.py b/docs/scripts/patch_devsite_toc.py
index 456d0af7b..5889300d2 100644
--- a/docs/scripts/patch_devsite_toc.py
+++ b/docs/scripts/patch_devsite_toc.py
@@ -117,7 +117,8 @@ def __init__(self, dir_name, index_file_name):
continue
# bail when toc indented block is done
if not line.startswith(" ") and not line.startswith("\t"):
- break
+ in_toc = False
+ continue
# extract entries
self.items.append(self.extract_toc_entry(line.strip()))
@@ -194,9 +195,7 @@ def validate_toc(toc_file_path, expected_section_list, added_sections):
# Add secrtions for the async_data_client and classic_client directories
toc_path = "_build/html/docfx_yaml/toc.yml"
custom_sections = [
- TocSection(
- dir_name="async_data_client", index_file_name="async_data_usage.rst"
- ),
+ TocSection(dir_name="data_client", index_file_name="data_client_usage.rst"),
TocSection(dir_name="classic_client", index_file_name="usage.rst"),
]
add_sections(toc_path, custom_sections)
@@ -210,7 +209,7 @@ def validate_toc(toc_file_path, expected_section_list, added_sections):
"bigtable APIs",
"Changelog",
"Multiprocessing",
- "Async Data Client",
+ "Data Client",
"Classic Client",
],
added_sections=custom_sections,
diff --git a/gapic-generator-fork b/gapic-generator-fork
deleted file mode 160000
index b26cda7d1..000000000
--- a/gapic-generator-fork
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit b26cda7d163d6e0d45c9684f328ca32fb49b799a
diff --git a/google/cloud/bigtable/data/__init__.py b/google/cloud/bigtable/data/__init__.py
index 68dc22891..15f9bc167 100644
--- a/google/cloud/bigtable/data/__init__.py
+++ b/google/cloud/bigtable/data/__init__.py
@@ -17,8 +17,10 @@
from google.cloud.bigtable.data._async.client import BigtableDataClientAsync
from google.cloud.bigtable.data._async.client import TableAsync
-
from google.cloud.bigtable.data._async.mutations_batcher import MutationsBatcherAsync
+from google.cloud.bigtable.data._sync_autogen.client import BigtableDataClient
+from google.cloud.bigtable.data._sync_autogen.client import Table
+from google.cloud.bigtable.data._sync_autogen.mutations_batcher import MutationsBatcher
from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
from google.cloud.bigtable.data.read_rows_query import RowRange
@@ -45,16 +47,42 @@
from google.cloud.bigtable.data._helpers import RowKeySamples
from google.cloud.bigtable.data._helpers import ShardedQuery
+# setup custom CrossSync mappings for library
+from google.cloud.bigtable_v2.services.bigtable.async_client import (
+ BigtableAsyncClient,
+)
+from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
+from google.cloud.bigtable.data._async._mutate_rows import _MutateRowsOperationAsync
+
+from google.cloud.bigtable_v2.services.bigtable.client import (
+ BigtableClient,
+)
+from google.cloud.bigtable.data._sync_autogen._read_rows import _ReadRowsOperation
+from google.cloud.bigtable.data._sync_autogen._mutate_rows import _MutateRowsOperation
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+CrossSync.add_mapping("GapicClient", BigtableAsyncClient)
+CrossSync._Sync_Impl.add_mapping("GapicClient", BigtableClient)
+CrossSync.add_mapping("_ReadRowsOperation", _ReadRowsOperationAsync)
+CrossSync._Sync_Impl.add_mapping("_ReadRowsOperation", _ReadRowsOperation)
+CrossSync.add_mapping("_MutateRowsOperation", _MutateRowsOperationAsync)
+CrossSync._Sync_Impl.add_mapping("_MutateRowsOperation", _MutateRowsOperation)
+CrossSync.add_mapping("MutationsBatcher", MutationsBatcherAsync)
+CrossSync._Sync_Impl.add_mapping("MutationsBatcher", MutationsBatcher)
__version__: str = package_version.__version__
__all__ = (
"BigtableDataClientAsync",
"TableAsync",
+ "MutationsBatcherAsync",
+ "BigtableDataClient",
+ "Table",
+ "MutationsBatcher",
"RowKeySamples",
"ReadRowsQuery",
"RowRange",
- "MutationsBatcherAsync",
"Mutation",
"RowMutationEntry",
"SetCell",
diff --git a/google/cloud/bigtable/data/_async/_mutate_rows.py b/google/cloud/bigtable/data/_async/_mutate_rows.py
index 465378aa4..bf618bf04 100644
--- a/google/cloud/bigtable/data/_async/_mutate_rows.py
+++ b/google/cloud/bigtable/data/_async/_mutate_rows.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -15,38 +15,38 @@
from __future__ import annotations
from typing import Sequence, TYPE_CHECKING
-from dataclasses import dataclass
import functools
from google.api_core import exceptions as core_exceptions
from google.api_core import retry as retries
-import google.cloud.bigtable_v2.types.bigtable as types_pb
import google.cloud.bigtable.data.exceptions as bt_exceptions
-from google.cloud.bigtable.data._helpers import _make_metadata
from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
from google.cloud.bigtable.data._helpers import _retry_exception_factory
# mutate_rows requests are limited to this number of mutations
from google.cloud.bigtable.data.mutations import _MUTATE_ROWS_REQUEST_MUTATION_LIMIT
+from google.cloud.bigtable.data.mutations import _EntryWithProto
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
if TYPE_CHECKING:
- from google.cloud.bigtable_v2.services.bigtable.async_client import (
- BigtableAsyncClient,
- )
from google.cloud.bigtable.data.mutations import RowMutationEntry
- from google.cloud.bigtable.data._async.client import TableAsync
-
-@dataclass
-class _EntryWithProto:
- """
- A dataclass to hold a RowMutationEntry and its corresponding proto representation.
- """
+ if CrossSync.is_async:
+ from google.cloud.bigtable_v2.services.bigtable.async_client import (
+ BigtableAsyncClient as GapicClientType,
+ )
+ from google.cloud.bigtable.data._async.client import TableAsync as TableType
+ else:
+ from google.cloud.bigtable_v2.services.bigtable.client import ( # type: ignore
+ BigtableClient as GapicClientType,
+ )
+ from google.cloud.bigtable.data._sync_autogen.client import Table as TableType # type: ignore
- entry: RowMutationEntry
- proto: types_pb.MutateRowsRequest.Entry
+__CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen._mutate_rows"
+@CrossSync.convert_class("_MutateRowsOperation")
class _MutateRowsOperationAsync:
"""
MutateRowsOperation manages the logic of sending a set of row mutations,
@@ -66,10 +66,11 @@ class _MutateRowsOperationAsync:
If not specified, the request will run until operation_timeout is reached.
"""
+ @CrossSync.convert
def __init__(
self,
- gapic_client: "BigtableAsyncClient",
- table: "TableAsync",
+ gapic_client: GapicClientType,
+ table: TableType,
mutation_entries: list["RowMutationEntry"],
operation_timeout: float,
attempt_timeout: float | None,
@@ -84,14 +85,10 @@ def __init__(
f"all entries. Found {total_mutations}."
)
# create partial function to pass to trigger rpc call
- metadata = _make_metadata(
- table.table_name, table.app_profile_id, instance_name=None
- )
self._gapic_fn = functools.partial(
gapic_client.mutate_rows,
table_name=table.table_name,
app_profile_id=table.app_profile_id,
- metadata=metadata,
retry=None,
)
# create predicate for determining which errors are retryable
@@ -102,7 +99,7 @@ def __init__(
bt_exceptions._MutateRowsIncomplete,
)
sleep_generator = retries.exponential_sleep_generator(0.01, 2, 60)
- self._operation = retries.retry_target_async(
+ self._operation = lambda: CrossSync.retry_target(
self._run_attempt,
self.is_retryable,
sleep_generator,
@@ -117,6 +114,7 @@ def __init__(
self.remaining_indices = list(range(len(self.mutations)))
self.errors: dict[int, list[Exception]] = {}
+ @CrossSync.convert
async def start(self):
"""
Start the operation, and run until completion
@@ -126,7 +124,7 @@ async def start(self):
"""
try:
# trigger mutate_rows
- await self._operation
+ await self._operation()
except Exception as exc:
# exceptions raised by retryable are added to the list of exceptions for all unfinalized mutations
incomplete_indices = self.remaining_indices.copy()
@@ -153,6 +151,7 @@ async def start(self):
all_errors, len(self.mutations)
)
+ @CrossSync.convert
async def _run_attempt(self):
"""
Run a single attempt of the mutate_rows rpc.
diff --git a/google/cloud/bigtable/data/_async/_read_rows.py b/google/cloud/bigtable/data/_async/_read_rows.py
index 6034ae6cf..6d2fa3a7d 100644
--- a/google/cloud/bigtable/data/_async/_read_rows.py
+++ b/google/cloud/bigtable/data/_async/_read_rows.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -15,13 +15,7 @@
from __future__ import annotations
-from typing import (
- TYPE_CHECKING,
- AsyncGenerator,
- AsyncIterable,
- Awaitable,
- Sequence,
-)
+from typing import Sequence, TYPE_CHECKING
from google.cloud.bigtable_v2.types import ReadRowsRequest as ReadRowsRequestPB
from google.cloud.bigtable_v2.types import ReadRowsResponse as ReadRowsResponsePB
@@ -32,22 +26,25 @@
from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
from google.cloud.bigtable.data.exceptions import InvalidChunk
from google.cloud.bigtable.data.exceptions import _RowSetComplete
+from google.cloud.bigtable.data.exceptions import _ResetRow
from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
-from google.cloud.bigtable.data._helpers import _make_metadata
from google.cloud.bigtable.data._helpers import _retry_exception_factory
from google.api_core import retry as retries
from google.api_core.retry import exponential_sleep_generator
-if TYPE_CHECKING:
- from google.cloud.bigtable.data._async.client import TableAsync
+from google.cloud.bigtable.data._cross_sync import CrossSync
+if TYPE_CHECKING:
+ if CrossSync.is_async:
+ from google.cloud.bigtable.data._async.client import TableAsync as TableType
+ else:
+ from google.cloud.bigtable.data._sync_autogen.client import Table as TableType # type: ignore
-class _ResetRow(Exception):
- def __init__(self, chunk):
- self.chunk = chunk
+__CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen._read_rows"
+@CrossSync.convert_class("_ReadRowsOperation")
class _ReadRowsOperationAsync:
"""
ReadRowsOperation handles the logic of merging chunks from a ReadRowsResponse stream
@@ -74,7 +71,6 @@ class _ReadRowsOperationAsync:
"request",
"table",
"_predicate",
- "_metadata",
"_last_yielded_row_key",
"_remaining_count",
)
@@ -82,7 +78,7 @@ class _ReadRowsOperationAsync:
def __init__(
self,
query: ReadRowsQuery,
- table: "TableAsync",
+ table: TableType,
operation_timeout: float,
attempt_timeout: float,
retryable_exceptions: Sequence[type[Exception]] = (),
@@ -101,20 +97,17 @@ def __init__(
self.request = query._to_pb(table)
self.table = table
self._predicate = retries.if_exception_type(*retryable_exceptions)
- self._metadata = _make_metadata(
- table.table_name, table.app_profile_id, instance_name=None
- )
self._last_yielded_row_key: bytes | None = None
self._remaining_count: int | None = self.request.rows_limit or None
- def start_operation(self) -> AsyncGenerator[Row, None]:
+ def start_operation(self) -> CrossSync.Iterable[Row]:
"""
Start the read_rows operation, retrying on retryable errors.
Yields:
Row: The next row in the stream
"""
- return retries.retry_target_stream_async(
+ return CrossSync.retry_target_stream(
self._read_rows_attempt,
self._predicate,
exponential_sleep_generator(0.01, 60, multiplier=2),
@@ -122,7 +115,7 @@ def start_operation(self) -> AsyncGenerator[Row, None]:
exception_factory=_retry_exception_factory,
)
- def _read_rows_attempt(self) -> AsyncGenerator[Row, None]:
+ def _read_rows_attempt(self) -> CrossSync.Iterable[Row]:
"""
Attempt a single read_rows rpc call.
This function is intended to be wrapped by retry logic,
@@ -152,15 +145,15 @@ def _read_rows_attempt(self) -> AsyncGenerator[Row, None]:
gapic_stream = self.table.client._gapic_client.read_rows(
self.request,
timeout=next(self.attempt_timeout_gen),
- metadata=self._metadata,
retry=None,
)
chunked_stream = self.chunk_stream(gapic_stream)
return self.merge_rows(chunked_stream)
+ @CrossSync.convert()
async def chunk_stream(
- self, stream: Awaitable[AsyncIterable[ReadRowsResponsePB]]
- ) -> AsyncGenerator[ReadRowsResponsePB.CellChunk, None]:
+ self, stream: CrossSync.Awaitable[CrossSync.Iterable[ReadRowsResponsePB]]
+ ) -> CrossSync.Iterable[ReadRowsResponsePB.CellChunk]:
"""
process chunks out of raw read_rows stream
@@ -210,9 +203,12 @@ async def chunk_stream(
current_key = None
@staticmethod
+ @CrossSync.convert(
+ replace_symbols={"__aiter__": "__iter__", "__anext__": "__next__"},
+ )
async def merge_rows(
- chunks: AsyncGenerator[ReadRowsResponsePB.CellChunk, None] | None
- ) -> AsyncGenerator[Row, None]:
+ chunks: CrossSync.Iterable[ReadRowsResponsePB.CellChunk] | None,
+ ) -> CrossSync.Iterable[Row]:
"""
Merge chunks into rows
@@ -228,7 +224,7 @@ async def merge_rows(
while True:
try:
c = await it.__anext__()
- except StopAsyncIteration:
+ except CrossSync.StopIteration:
# stream complete
return
row_key = c.row_key
@@ -321,7 +317,7 @@ async def merge_rows(
):
raise InvalidChunk("reset row with data")
continue
- except StopAsyncIteration:
+ except CrossSync.StopIteration:
raise InvalidChunk("premature end of stream")
@staticmethod
diff --git a/google/cloud/bigtable/data/_async/client.py b/google/cloud/bigtable/data/_async/client.py
index 82a874918..c7cc0de6b 100644
--- a/google/cloud/bigtable/data/_async/client.py
+++ b/google/cloud/bigtable/data/_async/client.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -15,112 +15,141 @@
from __future__ import annotations
-import asyncio
-from functools import partial
-import os
-import random
-import sys
-import time
from typing import (
- TYPE_CHECKING,
+ cast,
Any,
AsyncIterable,
- Dict,
Optional,
- Sequence,
Set,
- Union,
- cast,
+ Sequence,
+ TYPE_CHECKING,
)
+
+import time
import warnings
+import random
+import os
+import concurrent.futures
-from google.api_core import client_options as client_options_lib
-from google.api_core import retry as retries
-from google.api_core.exceptions import Aborted, DeadlineExceeded, ServiceUnavailable
-import google.auth._default
-import google.auth.credentials
-from google.cloud.client import ClientWithProject
-from google.cloud.environment_vars import BIGTABLE_EMULATOR # type: ignore
-import grpc
+from functools import partial
+from grpc import Channel
-from google.cloud.bigtable.client import _DEFAULT_BIGTABLE_EMULATOR_CLIENT
-from google.cloud.bigtable.data.execute_query._async.execute_query_iterator import (
- ExecuteQueryIteratorAsync,
-)
-from google.cloud.bigtable.data._async._mutate_rows import _MutateRowsOperationAsync
-from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
-from google.cloud.bigtable.data._async.mutations_batcher import (
- _MB_SIZE,
- MutationsBatcherAsync,
-)
-from google.cloud.bigtable.data._helpers import (
- _CONCURRENCY_LIMIT,
- TABLE_DEFAULT,
- _attempt_timeout_generator,
- _get_error_type,
- _get_retryable_errors,
- _get_timeouts,
- _make_metadata,
- _retry_exception_factory,
- _validate_timeouts,
- _WarmedInstanceKey,
-)
-from google.cloud.bigtable.data.exceptions import (
- FailedQueryShardError,
- ShardedReadRowsExceptionGroup,
-)
-from google.cloud.bigtable.data.mutations import Mutation, RowMutationEntry
-from google.cloud.bigtable.data.read_modify_write_rules import ReadModifyWriteRule
-from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
-from google.cloud.bigtable.data.row import Row
-from google.cloud.bigtable.data.row_filters import (
- CellsRowLimitFilter,
- RowFilter,
- RowFilterChain,
- StripValueTransformerFilter,
-)
from google.cloud.bigtable.data.execute_query.values import ExecuteQueryValueType
from google.cloud.bigtable.data.execute_query.metadata import SqlType
from google.cloud.bigtable.data.execute_query._parameters_formatting import (
_format_execute_query_params,
)
-from google.cloud.bigtable_v2.services.bigtable.async_client import (
+from google.cloud.bigtable_v2.services.bigtable.transports.base import (
DEFAULT_CLIENT_INFO,
- BigtableAsyncClient,
-)
-from google.cloud.bigtable_v2.services.bigtable.client import BigtableClientMeta
-from google.cloud.bigtable_v2.services.bigtable.transports.pooled_grpc_asyncio import (
- PooledBigtableGrpcAsyncIOTransport,
- PooledChannel,
)
from google.cloud.bigtable_v2.types.bigtable import PingAndWarmRequest
+from google.cloud.client import ClientWithProject
+from google.cloud.environment_vars import BIGTABLE_EMULATOR # type: ignore
+from google.api_core import retry as retries
+from google.api_core.exceptions import DeadlineExceeded
+from google.api_core.exceptions import ServiceUnavailable
+from google.api_core.exceptions import Aborted
+
+import google.auth.credentials
+import google.auth._default
+from google.api_core import client_options as client_options_lib
+from google.cloud.bigtable.client import _DEFAULT_BIGTABLE_EMULATOR_CLIENT
+from google.cloud.bigtable.data.row import Row
+from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+from google.cloud.bigtable.data.exceptions import FailedQueryShardError
+from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
+
+from google.cloud.bigtable.data._helpers import TABLE_DEFAULT
+from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
+from google.cloud.bigtable.data._helpers import _retry_exception_factory
+from google.cloud.bigtable.data._helpers import _validate_timeouts
+from google.cloud.bigtable.data._helpers import _get_error_type
+from google.cloud.bigtable.data._helpers import _get_retryable_errors
+from google.cloud.bigtable.data._helpers import _get_timeouts
+from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
+from google.cloud.bigtable.data.mutations import Mutation, RowMutationEntry
+
+from google.cloud.bigtable.data.read_modify_write_rules import ReadModifyWriteRule
+from google.cloud.bigtable.data.row_filters import RowFilter
+from google.cloud.bigtable.data.row_filters import StripValueTransformerFilter
+from google.cloud.bigtable.data.row_filters import CellsRowLimitFilter
+from google.cloud.bigtable.data.row_filters import RowFilterChain
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+if CrossSync.is_async:
+ from grpc.aio import insecure_channel
+ from google.cloud.bigtable_v2.services.bigtable.transports import (
+ BigtableGrpcAsyncIOTransport as TransportType,
+ )
+ from google.cloud.bigtable.data._async.mutations_batcher import _MB_SIZE
+else:
+ from typing import Iterable # noqa: F401
+ from grpc import insecure_channel
+ from google.cloud.bigtable_v2.services.bigtable.transports import BigtableGrpcTransport as TransportType # type: ignore
+ from google.cloud.bigtable.data._sync_autogen.mutations_batcher import _MB_SIZE
+
if TYPE_CHECKING:
- from google.cloud.bigtable.data._helpers import RowKeySamples, ShardedQuery
+ from google.cloud.bigtable.data._helpers import RowKeySamples
+ from google.cloud.bigtable.data._helpers import ShardedQuery
+
+ if CrossSync.is_async:
+ from google.cloud.bigtable.data._async.mutations_batcher import (
+ MutationsBatcherAsync,
+ )
+ from google.cloud.bigtable.data.execute_query._async.execute_query_iterator import (
+ ExecuteQueryIteratorAsync,
+ )
+ else:
+ from google.cloud.bigtable.data._sync_autogen.mutations_batcher import ( # noqa: F401
+ MutationsBatcher,
+ )
+ from google.cloud.bigtable.data.execute_query._sync_autogen.execute_query_iterator import ( # noqa: F401
+ ExecuteQueryIterator,
+ )
+__CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen.client"
+
+
+@CrossSync.convert_class(
+ sync_name="BigtableDataClient",
+ add_mapping_for_name="DataClient",
+)
class BigtableDataClientAsync(ClientWithProject):
+ @CrossSync.convert(
+ docstring_format_vars={
+ "LOOP_MESSAGE": (
+ "Client should be created within an async context (running event loop)",
+ None,
+ ),
+ "RAISE_NO_LOOP": (
+ "RuntimeError: if called outside of an async context (no running event loop)",
+ None,
+ ),
+ }
+ )
def __init__(
self,
*,
project: str | None = None,
- pool_size: int = 3,
credentials: google.auth.credentials.Credentials | None = None,
client_options: dict[str, Any]
| "google.api_core.client_options.ClientOptions"
| None = None,
+ **kwargs,
):
"""
Create a client instance for the Bigtable Data API
- Client should be created within an async context (running event loop)
+ {LOOP_MESSAGE}
Args:
project: the project which the client acts on behalf of.
If not passed, falls back to the default inferred
from the environment.
- pool_size: The number of grpc channels to maintain
- in the internal channel pool.
credentials:
Thehe OAuth2 Credentials to use for this
client. If not passed (and if no ``_http`` object is
@@ -130,13 +159,10 @@ def __init__(
Client options used to set user options
on the client. API Endpoint should be set through client_options.
Raises:
- RuntimeError: if called outside of an async context (no running event loop)
- ValueError: if pool_size is less than 1
+ {RAISE_NO_LOOP}
"""
- # set up transport in registry
- transport_str = f"pooled_grpc_asyncio_{pool_size}"
- transport = PooledBigtableGrpcAsyncIOTransport.with_fixed_size(pool_size)
- BigtableClientMeta._transport_registry[transport_str] = transport
+ if "pool_size" in kwargs:
+ warnings.warn("pool_size no longer supported")
# set up client info headers for veneer library
client_info = DEFAULT_CLIENT_INFO
client_info.client_library_version = self._client_version()
@@ -146,9 +172,16 @@ def __init__(
client_options = cast(
Optional[client_options_lib.ClientOptions], client_options
)
+ custom_channel = None
self._emulator_host = os.getenv(BIGTABLE_EMULATOR)
if self._emulator_host is not None:
+ warnings.warn(
+ "Connecting to Bigtable emulator at {}".format(self._emulator_host),
+ RuntimeWarning,
+ stacklevel=2,
+ )
# use insecure channel if emulator is set
+ custom_channel = insecure_channel(self._emulator_host)
if credentials is None:
credentials = google.auth.credentials.AnonymousCredentials()
if project is None:
@@ -160,38 +193,27 @@ def __init__(
project=project,
client_options=client_options,
)
- self._gapic_client = BigtableAsyncClient(
- transport=transport_str,
+ self._gapic_client = CrossSync.GapicClient(
credentials=credentials,
client_options=client_options,
client_info=client_info,
+ transport=lambda *args, **kwargs: TransportType(
+ *args, **kwargs, channel=custom_channel
+ ),
)
- self.transport = cast(
- PooledBigtableGrpcAsyncIOTransport, self._gapic_client.transport
- )
+ self._is_closed = CrossSync.Event()
+ self.transport = cast(TransportType, self._gapic_client.transport)
# keep track of active instances to for warmup on channel refresh
self._active_instances: Set[_WarmedInstanceKey] = set()
# keep track of table objects associated with each instance
# only remove instance from _active_instances when all associated tables remove it
self._instance_owners: dict[_WarmedInstanceKey, Set[int]] = {}
self._channel_init_time = time.monotonic()
- self._channel_refresh_tasks: list[asyncio.Task[None]] = []
- if self._emulator_host is not None:
- # connect to an emulator host
- warnings.warn(
- "Connecting to Bigtable emulator at {}".format(self._emulator_host),
- RuntimeWarning,
- stacklevel=2,
- )
- self.transport._grpc_channel = PooledChannel(
- pool_size=pool_size,
- host=self._emulator_host,
- insecure=True,
- )
- # refresh cached stubs to use emulator pool
- self.transport._stubs = {}
- self.transport._prep_wrapped_messages(client_info)
- else:
+ self._channel_refresh_task: CrossSync.Task[None] | None = None
+ self._executor = (
+ concurrent.futures.ThreadPoolExecutor() if not CrossSync.is_async else None
+ )
+ if self._emulator_host is None:
# attempt to start background channel refresh tasks
try:
self._start_background_channel_refresh()
@@ -208,40 +230,58 @@ def _client_version() -> str:
"""
Helper function to return the client version string for this client
"""
- return f"{google.cloud.bigtable.__version__}-data-async"
-
+ version_str = f"{google.cloud.bigtable.__version__}-data"
+ if CrossSync.is_async:
+ version_str += "-async"
+ return version_str
+
+ @CrossSync.convert(
+ docstring_format_vars={
+ "RAISE_NO_LOOP": (
+ "RuntimeError: if not called in an asyncio event loop",
+ "None",
+ )
+ }
+ )
def _start_background_channel_refresh(self) -> None:
"""
- Starts a background task to ping and warm each channel in the pool
+ Starts a background task to ping and warm grpc channel
Raises:
- RuntimeError: if not called in an asyncio event loop
+ {RAISE_NO_LOOP}
"""
- if not self._channel_refresh_tasks and not self._emulator_host:
- # raise RuntimeError if there is no event loop
- asyncio.get_running_loop()
- for channel_idx in range(self.transport.pool_size):
- refresh_task = asyncio.create_task(self._manage_channel(channel_idx))
- if sys.version_info >= (3, 8):
- # task names supported in Python 3.8+
- refresh_task.set_name(
- f"{self.__class__.__name__} channel refresh {channel_idx}"
- )
- self._channel_refresh_tasks.append(refresh_task)
+ if (
+ not self._channel_refresh_task
+ and not self._emulator_host
+ and not self._is_closed.is_set()
+ ):
+ # raise error if not in an event loop in async client
+ CrossSync.verify_async_event_loop()
+ self._channel_refresh_task = CrossSync.create_task(
+ self._manage_channel,
+ sync_executor=self._executor,
+ task_name=f"{self.__class__.__name__} channel refresh",
+ )
- async def close(self, timeout: float = 2.0):
+ @CrossSync.convert
+ async def close(self, timeout: float | None = 2.0):
"""
Cancel all background tasks
"""
- for task in self._channel_refresh_tasks:
- task.cancel()
- group = asyncio.gather(*self._channel_refresh_tasks, return_exceptions=True)
- await asyncio.wait_for(group, timeout=timeout)
+ self._is_closed.set()
+ if self._channel_refresh_task is not None:
+ self._channel_refresh_task.cancel()
+ await CrossSync.wait([self._channel_refresh_task], timeout=timeout)
await self.transport.close()
- self._channel_refresh_tasks = []
+ if self._executor:
+ self._executor.shutdown(wait=False)
+ self._channel_refresh_task = None
+ @CrossSync.convert
async def _ping_and_warm_instances(
- self, channel: grpc.aio.Channel, instance_key: _WarmedInstanceKey | None = None
+ self,
+ instance_key: _WarmedInstanceKey | None = None,
+ channel: Channel | None = None,
) -> list[BaseException | None]:
"""
Prepares the backend for requests on a channel
@@ -249,11 +289,12 @@ async def _ping_and_warm_instances(
Pings each Bigtable instance registered in `_active_instances` on the client
Args:
- channel: grpc channel to warm
instance_key: if provided, only warm the instance associated with the key
+ channel: grpc channel to warm. If none, warms `self.transport.grpc_channel`
Returns:
list[BaseException | None]: sequence of results or exceptions from the ping requests
"""
+ channel = channel or self.transport.grpc_channel
instance_list = (
[instance_key] if instance_key is not None else self._active_instances
)
@@ -262,8 +303,9 @@ async def _ping_and_warm_instances(
request_serializer=PingAndWarmRequest.serialize,
)
# prepare list of coroutines to run
- tasks = [
- ping_rpc(
+ partial_list = [
+ partial(
+ ping_rpc,
request={"name": instance_name, "app_profile_id": app_profile_id},
metadata=[
(
@@ -275,20 +317,20 @@ async def _ping_and_warm_instances(
)
for (instance_name, table_name, app_profile_id) in instance_list
]
- # execute coroutines in parallel
- result_list = await asyncio.gather(*tasks, return_exceptions=True)
- # return None in place of empty successful responses
+ result_list = await CrossSync.gather_partials(
+ partial_list, return_exceptions=True, sync_executor=self._executor
+ )
return [r or None for r in result_list]
+ @CrossSync.convert
async def _manage_channel(
self,
- channel_idx: int,
refresh_interval_min: float = 60 * 35,
refresh_interval_max: float = 60 * 45,
grace_period: float = 60 * 10,
) -> None:
"""
- Background coroutine that periodically refreshes and warms a grpc channel
+ Background task that periodically refreshes and warms a grpc channel
The backend will automatically close channels after 60 minutes, so
`refresh_interval` + `grace_period` should be < 60 minutes
@@ -296,7 +338,6 @@ async def _manage_channel(
Runs continuously until the client is closed
Args:
- channel_idx: index of the channel in the transport's channel pool
refresh_interval_min: minimum interval before initiating refresh
process in seconds. Actual interval will be a random value
between `refresh_interval_min` and `refresh_interval_max`
@@ -312,30 +353,47 @@ async def _manage_channel(
next_sleep = max(first_refresh - time.monotonic(), 0)
if next_sleep > 0:
# warm the current channel immediately
- channel = self.transport.channels[channel_idx]
- await self._ping_and_warm_instances(channel)
+ await self._ping_and_warm_instances(channel=self.transport.grpc_channel)
# continuously refresh the channel every `refresh_interval` seconds
- while True:
- await asyncio.sleep(next_sleep)
+ while not self._is_closed.is_set():
+ await CrossSync.event_wait(
+ self._is_closed,
+ next_sleep,
+ async_break_early=False, # no need to interrupt sleep. Task will be cancelled on close
+ )
+ if self._is_closed.is_set():
+ # don't refresh if client is closed
+ break
+ start_timestamp = time.monotonic()
# prepare new channel for use
- new_channel = self.transport.grpc_channel._create_channel()
- await self._ping_and_warm_instances(new_channel)
+ old_channel = self.transport.grpc_channel
+ new_channel = self.transport.create_channel()
+ await self._ping_and_warm_instances(channel=new_channel)
# cycle channel out of use, with long grace window before closure
- start_timestamp = time.time()
- await self.transport.replace_channel(
- channel_idx, grace=grace_period, swap_sleep=10, new_channel=new_channel
- )
- # subtract the time spent waiting for the channel to be replaced
+ self.transport._grpc_channel = new_channel
+ # give old_channel a chance to complete existing rpcs
+ if CrossSync.is_async:
+ await old_channel.close(grace_period)
+ else:
+ if grace_period:
+ self._is_closed.wait(grace_period) # type: ignore
+ old_channel.close() # type: ignore
+ # subtract thed time spent waiting for the channel to be replaced
next_refresh = random.uniform(refresh_interval_min, refresh_interval_max)
- next_sleep = next_refresh - (time.time() - start_timestamp)
+ next_sleep = max(next_refresh - (time.monotonic() - start_timestamp), 0)
+ @CrossSync.convert(
+ replace_symbols={
+ "TableAsync": "Table",
+ "ExecuteQueryIteratorAsync": "ExecuteQueryIterator",
+ }
+ )
async def _register_instance(
- self, instance_id: str, owner: Union[TableAsync, ExecuteQueryIteratorAsync]
+ self, instance_id: str, owner: TableAsync | ExecuteQueryIteratorAsync
) -> None:
"""
- Registers an instance with the client, and warms the channel pool
- for the instance
- The client will periodically refresh grpc channel pool used to make
+ Registers an instance with the client, and warms the channel for the instance
+ The client will periodically refresh grpc channel used to make
requests, and new channels will be warmed for each registered instance
Channels will not be refreshed unless at least one instance is registered
@@ -350,19 +408,24 @@ async def _register_instance(
instance_name, owner.table_name, owner.app_profile_id
)
self._instance_owners.setdefault(instance_key, set()).add(id(owner))
- if instance_name not in self._active_instances:
+ if instance_key not in self._active_instances:
self._active_instances.add(instance_key)
- if self._channel_refresh_tasks:
+ if self._channel_refresh_task:
# refresh tasks already running
# call ping and warm on all existing channels
- for channel in self.transport.channels:
- await self._ping_and_warm_instances(channel, instance_key)
+ await self._ping_and_warm_instances(instance_key)
else:
# refresh tasks aren't active. start them as background tasks
self._start_background_channel_refresh()
+ @CrossSync.convert(
+ replace_symbols={
+ "TableAsync": "Table",
+ "ExecuteQueryIteratorAsync": "ExecuteQueryIterator",
+ }
+ )
async def _remove_instance_registration(
- self, instance_id: str, owner: Union[TableAsync, ExecuteQueryIteratorAsync]
+ self, instance_id: str, owner: TableAsync | "ExecuteQueryIteratorAsync"
) -> bool:
"""
Removes an instance from the client's registered instances, to prevent
@@ -391,11 +454,26 @@ async def _remove_instance_registration(
except KeyError:
return False
+ @CrossSync.convert(
+ replace_symbols={"TableAsync": "Table"},
+ docstring_format_vars={
+ "LOOP_MESSAGE": (
+ "Must be created within an async context (running event loop)",
+ "",
+ ),
+ "RAISE_NO_LOOP": (
+ "RuntimeError: if called outside of an async context (no running event loop)",
+ "None",
+ ),
+ },
+ )
def get_table(self, instance_id: str, table_id: str, *args, **kwargs) -> TableAsync:
"""
Returns a table instance for making data API requests. All arguments are passed
directly to the TableAsync constructor.
+ {LOOP_MESSAGE}
+
Args:
instance_id: The Bigtable instance ID to associate with this client.
instance_id is combined with the client's project to fully
@@ -428,17 +506,20 @@ def get_table(self, instance_id: str, table_id: str, *args, **kwargs) -> TableAs
Returns:
TableAsync: a table instance for making data API requests
Raises:
- RuntimeError: if called outside of an async context (no running event loop)
+ {RAISE_NO_LOOP}
"""
return TableAsync(self, instance_id, table_id, *args, **kwargs)
+ @CrossSync.convert(
+ replace_symbols={"ExecuteQueryIteratorAsync": "ExecuteQueryIterator"}
+ )
async def execute_query(
self,
query: str,
instance_id: str,
*,
- parameters: Dict[str, ExecuteQueryValueType] | None = None,
- parameter_types: Dict[str, SqlType.Type] | None = None,
+ parameters: dict[str, ExecuteQueryValueType] | None = None,
+ parameter_types: dict[str, SqlType.Type] | None = None,
app_profile_id: str | None = None,
operation_timeout: float = 600,
attempt_timeout: float | None = 20,
@@ -508,35 +589,28 @@ async def execute_query(
"proto_format": {},
}
- # app_profile_id should be set to an empty string for ExecuteQueryRequest only
- app_profile_id_for_metadata = app_profile_id or ""
-
- req_metadata = _make_metadata(
- table_name=None,
- app_profile_id=app_profile_id_for_metadata,
- instance_name=instance_name,
- )
-
- return ExecuteQueryIteratorAsync(
+ return CrossSync.ExecuteQueryIterator(
self,
instance_id,
app_profile_id,
request_body,
attempt_timeout,
operation_timeout,
- req_metadata,
- retryable_excs,
+ retryable_excs=retryable_excs,
)
+ @CrossSync.convert(sync_name="__enter__")
async def __aenter__(self):
self._start_background_channel_refresh()
return self
+ @CrossSync.convert(sync_name="__exit__", replace_symbols={"__aexit__": "__exit__"})
async def __aexit__(self, exc_type, exc_val, exc_tb):
await self.close()
await self._gapic_client.__aexit__(exc_type, exc_val, exc_tb)
+@CrossSync.convert_class(sync_name="Table", add_mapping_for_name="Table")
class TableAsync:
"""
Main Data API surface
@@ -545,6 +619,19 @@ class TableAsync:
each call
"""
+ @CrossSync.convert(
+ replace_symbols={"BigtableDataClientAsync": "BigtableDataClient"},
+ docstring_format_vars={
+ "LOOP_MESSAGE": (
+ "Must be created within an async context (running event loop)",
+ "",
+ ),
+ "RAISE_NO_LOOP": (
+ "RuntimeError: if called outside of an async context (no running event loop)",
+ "None",
+ ),
+ },
+ )
def __init__(
self,
client: BigtableDataClientAsync,
@@ -575,7 +662,7 @@ def __init__(
"""
Initialize a Table instance
- Must be created within an async context (running event loop)
+ {LOOP_MESSAGE}
Args:
instance_id: The Bigtable instance ID to associate with this client.
@@ -607,7 +694,7 @@ def __init__(
encountered during all other operations.
Defaults to 4 (DeadlineExceeded) and 14 (ServiceUnavailable)
Raises:
- RuntimeError: if called outside of an async context (no running event loop)
+ {RAISE_NO_LOOP}
"""
# NOTE: any changes to the signature of this method should also be reflected
# in client.get_table()
@@ -653,17 +740,19 @@ def __init__(
default_mutate_rows_retryable_errors or ()
)
self.default_retryable_errors = default_retryable_errors or ()
-
- # raises RuntimeError if called outside of an async context (no running event loop)
try:
- self._register_instance_task = asyncio.create_task(
- self.client._register_instance(instance_id, self)
+ self._register_instance_future = CrossSync.create_task(
+ self.client._register_instance,
+ self.instance_id,
+ self,
+ sync_executor=self.client._executor,
)
except RuntimeError as e:
raise RuntimeError(
f"{self.__class__.__name__} must be created within an async event loop context."
) from e
+ @CrossSync.convert(replace_symbols={"AsyncIterable": "Iterable"})
async def read_rows_stream(
self,
query: ReadRowsQuery,
@@ -705,7 +794,7 @@ async def read_rows_stream(
)
retryable_excs = _get_retryable_errors(retryable_errors, self)
- row_merger = _ReadRowsOperationAsync(
+ row_merger = CrossSync._ReadRowsOperation(
query,
self,
operation_timeout=operation_timeout,
@@ -714,6 +803,7 @@ async def read_rows_stream(
)
return row_merger.start_operation()
+ @CrossSync.convert
async def read_rows(
self,
query: ReadRowsQuery,
@@ -761,6 +851,7 @@ async def read_rows(
)
return [row async for row in row_generator]
+ @CrossSync.convert
async def read_row(
self,
row_key: str | bytes,
@@ -810,6 +901,7 @@ async def read_row(
return None
return results[0]
+ @CrossSync.convert
async def read_rows_sharded(
self,
sharded_query: ShardedQuery,
@@ -860,8 +952,9 @@ async def read_rows_sharded(
)
# limit the number of concurrent requests using a semaphore
- concurrency_sem = asyncio.Semaphore(_CONCURRENCY_LIMIT)
+ concurrency_sem = CrossSync.Semaphore(_CONCURRENCY_LIMIT)
+ @CrossSync.convert
async def read_rows_with_semaphore(query):
async with concurrency_sem:
# calculate new timeout based on time left in overall operation
@@ -877,8 +970,14 @@ async def read_rows_with_semaphore(query):
retryable_errors=retryable_errors,
)
- routine_list = [read_rows_with_semaphore(query) for query in sharded_query]
- batch_result = await asyncio.gather(*routine_list, return_exceptions=True)
+ routine_list = [
+ partial(read_rows_with_semaphore, query) for query in sharded_query
+ ]
+ batch_result = await CrossSync.gather_partials(
+ routine_list,
+ return_exceptions=True,
+ sync_executor=self.client._executor,
+ )
# collect results and errors
error_dict = {}
@@ -905,6 +1004,7 @@ async def read_rows_with_semaphore(query):
)
return results_list
+ @CrossSync.convert
async def row_exists(
self,
row_key: str | bytes,
@@ -953,6 +1053,7 @@ async def row_exists(
)
return len(results) > 0
+ @CrossSync.convert
async def sample_row_keys(
self,
*,
@@ -1004,22 +1105,17 @@ async def sample_row_keys(
sleep_generator = retries.exponential_sleep_generator(0.01, 2, 60)
- # prepare request
- metadata = _make_metadata(
- self.table_name, self.app_profile_id, instance_name=None
- )
-
+ @CrossSync.convert
async def execute_rpc():
results = await self.client._gapic_client.sample_row_keys(
table_name=self.table_name,
app_profile_id=self.app_profile_id,
timeout=next(attempt_timeout_gen),
- metadata=metadata,
retry=None,
)
return [(s.row_key, s.offset_bytes) async for s in results]
- return await retries.retry_target_async(
+ return await CrossSync.retry_target(
execute_rpc,
predicate,
sleep_generator,
@@ -1027,6 +1123,7 @@ async def execute_rpc():
exception_factory=_retry_exception_factory,
)
+ @CrossSync.convert(replace_symbols={"MutationsBatcherAsync": "MutationsBatcher"})
def mutations_batcher(
self,
*,
@@ -1039,7 +1136,7 @@ def mutations_batcher(
batch_attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
batch_retryable_errors: Sequence[type[Exception]]
| TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
- ) -> MutationsBatcherAsync:
+ ) -> "MutationsBatcherAsync":
"""
Returns a new mutations batcher instance.
@@ -1064,7 +1161,7 @@ def mutations_batcher(
Returns:
MutationsBatcherAsync: a MutationsBatcherAsync context manager that can batch requests
"""
- return MutationsBatcherAsync(
+ return CrossSync.MutationsBatcher(
self,
flush_interval=flush_interval,
flush_limit_mutation_count=flush_limit_mutation_count,
@@ -1076,6 +1173,7 @@ def mutations_batcher(
batch_retryable_errors=batch_retryable_errors,
)
+ @CrossSync.convert
async def mutate_row(
self,
row_key: str | bytes,
@@ -1143,12 +1241,9 @@ async def mutate_row(
table_name=self.table_name,
app_profile_id=self.app_profile_id,
timeout=attempt_timeout,
- metadata=_make_metadata(
- self.table_name, self.app_profile_id, instance_name=None
- ),
retry=None,
)
- return await retries.retry_target_async(
+ return await CrossSync.retry_target(
target,
predicate,
sleep_generator,
@@ -1156,6 +1251,7 @@ async def mutate_row(
exception_factory=_retry_exception_factory,
)
+ @CrossSync.convert
async def bulk_mutate_rows(
self,
mutation_entries: list[RowMutationEntry],
@@ -1201,7 +1297,7 @@ async def bulk_mutate_rows(
)
retryable_excs = _get_retryable_errors(retryable_errors, self)
- operation = _MutateRowsOperationAsync(
+ operation = CrossSync._MutateRowsOperation(
self.client._gapic_client,
self,
mutation_entries,
@@ -1211,6 +1307,7 @@ async def bulk_mutate_rows(
)
await operation.start()
+ @CrossSync.convert
async def check_and_mutate_row(
self,
row_key: str | bytes,
@@ -1263,9 +1360,6 @@ async def check_and_mutate_row(
):
false_case_mutations = [false_case_mutations]
false_case_list = [m._to_pb() for m in false_case_mutations or []]
- metadata = _make_metadata(
- self.table_name, self.app_profile_id, instance_name=None
- )
result = await self.client._gapic_client.check_and_mutate_row(
true_mutations=true_case_list,
false_mutations=false_case_list,
@@ -1273,12 +1367,12 @@ async def check_and_mutate_row(
row_key=row_key.encode("utf-8") if isinstance(row_key, str) else row_key,
table_name=self.table_name,
app_profile_id=self.app_profile_id,
- metadata=metadata,
timeout=operation_timeout,
retry=None,
)
return result.predicate_matched
+ @CrossSync.convert
async def read_modify_write_row(
self,
row_key: str | bytes,
@@ -1316,28 +1410,27 @@ async def read_modify_write_row(
rules = [rules]
if not rules:
raise ValueError("rules must contain at least one item")
- metadata = _make_metadata(
- self.table_name, self.app_profile_id, instance_name=None
- )
result = await self.client._gapic_client.read_modify_write_row(
rules=[rule._to_pb() for rule in rules],
row_key=row_key.encode("utf-8") if isinstance(row_key, str) else row_key,
table_name=self.table_name,
app_profile_id=self.app_profile_id,
- metadata=metadata,
timeout=operation_timeout,
retry=None,
)
# construct Row from result
return Row._from_pb(result.row)
+ @CrossSync.convert
async def close(self):
"""
Called to close the Table instance and release any resources held by it.
"""
- self._register_instance_task.cancel()
+ if self._register_instance_future:
+ self._register_instance_future.cancel()
await self.client._remove_instance_registration(self.instance_id, self)
+ @CrossSync.convert(sync_name="__enter__")
async def __aenter__(self):
"""
Implement async context manager protocol
@@ -1345,9 +1438,11 @@ async def __aenter__(self):
Ensure registration task has time to run, so that
grpc channels will be warmed for the specified instance
"""
- await self._register_instance_task
+ if self._register_instance_future:
+ await self._register_instance_future
return self
+ @CrossSync.convert(sync_name="__exit__")
async def __aexit__(self, exc_type, exc_val, exc_tb):
"""
Implement async context manager protocol
diff --git a/google/cloud/bigtable/data/_async/mutations_batcher.py b/google/cloud/bigtable/data/_async/mutations_batcher.py
index 76d13f00b..6e15bb5f3 100644
--- a/google/cloud/bigtable/data/_async/mutations_batcher.py
+++ b/google/cloud/bigtable/data/_async/mutations_batcher.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -14,32 +14,40 @@
#
from __future__ import annotations
-from typing import Any, Sequence, TYPE_CHECKING
-import asyncio
+from typing import Sequence, TYPE_CHECKING, cast
import atexit
import warnings
from collections import deque
+import concurrent.futures
-from google.cloud.bigtable.data.mutations import RowMutationEntry
from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
from google.cloud.bigtable.data.exceptions import FailedMutationEntryError
from google.cloud.bigtable.data._helpers import _get_retryable_errors
from google.cloud.bigtable.data._helpers import _get_timeouts
from google.cloud.bigtable.data._helpers import TABLE_DEFAULT
-from google.cloud.bigtable.data._async._mutate_rows import _MutateRowsOperationAsync
-from google.cloud.bigtable.data._async._mutate_rows import (
+from google.cloud.bigtable.data.mutations import (
_MUTATE_ROWS_REQUEST_MUTATION_LIMIT,
)
from google.cloud.bigtable.data.mutations import Mutation
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
if TYPE_CHECKING:
- from google.cloud.bigtable.data._async.client import TableAsync
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ if CrossSync.is_async:
+ from google.cloud.bigtable.data._async.client import TableAsync as TableType
+ else:
+ from google.cloud.bigtable.data._sync_autogen.client import Table as TableType # type: ignore
+
+__CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen.mutations_batcher"
# used to make more readable default values
_MB_SIZE = 1024 * 1024
+@CrossSync.convert_class(sync_name="_FlowControl", add_mapping_for_name="_FlowControl")
class _FlowControlAsync:
"""
Manages flow control for batched mutations. Mutations are registered against
@@ -70,7 +78,7 @@ def __init__(
raise ValueError("max_mutation_count must be greater than 0")
if self._max_mutation_bytes < 1:
raise ValueError("max_mutation_bytes must be greater than 0")
- self._capacity_condition = asyncio.Condition()
+ self._capacity_condition = CrossSync.Condition()
self._in_flight_mutation_count = 0
self._in_flight_mutation_bytes = 0
@@ -96,6 +104,7 @@ def _has_capacity(self, additional_count: int, additional_size: int) -> bool:
new_count = self._in_flight_mutation_count + additional_count
return new_size <= acceptable_size and new_count <= acceptable_count
+ @CrossSync.convert
async def remove_from_flow(
self, mutations: RowMutationEntry | list[RowMutationEntry]
) -> None:
@@ -117,6 +126,7 @@ async def remove_from_flow(
async with self._capacity_condition:
self._capacity_condition.notify_all()
+ @CrossSync.convert
async def add_to_flow(self, mutations: RowMutationEntry | list[RowMutationEntry]):
"""
Generator function that registers mutations with flow control. As mutations
@@ -166,6 +176,7 @@ async def add_to_flow(self, mutations: RowMutationEntry | list[RowMutationEntry]
yield mutations[start_idx:end_idx]
+@CrossSync.convert_class(sync_name="MutationsBatcher")
class MutationsBatcherAsync:
"""
Allows users to send batches using context manager API:
@@ -199,7 +210,7 @@ class MutationsBatcherAsync:
def __init__(
self,
- table: "TableAsync",
+ table: TableType,
*,
flush_interval: float | None = 5,
flush_limit_mutation_count: int | None = 1000,
@@ -218,11 +229,11 @@ def __init__(
batch_retryable_errors, table
)
- self.closed: bool = False
+ self._closed = CrossSync.Event()
self._table = table
self._staged_entries: list[RowMutationEntry] = []
self._staged_count, self._staged_bytes = 0, 0
- self._flow_control = _FlowControlAsync(
+ self._flow_control = CrossSync._FlowControl(
flow_control_max_mutation_count, flow_control_max_bytes
)
self._flush_limit_bytes = flush_limit_bytes
@@ -231,8 +242,22 @@ def __init__(
if flush_limit_mutation_count is not None
else float("inf")
)
- self._flush_timer = self._start_flush_timer(flush_interval)
- self._flush_jobs: set[asyncio.Future[None]] = set()
+ # used by sync class to run mutate_rows operations
+ self._sync_rpc_executor = (
+ concurrent.futures.ThreadPoolExecutor(max_workers=8)
+ if not CrossSync.is_async
+ else None
+ )
+ # used by sync class to manage flush_internal tasks
+ self._sync_flush_executor = (
+ concurrent.futures.ThreadPoolExecutor(max_workers=4)
+ if not CrossSync.is_async
+ else None
+ )
+ self._flush_timer = CrossSync.create_task(
+ self._timer_routine, flush_interval, sync_executor=self._sync_flush_executor
+ )
+ self._flush_jobs: set[CrossSync.Future[None]] = set()
# MutationExceptionGroup reports number of successful entries along with failures
self._entries_processed_since_last_raise: int = 0
self._exceptions_since_last_raise: int = 0
@@ -245,7 +270,8 @@ def __init__(
# clean up on program exit
atexit.register(self._on_exit)
- def _start_flush_timer(self, interval: float | None) -> asyncio.Future[None]:
+ @CrossSync.convert
+ async def _timer_routine(self, interval: float | None) -> None:
"""
Set up a background task to flush the batcher every interval seconds
@@ -254,27 +280,18 @@ def _start_flush_timer(self, interval: float | None) -> asyncio.Future[None]:
Args:
flush_interval: Automatically flush every flush_interval seconds.
If None, no time-based flushing is performed.
- Returns:
- asyncio.Future[None]: future representing the background task
"""
- if interval is None or self.closed:
- empty_future: asyncio.Future[None] = asyncio.Future()
- empty_future.set_result(None)
- return empty_future
-
- async def timer_routine(self, interval: float):
- """
- Triggers new flush tasks every `interval` seconds
- """
- while not self.closed:
- await asyncio.sleep(interval)
- # add new flush task to list
- if not self.closed and self._staged_entries:
- self._schedule_flush()
-
- timer_task = asyncio.create_task(timer_routine(self, interval))
- return timer_task
+ if not interval or interval <= 0:
+ return None
+ while not self._closed.is_set():
+ # wait until interval has passed, or until closed
+ await CrossSync.event_wait(
+ self._closed, timeout=interval, async_break_early=False
+ )
+ if not self._closed.is_set() and self._staged_entries:
+ self._schedule_flush()
+ @CrossSync.convert
async def append(self, mutation_entry: RowMutationEntry):
"""
Add a new set of mutations to the internal queue
@@ -286,9 +303,9 @@ async def append(self, mutation_entry: RowMutationEntry):
ValueError: if an invalid mutation type is added
"""
# TODO: return a future to track completion of this entry
- if self.closed:
+ if self._closed.is_set():
raise RuntimeError("Cannot append to closed MutationsBatcher")
- if isinstance(mutation_entry, Mutation): # type: ignore
+ if isinstance(cast(Mutation, mutation_entry), Mutation):
raise ValueError(
f"invalid mutation type: {type(mutation_entry).__name__}. Only RowMutationEntry objects are supported by batcher"
)
@@ -302,25 +319,29 @@ async def append(self, mutation_entry: RowMutationEntry):
):
self._schedule_flush()
# yield to the event loop to allow flush to run
- await asyncio.sleep(0)
+ await CrossSync.yield_to_event_loop()
- def _schedule_flush(self) -> asyncio.Future[None] | None:
+ def _schedule_flush(self) -> CrossSync.Future[None] | None:
"""
Update the flush task to include the latest staged entries
Returns:
- asyncio.Future[None] | None:
+ Future[None] | None:
future representing the background task, if started
"""
if self._staged_entries:
entries, self._staged_entries = self._staged_entries, []
self._staged_count, self._staged_bytes = 0, 0
- new_task = self._create_bg_task(self._flush_internal, entries)
- new_task.add_done_callback(self._flush_jobs.remove)
- self._flush_jobs.add(new_task)
+ new_task = CrossSync.create_task(
+ self._flush_internal, entries, sync_executor=self._sync_flush_executor
+ )
+ if not new_task.done():
+ self._flush_jobs.add(new_task)
+ new_task.add_done_callback(self._flush_jobs.remove)
return new_task
return None
+ @CrossSync.convert
async def _flush_internal(self, new_entries: list[RowMutationEntry]):
"""
Flushes a set of mutations to the server, and updates internal state
@@ -329,9 +350,11 @@ async def _flush_internal(self, new_entries: list[RowMutationEntry]):
new_entries list of RowMutationEntry objects to flush
"""
# flush new entries
- in_process_requests: list[asyncio.Future[list[FailedMutationEntryError]]] = []
+ in_process_requests: list[CrossSync.Future[list[FailedMutationEntryError]]] = []
async for batch in self._flow_control.add_to_flow(new_entries):
- batch_task = self._create_bg_task(self._execute_mutate_rows, batch)
+ batch_task = CrossSync.create_task(
+ self._execute_mutate_rows, batch, sync_executor=self._sync_rpc_executor
+ )
in_process_requests.append(batch_task)
# wait for all inflight requests to complete
found_exceptions = await self._wait_for_batch_results(*in_process_requests)
@@ -339,6 +362,7 @@ async def _flush_internal(self, new_entries: list[RowMutationEntry]):
self._entries_processed_since_last_raise += len(new_entries)
self._add_exceptions(found_exceptions)
+ @CrossSync.convert
async def _execute_mutate_rows(
self, batch: list[RowMutationEntry]
) -> list[FailedMutationEntryError]:
@@ -355,7 +379,7 @@ async def _execute_mutate_rows(
FailedMutationEntryError objects will not contain index information
"""
try:
- operation = _MutateRowsOperationAsync(
+ operation = CrossSync._MutateRowsOperation(
self._table.client._gapic_client,
self._table,
batch,
@@ -419,10 +443,12 @@ def _raise_exceptions(self):
entry_count=entry_count,
)
+ @CrossSync.convert(sync_name="__enter__")
async def __aenter__(self):
"""Allow use of context manager API"""
return self
+ @CrossSync.convert(sync_name="__exit__")
async def __aexit__(self, exc_type, exc, tb):
"""
Allow use of context manager API.
@@ -431,19 +457,30 @@ async def __aexit__(self, exc_type, exc, tb):
"""
await self.close()
+ @property
+ def closed(self) -> bool:
+ """
+ Returns:
+ - True if the batcher is closed, False otherwise
+ """
+ return self._closed.is_set()
+
+ @CrossSync.convert
async def close(self):
"""
Flush queue and clean up resources
"""
- self.closed = True
+ self._closed.set()
self._flush_timer.cancel()
self._schedule_flush()
- if self._flush_jobs:
- await asyncio.gather(*self._flush_jobs, return_exceptions=True)
- try:
- await self._flush_timer
- except asyncio.CancelledError:
- pass
+ # shut down executors
+ if self._sync_flush_executor:
+ with self._sync_flush_executor:
+ self._sync_flush_executor.shutdown(wait=True)
+ if self._sync_rpc_executor:
+ with self._sync_rpc_executor:
+ self._sync_rpc_executor.shutdown(wait=True)
+ await CrossSync.wait([*self._flush_jobs, self._flush_timer])
atexit.unregister(self._on_exit)
# raise unreported exceptions
self._raise_exceptions()
@@ -452,32 +489,17 @@ def _on_exit(self):
"""
Called when program is exited. Raises warning if unflushed mutations remain
"""
- if not self.closed and self._staged_entries:
+ if not self._closed.is_set() and self._staged_entries:
warnings.warn(
f"MutationsBatcher for table {self._table.table_name} was not closed. "
f"{len(self._staged_entries)} Unflushed mutations will not be sent to the server."
)
@staticmethod
- def _create_bg_task(func, *args, **kwargs) -> asyncio.Future[Any]:
- """
- Create a new background task, and return a future
-
- This method wraps asyncio to make it easier to maintain subclasses
- with different concurrency models.
-
- Args:
- func: function to execute in background task
- *args: positional arguments to pass to func
- **kwargs: keyword arguments to pass to func
- Returns:
- asyncio.Future: Future object representing the background task
- """
- return asyncio.create_task(func(*args, **kwargs))
-
- @staticmethod
+ @CrossSync.convert
async def _wait_for_batch_results(
- *tasks: asyncio.Future[list[FailedMutationEntryError]] | asyncio.Future[None],
+ *tasks: CrossSync.Future[list[FailedMutationEntryError]]
+ | CrossSync.Future[None],
) -> list[Exception]:
"""
Takes in a list of futures representing _execute_mutate_rows tasks,
@@ -494,19 +516,19 @@ async def _wait_for_batch_results(
"""
if not tasks:
return []
- all_results = await asyncio.gather(*tasks, return_exceptions=True)
- found_errors = []
- for result in all_results:
- if isinstance(result, Exception):
- # will receive direct Exception objects if request task fails
- found_errors.append(result)
- elif isinstance(result, BaseException):
- # BaseException not expected from grpc calls. Raise immediately
- raise result
- elif result:
- # completed requests will return a list of FailedMutationEntryError
- for e in result:
- # strip index information
- e.index = None
- found_errors.extend(result)
- return found_errors
+ exceptions: list[Exception] = []
+ for task in tasks:
+ if CrossSync.is_async:
+ # futures don't need to be awaited in sync mode
+ await task
+ try:
+ exc_list = task.result()
+ if exc_list:
+ # expect a list of FailedMutationEntryError objects
+ for exc in exc_list:
+ # strip index information
+ exc.index = None
+ exceptions.extend(exc_list)
+ except Exception as e:
+ exceptions.append(e)
+ return exceptions
diff --git a/google/cloud/bigtable/data/_cross_sync/__init__.py b/google/cloud/bigtable/data/_cross_sync/__init__.py
new file mode 100644
index 000000000..77a9ddae9
--- /dev/null
+++ b/google/cloud/bigtable/data/_cross_sync/__init__.py
@@ -0,0 +1,20 @@
+# Copyright 2024 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.
+
+from .cross_sync import CrossSync
+
+
+__all__ = [
+ "CrossSync",
+]
diff --git a/google/cloud/bigtable/data/_cross_sync/_decorators.py b/google/cloud/bigtable/data/_cross_sync/_decorators.py
new file mode 100644
index 000000000..f37b05b64
--- /dev/null
+++ b/google/cloud/bigtable/data/_cross_sync/_decorators.py
@@ -0,0 +1,441 @@
+# Copyright 2024 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.
+"""
+Contains a set of AstDecorator classes, which define the behavior of CrossSync decorators.
+Each AstDecorator class is used through @CrossSync.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Iterable
+
+if TYPE_CHECKING:
+ import ast
+ from typing import Callable, Any
+
+
+class AstDecorator:
+ """
+ Helper class for CrossSync decorators used for guiding ast transformations.
+
+ AstDecorators are accessed in two ways:
+ 1. The decorations are used directly as method decorations in the async client,
+ wrapping existing classes and methods
+ 2. The decorations are read back when processing the AST transformations when
+ generating sync code.
+
+ This class allows the same decorator to be used in both contexts.
+
+ Typically, AstDecorators act as a no-op in async code, and the arguments simply
+ provide configuration guidance for the sync code generation.
+ """
+
+ @classmethod
+ def decorator(cls, *args, **kwargs) -> Callable[..., Any]:
+ """
+ Provides a callable that can be used as a decorator function in async code
+
+ AstDecorator.decorate is called by CrossSync when attaching decorators to
+ the CrossSync class.
+
+ This method creates a new instance of the class, using the arguments provided
+ to the decorator, and defers to the async_decorator method of the instance
+ to build the wrapper function.
+
+ Arguments:
+ *args: arguments to the decorator
+ **kwargs: keyword arguments to the decorator
+ """
+ # decorators with no arguments will provide the function to be wrapped
+ # as the first argument. Pull it out if it exists
+ func = None
+ if len(args) == 1 and callable(args[0]):
+ func = args[0]
+ args = args[1:]
+ # create new AstDecorator instance from given decorator arguments
+ new_instance = cls(*args, **kwargs)
+ # build wrapper
+ wrapper = new_instance.async_decorator()
+ if wrapper is None:
+ # if no wrapper, return no-op decorator
+ return func or (lambda f: f)
+ elif func:
+ # if we can, return single wrapped function
+ return wrapper(func)
+ else:
+ # otherwise, return decorator function
+ return wrapper
+
+ def async_decorator(self) -> Callable[..., Any] | None:
+ """
+ Decorator to apply the async_impl decorator to the wrapped function
+
+ Default implementation is a no-op
+ """
+ return None
+
+ def sync_ast_transform(
+ self, wrapped_node: ast.AST, transformers_globals: dict[str, Any]
+ ) -> ast.AST | None:
+ """
+ When this decorator is encountered in the ast during sync generation, this method is called
+ to transform the wrapped node.
+
+ If None is returned, the node will be dropped from the output file.
+
+ Args:
+ wrapped_node: ast node representing the wrapped function or class that is being wrapped
+ transformers_globals: the set of globals() from the transformers module. This is used to access
+ ast transformer classes that live outside the main codebase
+ Returns:
+ transformed ast node, or None if the node should be dropped
+ """
+ return wrapped_node
+
+ @classmethod
+ def get_for_node(cls, node: ast.Call | ast.Attribute | ast.Name) -> "AstDecorator":
+ """
+ Build an AstDecorator instance from an ast decorator node
+
+ The right subclass is found by comparing the string representation of the
+ decorator name to the class name. (Both names are converted to lowercase and
+ underscores are removed for comparison). If a matching subclass is found,
+ a new instance is created with the provided arguments.
+
+ Args:
+ node: ast.Call node representing the decorator
+ Returns:
+ AstDecorator instance corresponding to the decorator
+ Raises:
+ ValueError: if the decorator cannot be parsed
+ """
+ import ast
+
+ # expect decorators in format @CrossSync.
+ # (i.e. should be an ast.Call or an ast.Attribute)
+ root_attr = node.func if isinstance(node, ast.Call) else node
+ if not isinstance(root_attr, ast.Attribute):
+ raise ValueError("Unexpected decorator format")
+ # extract the module and decorator names
+ if "CrossSync" in ast.dump(root_attr):
+ decorator_name = root_attr.attr
+ got_kwargs = (
+ {kw.arg: cls._convert_ast_to_py(kw.value) for kw in node.keywords}
+ if hasattr(node, "keywords")
+ else {}
+ )
+ got_args = (
+ [cls._convert_ast_to_py(arg) for arg in node.args]
+ if hasattr(node, "args")
+ else []
+ )
+ # convert to standardized representation
+ formatted_name = decorator_name.replace("_", "").lower()
+ for subclass in cls.get_subclasses():
+ if subclass.__name__.lower() == formatted_name:
+ return subclass(*got_args, **got_kwargs)
+ raise ValueError(f"Unknown decorator encountered: {decorator_name}")
+ else:
+ raise ValueError("Not a CrossSync decorator")
+
+ @classmethod
+ def get_subclasses(cls) -> Iterable[type["AstDecorator"]]:
+ """
+ Get all subclasses of AstDecorator
+
+ Returns:
+ list of all subclasses of AstDecorator
+ """
+ for subclass in cls.__subclasses__():
+ yield from subclass.get_subclasses()
+ yield subclass
+
+ @classmethod
+ def _convert_ast_to_py(cls, ast_node: ast.expr | None) -> Any:
+ """
+ Helper to convert ast primitives to python primitives. Used when unwrapping arguments
+ """
+ import ast
+
+ if ast_node is None:
+ return None
+ if isinstance(ast_node, ast.Constant):
+ return ast_node.value
+ if isinstance(ast_node, ast.List):
+ return [cls._convert_ast_to_py(node) for node in ast_node.elts]
+ if isinstance(ast_node, ast.Tuple):
+ return tuple(cls._convert_ast_to_py(node) for node in ast_node.elts)
+ if isinstance(ast_node, ast.Dict):
+ return {
+ cls._convert_ast_to_py(k): cls._convert_ast_to_py(v)
+ for k, v in zip(ast_node.keys, ast_node.values)
+ }
+ raise ValueError(f"Unsupported type {type(ast_node)}")
+
+
+class ConvertClass(AstDecorator):
+ """
+ Class decorator for guiding generation of sync classes
+
+ Args:
+ sync_name: use a new name for the sync class
+ replace_symbols: a dict of symbols and replacements to use when generating sync class
+ docstring_format_vars: a dict of variables to replace in the docstring
+ rm_aio: if True, automatically strip all asyncio keywords from method. If false,
+ only keywords wrapped in CrossSync.rm_aio() calls to be removed.
+ add_mapping_for_name: when given, will add a new attribute to CrossSync,
+ so the original class and its sync version can be accessed from CrossSync.
+ """
+
+ def __init__(
+ self,
+ sync_name: str | None = None,
+ *,
+ replace_symbols: dict[str, str] | None = None,
+ docstring_format_vars: dict[str, tuple[str | None, str | None]] | None = None,
+ rm_aio: bool = False,
+ add_mapping_for_name: str | None = None,
+ ):
+ self.sync_name = sync_name
+ self.replace_symbols = replace_symbols
+ docstring_format_vars = docstring_format_vars or {}
+ self.async_docstring_format_vars = {
+ k: v[0] or "" for k, v in docstring_format_vars.items()
+ }
+ self.sync_docstring_format_vars = {
+ k: v[1] or "" for k, v in docstring_format_vars.items()
+ }
+ self.rm_aio = rm_aio
+ self.add_mapping_for_name = add_mapping_for_name
+
+ def async_decorator(self):
+ """
+ Use async decorator as a hook to update CrossSync mappings
+ """
+ from .cross_sync import CrossSync
+
+ if not self.add_mapping_for_name and not self.async_docstring_format_vars:
+ # return None if no changes needed
+ return None
+
+ new_mapping = self.add_mapping_for_name
+
+ def decorator(cls):
+ if new_mapping:
+ CrossSync.add_mapping(new_mapping, cls)
+ if self.async_docstring_format_vars:
+ cls.__doc__ = cls.__doc__.format(**self.async_docstring_format_vars)
+ return cls
+
+ return decorator
+
+ def sync_ast_transform(self, wrapped_node, transformers_globals):
+ """
+ Transform async class into sync copy
+ """
+ import ast
+ import copy
+
+ # copy wrapped node
+ wrapped_node = copy.deepcopy(wrapped_node)
+ # update name
+ if self.sync_name:
+ wrapped_node.name = self.sync_name
+ # strip CrossSync decorators
+ if hasattr(wrapped_node, "decorator_list"):
+ wrapped_node.decorator_list = [
+ d for d in wrapped_node.decorator_list if "CrossSync" not in ast.dump(d)
+ ]
+ else:
+ wrapped_node.decorator_list = []
+ # strip async keywords if specified
+ if self.rm_aio:
+ wrapped_node = transformers_globals["AsyncToSync"]().visit(wrapped_node)
+ # add mapping decorator if needed
+ if self.add_mapping_for_name:
+ wrapped_node.decorator_list.append(
+ ast.Call(
+ func=ast.Attribute(
+ value=ast.Name(id="CrossSync", ctx=ast.Load()),
+ attr="add_mapping_decorator",
+ ctx=ast.Load(),
+ ),
+ args=[
+ ast.Constant(value=self.add_mapping_for_name),
+ ],
+ keywords=[],
+ )
+ )
+ # replace symbols if specified
+ if self.replace_symbols:
+ wrapped_node = transformers_globals["SymbolReplacer"](
+ self.replace_symbols
+ ).visit(wrapped_node)
+ # update docstring if specified
+ if self.sync_docstring_format_vars:
+ docstring = ast.get_docstring(wrapped_node)
+ if docstring:
+ wrapped_node.body[0].value = ast.Constant(
+ value=docstring.format(**self.sync_docstring_format_vars)
+ )
+ return wrapped_node
+
+
+class Convert(ConvertClass):
+ """
+ Method decorator to mark async methods to be converted to sync methods
+
+ Args:
+ sync_name: use a new name for the sync method
+ replace_symbols: a dict of symbols and replacements to use when generating sync method
+ docstring_format_vars: a dict of variables to replace in the docstring
+ rm_aio: if True, automatically strip all asyncio keywords from method. If False,
+ only the signature `async def` is stripped. Other keywords must be wrapped in
+ CrossSync.rm_aio() calls to be removed.
+ """
+
+ def __init__(
+ self,
+ sync_name: str | None = None,
+ *,
+ replace_symbols: dict[str, str] | None = None,
+ docstring_format_vars: dict[str, tuple[str | None, str | None]] | None = None,
+ rm_aio: bool = True,
+ ):
+ super().__init__(
+ sync_name=sync_name,
+ replace_symbols=replace_symbols,
+ docstring_format_vars=docstring_format_vars,
+ rm_aio=rm_aio,
+ add_mapping_for_name=None,
+ )
+
+ def sync_ast_transform(self, wrapped_node, transformers_globals):
+ """
+ Transform async method into sync
+ """
+ import ast
+
+ # replace async function with sync function
+ converted = ast.copy_location(
+ ast.FunctionDef(
+ wrapped_node.name,
+ wrapped_node.args,
+ wrapped_node.body,
+ wrapped_node.decorator_list
+ if hasattr(wrapped_node, "decorator_list")
+ else [],
+ wrapped_node.returns if hasattr(wrapped_node, "returns") else None,
+ ),
+ wrapped_node,
+ )
+ # transform based on arguments
+ return super().sync_ast_transform(converted, transformers_globals)
+
+
+class Drop(AstDecorator):
+ """
+ Method decorator to drop methods or classes from the sync output
+ """
+
+ def sync_ast_transform(self, wrapped_node, transformers_globals):
+ """
+ Drop from sync output
+ """
+ return None
+
+
+class Pytest(AstDecorator):
+ """
+ Used in place of pytest.mark.asyncio to mark tests
+
+ When generating sync version, also runs rm_aio to remove async keywords from
+ entire test function
+
+ Args:
+ rm_aio: if True, automatically strip all asyncio keywords from test code.
+ Defaults to True, to simplify test code generation.
+ """
+
+ def __init__(self, rm_aio=True):
+ self.rm_aio = rm_aio
+
+ def async_decorator(self):
+ import pytest
+
+ return pytest.mark.asyncio
+
+ def sync_ast_transform(self, wrapped_node, transformers_globals):
+ """
+ convert async to sync
+ """
+ import ast
+
+ # always convert method to sync
+ converted = ast.copy_location(
+ ast.FunctionDef(
+ wrapped_node.name,
+ wrapped_node.args,
+ wrapped_node.body,
+ wrapped_node.decorator_list
+ if hasattr(wrapped_node, "decorator_list")
+ else [],
+ wrapped_node.returns if hasattr(wrapped_node, "returns") else None,
+ ),
+ wrapped_node,
+ )
+ # convert entire body to sync if rm_aio is set
+ if self.rm_aio:
+ converted = transformers_globals["AsyncToSync"]().visit(converted)
+ return converted
+
+
+class PytestFixture(AstDecorator):
+ """
+ Used in place of pytest.fixture or pytest.mark.asyncio to mark fixtures
+
+ Args:
+ *args: all arguments to pass to pytest.fixture
+ **kwargs: all keyword arguments to pass to pytest.fixture
+ """
+
+ def __init__(self, *args, **kwargs):
+ self._args = args
+ self._kwargs = kwargs
+
+ def async_decorator(self):
+ import pytest_asyncio # type: ignore
+
+ return lambda f: pytest_asyncio.fixture(*self._args, **self._kwargs)(f)
+
+ def sync_ast_transform(self, wrapped_node, transformers_globals):
+ import ast
+ import copy
+
+ new_node = copy.deepcopy(wrapped_node)
+ if not hasattr(new_node, "decorator_list"):
+ new_node.decorator_list = []
+ new_node.decorator_list.append(
+ ast.Call(
+ func=ast.Attribute(
+ value=ast.Name(id="pytest", ctx=ast.Load()),
+ attr="fixture",
+ ctx=ast.Load(),
+ ),
+ args=[ast.Constant(value=a) for a in self._args],
+ keywords=[
+ ast.keyword(arg=k, value=ast.Constant(value=v))
+ for k, v in self._kwargs.items()
+ ],
+ )
+ )
+ return new_node
diff --git a/google/cloud/bigtable/data/_cross_sync/_mapping_meta.py b/google/cloud/bigtable/data/_cross_sync/_mapping_meta.py
new file mode 100644
index 000000000..5312708cc
--- /dev/null
+++ b/google/cloud/bigtable/data/_cross_sync/_mapping_meta.py
@@ -0,0 +1,64 @@
+# Copyright 2024 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.
+from __future__ import annotations
+from typing import Any
+
+
+class MappingMeta(type):
+ """
+ Metaclass to provide add_mapping functionality, allowing users to add
+ custom attributes to derived classes at runtime.
+
+ Using a metaclass allows us to share functionality between CrossSync
+ and CrossSync._Sync_Impl, and it works better with mypy checks than
+ monkypatching
+ """
+
+ # list of attributes that can be added to the derived class at runtime
+ _runtime_replacements: dict[tuple[MappingMeta, str], Any] = {}
+
+ def add_mapping(cls: MappingMeta, name: str, value: Any):
+ """
+ Add a new attribute to the class, for replacing library-level symbols
+
+ Raises:
+ - AttributeError if the attribute already exists with a different value
+ """
+ key = (cls, name)
+ old_value = cls._runtime_replacements.get(key)
+ if old_value is None:
+ cls._runtime_replacements[key] = value
+ elif old_value != value:
+ raise AttributeError(f"Conflicting assignments for CrossSync.{name}")
+
+ def add_mapping_decorator(cls: MappingMeta, name: str):
+ """
+ Exposes add_mapping as a class decorator
+ """
+
+ def decorator(wrapped_cls):
+ cls.add_mapping(name, wrapped_cls)
+ return wrapped_cls
+
+ return decorator
+
+ def __getattr__(cls: MappingMeta, name: str):
+ """
+ Retrieve custom attributes
+ """
+ key = (cls, name)
+ found = cls._runtime_replacements.get(key)
+ if found is not None:
+ return found
+ raise AttributeError(f"CrossSync has no attribute {name}")
diff --git a/google/cloud/bigtable/data/_cross_sync/cross_sync.py b/google/cloud/bigtable/data/_cross_sync/cross_sync.py
new file mode 100644
index 000000000..1f1ee111a
--- /dev/null
+++ b/google/cloud/bigtable/data/_cross_sync/cross_sync.py
@@ -0,0 +1,334 @@
+# Copyright 2024 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.
+#
+"""
+CrossSync provides a toolset for sharing logic between async and sync codebases, including:
+- A set of decorators for annotating async classes and functions
+ (@CrossSync.export_sync, @CrossSync.convert, @CrossSync.drop_method, ...)
+- A set of wrappers to wrap common objects and types that have corresponding async and sync implementations
+ (CrossSync.Queue, CrossSync.Condition, CrossSync.Future, ...)
+- A set of function implementations for common async operations that can be used in both async and sync codebases
+ (CrossSync.gather_partials, CrossSync.wait, CrossSync.condition_wait, ...)
+- CrossSync.rm_aio(), which is used to annotate regions of the code containing async keywords to strip
+
+A separate module will use CrossSync annotations to generate a corresponding sync
+class based on a decorated async class.
+
+Usage Example:
+```python
+@CrossSync.export_sync(path="path/to/sync_module.py")
+
+ @CrossSync.convert
+ async def async_func(self, arg: int) -> int:
+ await CrossSync.sleep(1)
+ return arg
+```
+"""
+
+from __future__ import annotations
+
+from typing import (
+ TypeVar,
+ Any,
+ Callable,
+ Coroutine,
+ Sequence,
+ Union,
+ AsyncIterable,
+ AsyncIterator,
+ AsyncGenerator,
+ TYPE_CHECKING,
+)
+import typing
+
+import asyncio
+import sys
+import concurrent.futures
+import google.api_core.retry as retries
+import queue
+import threading
+import time
+from ._decorators import (
+ ConvertClass,
+ Convert,
+ Drop,
+ Pytest,
+ PytestFixture,
+)
+from ._mapping_meta import MappingMeta
+
+if TYPE_CHECKING:
+ from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+
+
+class CrossSync(metaclass=MappingMeta):
+ # support CrossSync.is_async to check if the current environment is async
+ is_async = True
+
+ # provide aliases for common async functions and types
+ sleep = asyncio.sleep
+ retry_target = retries.retry_target_async
+ retry_target_stream = retries.retry_target_stream_async
+ Retry = retries.AsyncRetry
+ Queue: TypeAlias = asyncio.Queue
+ Condition: TypeAlias = asyncio.Condition
+ Future: TypeAlias = asyncio.Future
+ Task: TypeAlias = asyncio.Task
+ Event: TypeAlias = asyncio.Event
+ Semaphore: TypeAlias = asyncio.Semaphore
+ StopIteration: TypeAlias = StopAsyncIteration
+ # provide aliases for common async type annotations
+ Awaitable: TypeAlias = typing.Awaitable
+ Iterable: TypeAlias = AsyncIterable
+ Iterator: TypeAlias = AsyncIterator
+ Generator: TypeAlias = AsyncGenerator
+
+ # decorators
+ convert_class = ConvertClass.decorator # decorate classes to convert
+ convert = Convert.decorator # decorate methods to convert from async to sync
+ drop = Drop.decorator # decorate methods to remove from sync version
+ pytest = Pytest.decorator # decorate test methods to run with pytest-asyncio
+ pytest_fixture = (
+ PytestFixture.decorator
+ ) # decorate test methods to run with pytest fixture
+
+ @classmethod
+ def next(cls, iterable):
+ return iterable.__anext__()
+
+ @classmethod
+ def Mock(cls, *args, **kwargs):
+ """
+ Alias for AsyncMock, importing at runtime to avoid hard dependency on mock
+ """
+ try:
+ from unittest.mock import AsyncMock # type: ignore
+ except ImportError: # pragma: NO COVER
+ from mock import AsyncMock # type: ignore
+ return AsyncMock(*args, **kwargs)
+
+ @staticmethod
+ async def gather_partials(
+ partial_list: Sequence[Callable[[], Awaitable[T]]],
+ return_exceptions: bool = False,
+ sync_executor: concurrent.futures.ThreadPoolExecutor | None = None,
+ ) -> list[T | BaseException]:
+ """
+ abstraction over asyncio.gather, but with a set of partial functions instead
+ of coroutines, to work with sync functions.
+ To use gather with a set of futures instead of partials, use CrpssSync.wait
+
+ In the async version, the partials are expected to return an awaitable object. Patials
+ are unpacked and awaited in the gather call.
+
+ Sync version implemented with threadpool executor
+
+ Returns:
+ - a list of results (or exceptions, if return_exceptions=True) in the same order as partial_list
+ """
+ if not partial_list:
+ return []
+ awaitable_list = [partial() for partial in partial_list]
+ return await asyncio.gather(
+ *awaitable_list, return_exceptions=return_exceptions
+ )
+
+ @staticmethod
+ async def wait(
+ futures: Sequence[CrossSync.Future[T]], timeout: float | None = None
+ ) -> tuple[set[CrossSync.Future[T]], set[CrossSync.Future[T]]]:
+ """
+ abstraction over asyncio.wait
+
+ Return:
+ - a tuple of (done, pending) sets of futures
+ """
+ if not futures:
+ return set(), set()
+ return await asyncio.wait(futures, timeout=timeout)
+
+ @staticmethod
+ async def event_wait(
+ event: CrossSync.Event,
+ timeout: float | None = None,
+ async_break_early: bool = True,
+ ) -> None:
+ """
+ abstraction over asyncio.Event.wait
+
+ Args:
+ - event: event to wait for
+ - timeout: if set, will break out early after `timeout` seconds
+ - async_break_early: if False, the async version will wait for
+ the full timeout even if the event is set before the timeout.
+ This avoids creating a new background task
+ """
+ if timeout is None:
+ await event.wait()
+ elif not async_break_early:
+ if not event.is_set():
+ await asyncio.sleep(timeout)
+ else:
+ try:
+ await asyncio.wait_for(event.wait(), timeout=timeout)
+ except asyncio.TimeoutError:
+ pass
+
+ @staticmethod
+ def create_task(
+ fn: Callable[..., Coroutine[Any, Any, T]],
+ *fn_args,
+ sync_executor: concurrent.futures.ThreadPoolExecutor | None = None,
+ task_name: str | None = None,
+ **fn_kwargs,
+ ) -> CrossSync.Task[T]:
+ """
+ abstraction over asyncio.create_task. Sync version implemented with threadpool executor
+
+ sync_executor: ThreadPoolExecutor to use for sync operations. Ignored in async version
+ """
+ task: CrossSync.Task[T] = asyncio.create_task(fn(*fn_args, **fn_kwargs))
+ if task_name and sys.version_info >= (3, 8):
+ task.set_name(task_name)
+ return task
+
+ @staticmethod
+ async def yield_to_event_loop() -> None:
+ """
+ Call asyncio.sleep(0) to yield to allow other tasks to run
+ """
+ await asyncio.sleep(0)
+
+ @staticmethod
+ def verify_async_event_loop() -> None:
+ """
+ Raises RuntimeError if the event loop is not running
+ """
+ asyncio.get_running_loop()
+
+ @staticmethod
+ def rm_aio(statement: T) -> T:
+ """
+ Used to annotate regions of the code containing async keywords to strip
+
+ All async keywords inside an rm_aio call are removed, along with
+ `async with` and `async for` statements containing CrossSync.rm_aio() in the body
+ """
+ return statement
+
+ class _Sync_Impl(metaclass=MappingMeta):
+ """
+ Provide sync versions of the async functions and types in CrossSync
+ """
+
+ is_async = False
+
+ sleep = time.sleep
+ next = next
+ retry_target = retries.retry_target
+ retry_target_stream = retries.retry_target_stream
+ Retry = retries.Retry
+ Queue: TypeAlias = queue.Queue
+ Condition: TypeAlias = threading.Condition
+ Future: TypeAlias = concurrent.futures.Future
+ Task: TypeAlias = concurrent.futures.Future
+ Event: TypeAlias = threading.Event
+ Semaphore: TypeAlias = threading.Semaphore
+ StopIteration: TypeAlias = StopIteration
+ # type annotations
+ Awaitable: TypeAlias = Union[T]
+ Iterable: TypeAlias = typing.Iterable
+ Iterator: TypeAlias = typing.Iterator
+ Generator: TypeAlias = typing.Generator
+
+ @classmethod
+ def Mock(cls, *args, **kwargs):
+ from unittest.mock import Mock
+
+ return Mock(*args, **kwargs)
+
+ @staticmethod
+ def event_wait(
+ event: CrossSync._Sync_Impl.Event,
+ timeout: float | None = None,
+ async_break_early: bool = True,
+ ) -> None:
+ event.wait(timeout=timeout)
+
+ @staticmethod
+ def gather_partials(
+ partial_list: Sequence[Callable[[], T]],
+ return_exceptions: bool = False,
+ sync_executor: concurrent.futures.ThreadPoolExecutor | None = None,
+ ) -> list[T | BaseException]:
+ if not partial_list:
+ return []
+ if not sync_executor:
+ raise ValueError("sync_executor is required for sync version")
+ futures_list = [sync_executor.submit(partial) for partial in partial_list]
+ results_list: list[T | BaseException] = []
+ for future in futures_list:
+ found_exc = future.exception()
+ if found_exc is not None:
+ if return_exceptions:
+ results_list.append(found_exc)
+ else:
+ raise found_exc
+ else:
+ results_list.append(future.result())
+ return results_list
+
+ @staticmethod
+ def wait(
+ futures: Sequence[CrossSync._Sync_Impl.Future[T]],
+ timeout: float | None = None,
+ ) -> tuple[
+ set[CrossSync._Sync_Impl.Future[T]], set[CrossSync._Sync_Impl.Future[T]]
+ ]:
+ if not futures:
+ return set(), set()
+ return concurrent.futures.wait(futures, timeout=timeout)
+
+ @staticmethod
+ def create_task(
+ fn: Callable[..., T],
+ *fn_args,
+ sync_executor: concurrent.futures.ThreadPoolExecutor | None = None,
+ task_name: str | None = None,
+ **fn_kwargs,
+ ) -> CrossSync._Sync_Impl.Task[T]:
+ """
+ abstraction over asyncio.create_task. Sync version implemented with threadpool executor
+
+ sync_executor: ThreadPoolExecutor to use for sync operations. Ignored in async version
+ """
+ if not sync_executor:
+ raise ValueError("sync_executor is required for sync version")
+ return sync_executor.submit(fn, *fn_args, **fn_kwargs)
+
+ @staticmethod
+ def yield_to_event_loop() -> None:
+ """
+ No-op for sync version
+ """
+ pass
+
+ @staticmethod
+ def verify_async_event_loop() -> None:
+ """
+ No-op for sync version
+ """
+ pass
diff --git a/google/cloud/bigtable/data/_helpers.py b/google/cloud/bigtable/data/_helpers.py
index 2d36c521f..4c45e5c1c 100644
--- a/google/cloud/bigtable/data/_helpers.py
+++ b/google/cloud/bigtable/data/_helpers.py
@@ -29,6 +29,7 @@
if TYPE_CHECKING:
import grpc
from google.cloud.bigtable.data import TableAsync
+ from google.cloud.bigtable.data import Table
"""
Helper functions used in various places in the library.
@@ -59,31 +60,6 @@ class TABLE_DEFAULT(enum.Enum):
MUTATE_ROWS = "MUTATE_ROWS_DEFAULT"
-def _make_metadata(
- table_name: str | None, app_profile_id: str | None, instance_name: str | None
-) -> list[tuple[str, str]]:
- """
- Create properly formatted gRPC metadata for requests.
- """
- params = []
-
- if table_name is not None and instance_name is not None:
- raise ValueError("metadata can't contain both instance_name and table_name")
-
- if table_name is not None:
- params.append(f"table_name={table_name}")
- if instance_name is not None:
- params.append(f"name={instance_name}")
- if app_profile_id is not None:
- params.append(f"app_profile_id={app_profile_id}")
- if len(params) == 0:
- raise ValueError(
- "At least one of table_name and app_profile_id should be not None."
- )
- params_str = "&".join(params)
- return [("x-goog-request-params", params_str)]
-
-
def _attempt_timeout_generator(
per_request_timeout: float | None, operation_timeout: float
):
@@ -145,7 +121,7 @@ def _retry_exception_factory(
def _get_timeouts(
operation: float | TABLE_DEFAULT,
attempt: float | None | TABLE_DEFAULT,
- table: "TableAsync",
+ table: "TableAsync" | "Table",
) -> tuple[float, float]:
"""
Convert passed in timeout values to floats, using table defaults if necessary.
@@ -232,7 +208,7 @@ def _get_error_type(
def _get_retryable_errors(
call_codes: Sequence["grpc.StatusCode" | int | type[Exception]] | TABLE_DEFAULT,
- table: "TableAsync",
+ table: "TableAsync" | "Table",
) -> list[type[Exception]]:
"""
Convert passed in retryable error codes to a list of exception types.
diff --git a/google/cloud/bigtable/data/_sync_autogen/_mutate_rows.py b/google/cloud/bigtable/data/_sync_autogen/_mutate_rows.py
new file mode 100644
index 000000000..8e8c5ca89
--- /dev/null
+++ b/google/cloud/bigtable/data/_sync_autogen/_mutate_rows.py
@@ -0,0 +1,182 @@
+# Copyright 2024 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.
+#
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+from typing import Sequence, TYPE_CHECKING
+import functools
+from google.api_core import exceptions as core_exceptions
+from google.api_core import retry as retries
+import google.cloud.bigtable.data.exceptions as bt_exceptions
+from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
+from google.cloud.bigtable.data._helpers import _retry_exception_factory
+from google.cloud.bigtable.data.mutations import _MUTATE_ROWS_REQUEST_MUTATION_LIMIT
+from google.cloud.bigtable.data.mutations import _EntryWithProto
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+if TYPE_CHECKING:
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+ from google.cloud.bigtable_v2.services.bigtable.client import (
+ BigtableClient as GapicClientType,
+ )
+ from google.cloud.bigtable.data._sync_autogen.client import Table as TableType
+
+
+class _MutateRowsOperation:
+ """
+ MutateRowsOperation manages the logic of sending a set of row mutations,
+ and retrying on failed entries. It manages this using the _run_attempt
+ function, which attempts to mutate all outstanding entries, and raises
+ _MutateRowsIncomplete if any retryable errors are encountered.
+
+ Errors are exposed as a MutationsExceptionGroup, which contains a list of
+ exceptions organized by the related failed mutation entries.
+
+ Args:
+ gapic_client: the client to use for the mutate_rows call
+ table: the table associated with the request
+ mutation_entries: a list of RowMutationEntry objects to send to the server
+ operation_timeout: the timeout to use for the entire operation, in seconds.
+ attempt_timeout: the timeout to use for each mutate_rows attempt, in seconds.
+ If not specified, the request will run until operation_timeout is reached.
+ """
+
+ def __init__(
+ self,
+ gapic_client: GapicClientType,
+ table: TableType,
+ mutation_entries: list["RowMutationEntry"],
+ operation_timeout: float,
+ attempt_timeout: float | None,
+ retryable_exceptions: Sequence[type[Exception]] = (),
+ ):
+ total_mutations = sum((len(entry.mutations) for entry in mutation_entries))
+ if total_mutations > _MUTATE_ROWS_REQUEST_MUTATION_LIMIT:
+ raise ValueError(
+ f"mutate_rows requests can contain at most {_MUTATE_ROWS_REQUEST_MUTATION_LIMIT} mutations across all entries. Found {total_mutations}."
+ )
+ self._gapic_fn = functools.partial(
+ gapic_client.mutate_rows,
+ table_name=table.table_name,
+ app_profile_id=table.app_profile_id,
+ retry=None,
+ )
+ self.is_retryable = retries.if_exception_type(
+ *retryable_exceptions, bt_exceptions._MutateRowsIncomplete
+ )
+ sleep_generator = retries.exponential_sleep_generator(0.01, 2, 60)
+ self._operation = lambda: CrossSync._Sync_Impl.retry_target(
+ self._run_attempt,
+ self.is_retryable,
+ sleep_generator,
+ operation_timeout,
+ exception_factory=_retry_exception_factory,
+ )
+ self.timeout_generator = _attempt_timeout_generator(
+ attempt_timeout, operation_timeout
+ )
+ self.mutations = [_EntryWithProto(m, m._to_pb()) for m in mutation_entries]
+ self.remaining_indices = list(range(len(self.mutations)))
+ self.errors: dict[int, list[Exception]] = {}
+
+ def start(self):
+ """Start the operation, and run until completion
+
+ Raises:
+ MutationsExceptionGroup: if any mutations failed"""
+ try:
+ self._operation()
+ except Exception as exc:
+ incomplete_indices = self.remaining_indices.copy()
+ for idx in incomplete_indices:
+ self._handle_entry_error(idx, exc)
+ finally:
+ all_errors: list[Exception] = []
+ for idx, exc_list in self.errors.items():
+ if len(exc_list) == 0:
+ raise core_exceptions.ClientError(
+ f"Mutation {idx} failed with no associated errors"
+ )
+ elif len(exc_list) == 1:
+ cause_exc = exc_list[0]
+ else:
+ cause_exc = bt_exceptions.RetryExceptionGroup(exc_list)
+ entry = self.mutations[idx].entry
+ all_errors.append(
+ bt_exceptions.FailedMutationEntryError(idx, entry, cause_exc)
+ )
+ if all_errors:
+ raise bt_exceptions.MutationsExceptionGroup(
+ all_errors, len(self.mutations)
+ )
+
+ def _run_attempt(self):
+ """Run a single attempt of the mutate_rows rpc.
+
+ Raises:
+ _MutateRowsIncomplete: if there are failed mutations eligible for
+ retry after the attempt is complete
+ GoogleAPICallError: if the gapic rpc fails"""
+ request_entries = [self.mutations[idx].proto for idx in self.remaining_indices]
+ active_request_indices = {
+ req_idx: orig_idx
+ for (req_idx, orig_idx) in enumerate(self.remaining_indices)
+ }
+ self.remaining_indices = []
+ if not request_entries:
+ return
+ try:
+ result_generator = self._gapic_fn(
+ timeout=next(self.timeout_generator),
+ entries=request_entries,
+ retry=None,
+ )
+ for result_list in result_generator:
+ for result in result_list.entries:
+ orig_idx = active_request_indices[result.index]
+ entry_error = core_exceptions.from_grpc_status(
+ result.status.code,
+ result.status.message,
+ details=result.status.details,
+ )
+ if result.status.code != 0:
+ self._handle_entry_error(orig_idx, entry_error)
+ elif orig_idx in self.errors:
+ del self.errors[orig_idx]
+ del active_request_indices[result.index]
+ except Exception as exc:
+ for idx in active_request_indices.values():
+ self._handle_entry_error(idx, exc)
+ raise
+ if self.remaining_indices:
+ raise bt_exceptions._MutateRowsIncomplete
+
+ def _handle_entry_error(self, idx: int, exc: Exception):
+ """Add an exception to the list of exceptions for a given mutation index,
+ and add the index to the list of remaining indices if the exception is
+ retryable.
+
+ Args:
+ idx: the index of the mutation that failed
+ exc: the exception to add to the list"""
+ entry = self.mutations[idx].entry
+ self.errors.setdefault(idx, []).append(exc)
+ if (
+ entry.is_idempotent()
+ and self.is_retryable(exc)
+ and (idx not in self.remaining_indices)
+ ):
+ self.remaining_indices.append(idx)
diff --git a/google/cloud/bigtable/data/_sync_autogen/_read_rows.py b/google/cloud/bigtable/data/_sync_autogen/_read_rows.py
new file mode 100644
index 000000000..92619c6a4
--- /dev/null
+++ b/google/cloud/bigtable/data/_sync_autogen/_read_rows.py
@@ -0,0 +1,304 @@
+# Copyright 2024 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.
+#
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+from typing import Sequence, TYPE_CHECKING
+from google.cloud.bigtable_v2.types import ReadRowsRequest as ReadRowsRequestPB
+from google.cloud.bigtable_v2.types import ReadRowsResponse as ReadRowsResponsePB
+from google.cloud.bigtable_v2.types import RowSet as RowSetPB
+from google.cloud.bigtable_v2.types import RowRange as RowRangePB
+from google.cloud.bigtable.data.row import Row, Cell
+from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+from google.cloud.bigtable.data.exceptions import InvalidChunk
+from google.cloud.bigtable.data.exceptions import _RowSetComplete
+from google.cloud.bigtable.data.exceptions import _ResetRow
+from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
+from google.cloud.bigtable.data._helpers import _retry_exception_factory
+from google.api_core import retry as retries
+from google.api_core.retry import exponential_sleep_generator
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+if TYPE_CHECKING:
+ from google.cloud.bigtable.data._sync_autogen.client import Table as TableType
+
+
+class _ReadRowsOperation:
+ """
+ ReadRowsOperation handles the logic of merging chunks from a ReadRowsResponse stream
+ into a stream of Row objects.
+
+ ReadRowsOperation.merge_row_response_stream takes in a stream of ReadRowsResponse
+ and turns them into a stream of Row objects using an internal
+ StateMachine.
+
+ ReadRowsOperation(request, client) handles row merging logic end-to-end, including
+ performing retries on stream errors.
+
+ Args:
+ query: The query to execute
+ table: The table to send the request to
+ operation_timeout: The total time to allow for the operation, in seconds
+ attempt_timeout: The time to allow for each individual attempt, in seconds
+ retryable_exceptions: A list of exceptions that should trigger a retry
+ """
+
+ __slots__ = (
+ "attempt_timeout_gen",
+ "operation_timeout",
+ "request",
+ "table",
+ "_predicate",
+ "_last_yielded_row_key",
+ "_remaining_count",
+ )
+
+ def __init__(
+ self,
+ query: ReadRowsQuery,
+ table: TableType,
+ operation_timeout: float,
+ attempt_timeout: float,
+ retryable_exceptions: Sequence[type[Exception]] = (),
+ ):
+ self.attempt_timeout_gen = _attempt_timeout_generator(
+ attempt_timeout, operation_timeout
+ )
+ self.operation_timeout = operation_timeout
+ if isinstance(query, dict):
+ self.request = ReadRowsRequestPB(
+ **query,
+ table_name=table.table_name,
+ app_profile_id=table.app_profile_id,
+ )
+ else:
+ self.request = query._to_pb(table)
+ self.table = table
+ self._predicate = retries.if_exception_type(*retryable_exceptions)
+ self._last_yielded_row_key: bytes | None = None
+ self._remaining_count: int | None = self.request.rows_limit or None
+
+ def start_operation(self) -> CrossSync._Sync_Impl.Iterable[Row]:
+ """Start the read_rows operation, retrying on retryable errors.
+
+ Yields:
+ Row: The next row in the stream"""
+ return CrossSync._Sync_Impl.retry_target_stream(
+ self._read_rows_attempt,
+ self._predicate,
+ exponential_sleep_generator(0.01, 60, multiplier=2),
+ self.operation_timeout,
+ exception_factory=_retry_exception_factory,
+ )
+
+ def _read_rows_attempt(self) -> CrossSync._Sync_Impl.Iterable[Row]:
+ """Attempt a single read_rows rpc call.
+ This function is intended to be wrapped by retry logic,
+ which will call this function until it succeeds or
+ a non-retryable error is raised.
+
+ Yields:
+ Row: The next row in the stream"""
+ if self._last_yielded_row_key is not None:
+ try:
+ self.request.rows = self._revise_request_rowset(
+ row_set=self.request.rows,
+ last_seen_row_key=self._last_yielded_row_key,
+ )
+ except _RowSetComplete:
+ return self.merge_rows(None)
+ if self._remaining_count is not None:
+ self.request.rows_limit = self._remaining_count
+ if self._remaining_count == 0:
+ return self.merge_rows(None)
+ gapic_stream = self.table.client._gapic_client.read_rows(
+ self.request, timeout=next(self.attempt_timeout_gen), retry=None
+ )
+ chunked_stream = self.chunk_stream(gapic_stream)
+ return self.merge_rows(chunked_stream)
+
+ def chunk_stream(
+ self,
+ stream: CrossSync._Sync_Impl.Awaitable[
+ CrossSync._Sync_Impl.Iterable[ReadRowsResponsePB]
+ ],
+ ) -> CrossSync._Sync_Impl.Iterable[ReadRowsResponsePB.CellChunk]:
+ """process chunks out of raw read_rows stream
+
+ Args:
+ stream: the raw read_rows stream from the gapic client
+ Yields:
+ ReadRowsResponsePB.CellChunk: the next chunk in the stream"""
+ for resp in stream:
+ resp = resp._pb
+ if resp.last_scanned_row_key:
+ if (
+ self._last_yielded_row_key is not None
+ and resp.last_scanned_row_key <= self._last_yielded_row_key
+ ):
+ raise InvalidChunk("last scanned out of order")
+ self._last_yielded_row_key = resp.last_scanned_row_key
+ current_key = None
+ for c in resp.chunks:
+ if current_key is None:
+ current_key = c.row_key
+ if current_key is None:
+ raise InvalidChunk("first chunk is missing a row key")
+ elif (
+ self._last_yielded_row_key
+ and current_key <= self._last_yielded_row_key
+ ):
+ raise InvalidChunk("row keys should be strictly increasing")
+ yield c
+ if c.reset_row:
+ current_key = None
+ elif c.commit_row:
+ self._last_yielded_row_key = current_key
+ if self._remaining_count is not None:
+ self._remaining_count -= 1
+ if self._remaining_count < 0:
+ raise InvalidChunk("emit count exceeds row limit")
+ current_key = None
+
+ @staticmethod
+ def merge_rows(
+ chunks: CrossSync._Sync_Impl.Iterable[ReadRowsResponsePB.CellChunk] | None,
+ ) -> CrossSync._Sync_Impl.Iterable[Row]:
+ """Merge chunks into rows
+
+ Args:
+ chunks: the chunk stream to merge
+ Yields:
+ Row: the next row in the stream"""
+ if chunks is None:
+ return
+ it = chunks.__iter__()
+ while True:
+ try:
+ c = it.__next__()
+ except CrossSync._Sync_Impl.StopIteration:
+ return
+ row_key = c.row_key
+ if not row_key:
+ raise InvalidChunk("first row chunk is missing key")
+ cells = []
+ family: str | None = None
+ qualifier: bytes | None = None
+ try:
+ while True:
+ if c.reset_row:
+ raise _ResetRow(c)
+ k = c.row_key
+ f = c.family_name.value
+ q = c.qualifier.value if c.HasField("qualifier") else None
+ if k and k != row_key:
+ raise InvalidChunk("unexpected new row key")
+ if f:
+ family = f
+ if q is not None:
+ qualifier = q
+ else:
+ raise InvalidChunk("new family without qualifier")
+ elif family is None:
+ raise InvalidChunk("missing family")
+ elif q is not None:
+ if family is None:
+ raise InvalidChunk("new qualifier without family")
+ qualifier = q
+ elif qualifier is None:
+ raise InvalidChunk("missing qualifier")
+ ts = c.timestamp_micros
+ labels = c.labels if c.labels else []
+ value = c.value
+ if c.value_size > 0:
+ buffer = [value]
+ while c.value_size > 0:
+ c = it.__next__()
+ t = c.timestamp_micros
+ cl = c.labels
+ k = c.row_key
+ if (
+ c.HasField("family_name")
+ and c.family_name.value != family
+ ):
+ raise InvalidChunk("family changed mid cell")
+ if (
+ c.HasField("qualifier")
+ and c.qualifier.value != qualifier
+ ):
+ raise InvalidChunk("qualifier changed mid cell")
+ if t and t != ts:
+ raise InvalidChunk("timestamp changed mid cell")
+ if cl and cl != labels:
+ raise InvalidChunk("labels changed mid cell")
+ if k and k != row_key:
+ raise InvalidChunk("row key changed mid cell")
+ if c.reset_row:
+ raise _ResetRow(c)
+ buffer.append(c.value)
+ value = b"".join(buffer)
+ cells.append(
+ Cell(value, row_key, family, qualifier, ts, list(labels))
+ )
+ if c.commit_row:
+ yield Row(row_key, cells)
+ break
+ c = it.__next__()
+ except _ResetRow as e:
+ c = e.chunk
+ if (
+ c.row_key
+ or c.HasField("family_name")
+ or c.HasField("qualifier")
+ or c.timestamp_micros
+ or c.labels
+ or c.value
+ ):
+ raise InvalidChunk("reset row with data")
+ continue
+ except CrossSync._Sync_Impl.StopIteration:
+ raise InvalidChunk("premature end of stream")
+
+ @staticmethod
+ def _revise_request_rowset(row_set: RowSetPB, last_seen_row_key: bytes) -> RowSetPB:
+ """Revise the rows in the request to avoid ones we've already processed.
+
+ Args:
+ row_set: the row set from the request
+ last_seen_row_key: the last row key encountered
+ Returns:
+ RowSetPB: the new rowset after adusting for the last seen key
+ Raises:
+ _RowSetComplete: if there are no rows left to process after the revision"""
+ if row_set is None or (not row_set.row_ranges and (not row_set.row_keys)):
+ last_seen = last_seen_row_key
+ return RowSetPB(row_ranges=[RowRangePB(start_key_open=last_seen)])
+ adjusted_keys: list[bytes] = [
+ k for k in row_set.row_keys if k > last_seen_row_key
+ ]
+ adjusted_ranges: list[RowRangePB] = []
+ for row_range in row_set.row_ranges:
+ end_key = row_range.end_key_closed or row_range.end_key_open or None
+ if end_key is None or end_key > last_seen_row_key:
+ new_range = RowRangePB(row_range)
+ start_key = row_range.start_key_closed or row_range.start_key_open
+ if start_key is None or start_key <= last_seen_row_key:
+ new_range.start_key_open = last_seen_row_key
+ adjusted_ranges.append(new_range)
+ if len(adjusted_keys) == 0 and len(adjusted_ranges) == 0:
+ raise _RowSetComplete()
+ return RowSetPB(row_keys=adjusted_keys, row_ranges=adjusted_ranges)
diff --git a/google/cloud/bigtable/data/_sync_autogen/client.py b/google/cloud/bigtable/data/_sync_autogen/client.py
new file mode 100644
index 000000000..37e192147
--- /dev/null
+++ b/google/cloud/bigtable/data/_sync_autogen/client.py
@@ -0,0 +1,1234 @@
+# Copyright 2024 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.
+#
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+from typing import cast, Any, Optional, Set, Sequence, TYPE_CHECKING
+import time
+import warnings
+import random
+import os
+import concurrent.futures
+from functools import partial
+from grpc import Channel
+from google.cloud.bigtable.data.execute_query.values import ExecuteQueryValueType
+from google.cloud.bigtable.data.execute_query.metadata import SqlType
+from google.cloud.bigtable.data.execute_query._parameters_formatting import (
+ _format_execute_query_params,
+)
+from google.cloud.bigtable_v2.services.bigtable.transports.base import (
+ DEFAULT_CLIENT_INFO,
+)
+from google.cloud.bigtable_v2.types.bigtable import PingAndWarmRequest
+from google.cloud.client import ClientWithProject
+from google.cloud.environment_vars import BIGTABLE_EMULATOR
+from google.api_core import retry as retries
+from google.api_core.exceptions import DeadlineExceeded
+from google.api_core.exceptions import ServiceUnavailable
+from google.api_core.exceptions import Aborted
+import google.auth.credentials
+import google.auth._default
+from google.api_core import client_options as client_options_lib
+from google.cloud.bigtable.client import _DEFAULT_BIGTABLE_EMULATOR_CLIENT
+from google.cloud.bigtable.data.row import Row
+from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+from google.cloud.bigtable.data.exceptions import FailedQueryShardError
+from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
+from google.cloud.bigtable.data._helpers import TABLE_DEFAULT
+from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
+from google.cloud.bigtable.data._helpers import _retry_exception_factory
+from google.cloud.bigtable.data._helpers import _validate_timeouts
+from google.cloud.bigtable.data._helpers import _get_error_type
+from google.cloud.bigtable.data._helpers import _get_retryable_errors
+from google.cloud.bigtable.data._helpers import _get_timeouts
+from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
+from google.cloud.bigtable.data.mutations import Mutation, RowMutationEntry
+from google.cloud.bigtable.data.read_modify_write_rules import ReadModifyWriteRule
+from google.cloud.bigtable.data.row_filters import RowFilter
+from google.cloud.bigtable.data.row_filters import StripValueTransformerFilter
+from google.cloud.bigtable.data.row_filters import CellsRowLimitFilter
+from google.cloud.bigtable.data.row_filters import RowFilterChain
+from google.cloud.bigtable.data._cross_sync import CrossSync
+from typing import Iterable
+from grpc import insecure_channel
+from google.cloud.bigtable_v2.services.bigtable.transports import (
+ BigtableGrpcTransport as TransportType,
+)
+from google.cloud.bigtable.data._sync_autogen.mutations_batcher import _MB_SIZE
+
+if TYPE_CHECKING:
+ from google.cloud.bigtable.data._helpers import RowKeySamples
+ from google.cloud.bigtable.data._helpers import ShardedQuery
+ from google.cloud.bigtable.data._sync_autogen.mutations_batcher import (
+ MutationsBatcher,
+ )
+ from google.cloud.bigtable.data.execute_query._sync_autogen.execute_query_iterator import (
+ ExecuteQueryIterator,
+ )
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("DataClient")
+class BigtableDataClient(ClientWithProject):
+ def __init__(
+ self,
+ *,
+ project: str | None = None,
+ credentials: google.auth.credentials.Credentials | None = None,
+ client_options: dict[str, Any]
+ | "google.api_core.client_options.ClientOptions"
+ | None = None,
+ **kwargs,
+ ):
+ """Create a client instance for the Bigtable Data API
+
+
+
+ Args:
+ project: the project which the client acts on behalf of.
+ If not passed, falls back to the default inferred
+ from the environment.
+ credentials:
+ Thehe OAuth2 Credentials to use for this
+ client. If not passed (and if no ``_http`` object is
+ passed), falls back to the default inferred from the
+ environment.
+ client_options:
+ Client options used to set user options
+ on the client. API Endpoint should be set through client_options.
+ Raises:
+ """
+ if "pool_size" in kwargs:
+ warnings.warn("pool_size no longer supported")
+ client_info = DEFAULT_CLIENT_INFO
+ client_info.client_library_version = self._client_version()
+ if type(client_options) is dict:
+ client_options = client_options_lib.from_dict(client_options)
+ client_options = cast(
+ Optional[client_options_lib.ClientOptions], client_options
+ )
+ custom_channel = None
+ self._emulator_host = os.getenv(BIGTABLE_EMULATOR)
+ if self._emulator_host is not None:
+ warnings.warn(
+ "Connecting to Bigtable emulator at {}".format(self._emulator_host),
+ RuntimeWarning,
+ stacklevel=2,
+ )
+ custom_channel = insecure_channel(self._emulator_host)
+ if credentials is None:
+ credentials = google.auth.credentials.AnonymousCredentials()
+ if project is None:
+ project = _DEFAULT_BIGTABLE_EMULATOR_CLIENT
+ ClientWithProject.__init__(
+ self,
+ credentials=credentials,
+ project=project,
+ client_options=client_options,
+ )
+ self._gapic_client = CrossSync._Sync_Impl.GapicClient(
+ credentials=credentials,
+ client_options=client_options,
+ client_info=client_info,
+ transport=lambda *args, **kwargs: TransportType(
+ *args, **kwargs, channel=custom_channel
+ ),
+ )
+ self._is_closed = CrossSync._Sync_Impl.Event()
+ self.transport = cast(TransportType, self._gapic_client.transport)
+ self._active_instances: Set[_WarmedInstanceKey] = set()
+ self._instance_owners: dict[_WarmedInstanceKey, Set[int]] = {}
+ self._channel_init_time = time.monotonic()
+ self._channel_refresh_task: CrossSync._Sync_Impl.Task[None] | None = None
+ self._executor = (
+ concurrent.futures.ThreadPoolExecutor()
+ if not CrossSync._Sync_Impl.is_async
+ else None
+ )
+ if self._emulator_host is None:
+ try:
+ self._start_background_channel_refresh()
+ except RuntimeError:
+ warnings.warn(
+ f"{self.__class__.__name__} should be started in an asyncio event loop. Channel refresh will not be started",
+ RuntimeWarning,
+ stacklevel=2,
+ )
+
+ @staticmethod
+ def _client_version() -> str:
+ """Helper function to return the client version string for this client"""
+ version_str = f"{google.cloud.bigtable.__version__}-data"
+ return version_str
+
+ def _start_background_channel_refresh(self) -> None:
+ """Starts a background task to ping and warm grpc channel
+
+ Raises:
+ None"""
+ if (
+ not self._channel_refresh_task
+ and (not self._emulator_host)
+ and (not self._is_closed.is_set())
+ ):
+ CrossSync._Sync_Impl.verify_async_event_loop()
+ self._channel_refresh_task = CrossSync._Sync_Impl.create_task(
+ self._manage_channel,
+ sync_executor=self._executor,
+ task_name=f"{self.__class__.__name__} channel refresh",
+ )
+
+ def close(self, timeout: float | None = 2.0):
+ """Cancel all background tasks"""
+ self._is_closed.set()
+ if self._channel_refresh_task is not None:
+ self._channel_refresh_task.cancel()
+ CrossSync._Sync_Impl.wait([self._channel_refresh_task], timeout=timeout)
+ self.transport.close()
+ if self._executor:
+ self._executor.shutdown(wait=False)
+ self._channel_refresh_task = None
+
+ def _ping_and_warm_instances(
+ self,
+ instance_key: _WarmedInstanceKey | None = None,
+ channel: Channel | None = None,
+ ) -> list[BaseException | None]:
+ """Prepares the backend for requests on a channel
+
+ Pings each Bigtable instance registered in `_active_instances` on the client
+
+ Args:
+ instance_key: if provided, only warm the instance associated with the key
+ channel: grpc channel to warm. If none, warms `self.transport.grpc_channel`
+ Returns:
+ list[BaseException | None]: sequence of results or exceptions from the ping requests
+ """
+ channel = channel or self.transport.grpc_channel
+ instance_list = (
+ [instance_key] if instance_key is not None else self._active_instances
+ )
+ ping_rpc = channel.unary_unary(
+ "/google.bigtable.v2.Bigtable/PingAndWarm",
+ request_serializer=PingAndWarmRequest.serialize,
+ )
+ partial_list = [
+ partial(
+ ping_rpc,
+ request={"name": instance_name, "app_profile_id": app_profile_id},
+ metadata=[
+ (
+ "x-goog-request-params",
+ f"name={instance_name}&app_profile_id={app_profile_id}",
+ )
+ ],
+ wait_for_ready=True,
+ )
+ for (instance_name, table_name, app_profile_id) in instance_list
+ ]
+ result_list = CrossSync._Sync_Impl.gather_partials(
+ partial_list, return_exceptions=True, sync_executor=self._executor
+ )
+ return [r or None for r in result_list]
+
+ def _manage_channel(
+ self,
+ refresh_interval_min: float = 60 * 35,
+ refresh_interval_max: float = 60 * 45,
+ grace_period: float = 60 * 10,
+ ) -> None:
+ """Background task that periodically refreshes and warms a grpc channel
+
+ The backend will automatically close channels after 60 minutes, so
+ `refresh_interval` + `grace_period` should be < 60 minutes
+
+ Runs continuously until the client is closed
+
+ Args:
+ refresh_interval_min: minimum interval before initiating refresh
+ process in seconds. Actual interval will be a random value
+ between `refresh_interval_min` and `refresh_interval_max`
+ refresh_interval_max: maximum interval before initiating refresh
+ process in seconds. Actual interval will be a random value
+ between `refresh_interval_min` and `refresh_interval_max`
+ grace_period: time to allow previous channel to serve existing
+ requests before closing, in seconds"""
+ first_refresh = self._channel_init_time + random.uniform(
+ refresh_interval_min, refresh_interval_max
+ )
+ next_sleep = max(first_refresh - time.monotonic(), 0)
+ if next_sleep > 0:
+ self._ping_and_warm_instances(channel=self.transport.grpc_channel)
+ while not self._is_closed.is_set():
+ CrossSync._Sync_Impl.event_wait(
+ self._is_closed, next_sleep, async_break_early=False
+ )
+ if self._is_closed.is_set():
+ break
+ start_timestamp = time.monotonic()
+ old_channel = self.transport.grpc_channel
+ new_channel = self.transport.create_channel()
+ self._ping_and_warm_instances(channel=new_channel)
+ self.transport._grpc_channel = new_channel
+ if grace_period:
+ self._is_closed.wait(grace_period)
+ old_channel.close()
+ next_refresh = random.uniform(refresh_interval_min, refresh_interval_max)
+ next_sleep = max(next_refresh - (time.monotonic() - start_timestamp), 0)
+
+ def _register_instance(
+ self, instance_id: str, owner: Table | ExecuteQueryIterator
+ ) -> None:
+ """Registers an instance with the client, and warms the channel for the instance
+ The client will periodically refresh grpc channel used to make
+ requests, and new channels will be warmed for each registered instance
+ Channels will not be refreshed unless at least one instance is registered
+
+ Args:
+ instance_id: id of the instance to register.
+ owner: table that owns the instance. Owners will be tracked in
+ _instance_owners, and instances will only be unregistered when all
+ owners call _remove_instance_registration"""
+ instance_name = self._gapic_client.instance_path(self.project, instance_id)
+ instance_key = _WarmedInstanceKey(
+ instance_name, owner.table_name, owner.app_profile_id
+ )
+ self._instance_owners.setdefault(instance_key, set()).add(id(owner))
+ if instance_key not in self._active_instances:
+ self._active_instances.add(instance_key)
+ if self._channel_refresh_task:
+ self._ping_and_warm_instances(instance_key)
+ else:
+ self._start_background_channel_refresh()
+
+ def _remove_instance_registration(
+ self, instance_id: str, owner: Table | "ExecuteQueryIterator"
+ ) -> bool:
+ """Removes an instance from the client's registered instances, to prevent
+ warming new channels for the instance
+
+ If instance_id is not registered, or is still in use by other tables, returns False
+
+ Args:
+ instance_id: id of the instance to remove
+ owner: table that owns the instance. Owners will be tracked in
+ _instance_owners, and instances will only be unregistered when all
+ owners call _remove_instance_registration
+ Returns:
+ bool: True if instance was removed, else False"""
+ instance_name = self._gapic_client.instance_path(self.project, instance_id)
+ instance_key = _WarmedInstanceKey(
+ instance_name, owner.table_name, owner.app_profile_id
+ )
+ owner_list = self._instance_owners.get(instance_key, set())
+ try:
+ owner_list.remove(id(owner))
+ if len(owner_list) == 0:
+ self._active_instances.remove(instance_key)
+ return True
+ except KeyError:
+ return False
+
+ def get_table(self, instance_id: str, table_id: str, *args, **kwargs) -> Table:
+ """Returns a table instance for making data API requests. All arguments are passed
+ directly to the Table constructor.
+
+
+
+ Args:
+ instance_id: The Bigtable instance ID to associate with this client.
+ instance_id is combined with the client's project to fully
+ specify the instance
+ table_id: The ID of the table. table_id is combined with the
+ instance_id and the client's project to fully specify the table
+ app_profile_id: The app profile to associate with requests.
+ https://cloud.google.com/bigtable/docs/app-profiles
+ default_read_rows_operation_timeout: The default timeout for read rows
+ operations, in seconds. If not set, defaults to 600 seconds (10 minutes)
+ default_read_rows_attempt_timeout: The default timeout for individual
+ read rows rpc requests, in seconds. If not set, defaults to 20 seconds
+ default_mutate_rows_operation_timeout: The default timeout for mutate rows
+ operations, in seconds. If not set, defaults to 600 seconds (10 minutes)
+ default_mutate_rows_attempt_timeout: The default timeout for individual
+ mutate rows rpc requests, in seconds. If not set, defaults to 60 seconds
+ default_operation_timeout: The default timeout for all other operations, in
+ seconds. If not set, defaults to 60 seconds
+ default_attempt_timeout: The default timeout for all other individual rpc
+ requests, in seconds. If not set, defaults to 20 seconds
+ default_read_rows_retryable_errors: a list of errors that will be retried
+ if encountered during read_rows and related operations.
+ Defaults to 4 (DeadlineExceeded), 14 (ServiceUnavailable), and 10 (Aborted)
+ default_mutate_rows_retryable_errors: a list of errors that will be retried
+ if encountered during mutate_rows and related operations.
+ Defaults to 4 (DeadlineExceeded) and 14 (ServiceUnavailable)
+ default_retryable_errors: a list of errors that will be retried if
+ encountered during all other operations.
+ Defaults to 4 (DeadlineExceeded) and 14 (ServiceUnavailable)
+ Returns:
+ Table: a table instance for making data API requests
+ Raises:
+ None"""
+ return Table(self, instance_id, table_id, *args, **kwargs)
+
+ def execute_query(
+ self,
+ query: str,
+ instance_id: str,
+ *,
+ parameters: dict[str, ExecuteQueryValueType] | None = None,
+ parameter_types: dict[str, SqlType.Type] | None = None,
+ app_profile_id: str | None = None,
+ operation_timeout: float = 600,
+ attempt_timeout: float | None = 20,
+ retryable_errors: Sequence[type[Exception]] = (
+ DeadlineExceeded,
+ ServiceUnavailable,
+ Aborted,
+ ),
+ ) -> "ExecuteQueryIterator":
+ """Executes an SQL query on an instance.
+ Returns an iterator to asynchronously stream back columns from selected rows.
+
+ Failed requests within operation_timeout will be retried based on the
+ retryable_errors list until operation_timeout is reached.
+
+ Args:
+ query: Query to be run on Bigtable instance. The query can use ``@param``
+ placeholders to use parameter interpolation on the server. Values for all
+ parameters should be provided in ``parameters``. Types of parameters are
+ inferred but should be provided in ``parameter_types`` if the inference is
+ not possible (i.e. when value can be None, an empty list or an empty dict).
+ instance_id: The Bigtable instance ID to perform the query on.
+ instance_id is combined with the client's project to fully
+ specify the instance.
+ parameters: Dictionary with values for all parameters used in the ``query``.
+ parameter_types: Dictionary with types of parameters used in the ``query``.
+ Required to contain entries only for parameters whose type cannot be
+ detected automatically (i.e. the value can be None, an empty list or
+ an empty dict).
+ app_profile_id: The app profile to associate with requests.
+ https://cloud.google.com/bigtable/docs/app-profiles
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to 600 seconds.
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the 20 seconds.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to 4 (DeadlineExceeded), 14 (ServiceUnavailable), and 10 (Aborted)
+ Returns:
+ ExecuteQueryIterator: an asynchronous iterator that yields rows returned by the query
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing GoogleAPIError exceptions
+ from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised if the request encounters an unrecoverable error
+ """
+ warnings.warn(
+ "ExecuteQuery is in preview and may change in the future.",
+ category=RuntimeWarning,
+ )
+ retryable_excs = [_get_error_type(e) for e in retryable_errors]
+ pb_params = _format_execute_query_params(parameters, parameter_types)
+ instance_name = self._gapic_client.instance_path(self.project, instance_id)
+ request_body = {
+ "instance_name": instance_name,
+ "app_profile_id": app_profile_id,
+ "query": query,
+ "params": pb_params,
+ "proto_format": {},
+ }
+ return CrossSync._Sync_Impl.ExecuteQueryIterator(
+ self,
+ instance_id,
+ app_profile_id,
+ request_body,
+ attempt_timeout,
+ operation_timeout,
+ retryable_excs=retryable_excs,
+ )
+
+ def __enter__(self):
+ self._start_background_channel_refresh()
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.close()
+ self._gapic_client.__exit__(exc_type, exc_val, exc_tb)
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("Table")
+class Table:
+ """
+ Main Data API surface
+
+ Table object maintains table_id, and app_profile_id context, and passes them with
+ each call
+ """
+
+ def __init__(
+ self,
+ client: BigtableDataClient,
+ instance_id: str,
+ table_id: str,
+ app_profile_id: str | None = None,
+ *,
+ default_read_rows_operation_timeout: float = 600,
+ default_read_rows_attempt_timeout: float | None = 20,
+ default_mutate_rows_operation_timeout: float = 600,
+ default_mutate_rows_attempt_timeout: float | None = 60,
+ default_operation_timeout: float = 60,
+ default_attempt_timeout: float | None = 20,
+ default_read_rows_retryable_errors: Sequence[type[Exception]] = (
+ DeadlineExceeded,
+ ServiceUnavailable,
+ Aborted,
+ ),
+ default_mutate_rows_retryable_errors: Sequence[type[Exception]] = (
+ DeadlineExceeded,
+ ServiceUnavailable,
+ ),
+ default_retryable_errors: Sequence[type[Exception]] = (
+ DeadlineExceeded,
+ ServiceUnavailable,
+ ),
+ ):
+ """Initialize a Table instance
+
+
+
+ Args:
+ instance_id: The Bigtable instance ID to associate with this client.
+ instance_id is combined with the client's project to fully
+ specify the instance
+ table_id: The ID of the table. table_id is combined with the
+ instance_id and the client's project to fully specify the table
+ app_profile_id: The app profile to associate with requests.
+ https://cloud.google.com/bigtable/docs/app-profiles
+ default_read_rows_operation_timeout: The default timeout for read rows
+ operations, in seconds. If not set, defaults to 600 seconds (10 minutes)
+ default_read_rows_attempt_timeout: The default timeout for individual
+ read rows rpc requests, in seconds. If not set, defaults to 20 seconds
+ default_mutate_rows_operation_timeout: The default timeout for mutate rows
+ operations, in seconds. If not set, defaults to 600 seconds (10 minutes)
+ default_mutate_rows_attempt_timeout: The default timeout for individual
+ mutate rows rpc requests, in seconds. If not set, defaults to 60 seconds
+ default_operation_timeout: The default timeout for all other operations, in
+ seconds. If not set, defaults to 60 seconds
+ default_attempt_timeout: The default timeout for all other individual rpc
+ requests, in seconds. If not set, defaults to 20 seconds
+ default_read_rows_retryable_errors: a list of errors that will be retried
+ if encountered during read_rows and related operations.
+ Defaults to 4 (DeadlineExceeded), 14 (ServiceUnavailable), and 10 (Aborted)
+ default_mutate_rows_retryable_errors: a list of errors that will be retried
+ if encountered during mutate_rows and related operations.
+ Defaults to 4 (DeadlineExceeded) and 14 (ServiceUnavailable)
+ default_retryable_errors: a list of errors that will be retried if
+ encountered during all other operations.
+ Defaults to 4 (DeadlineExceeded) and 14 (ServiceUnavailable)
+ Raises:
+ None"""
+ _validate_timeouts(
+ default_operation_timeout, default_attempt_timeout, allow_none=True
+ )
+ _validate_timeouts(
+ default_read_rows_operation_timeout,
+ default_read_rows_attempt_timeout,
+ allow_none=True,
+ )
+ _validate_timeouts(
+ default_mutate_rows_operation_timeout,
+ default_mutate_rows_attempt_timeout,
+ allow_none=True,
+ )
+ self.client = client
+ self.instance_id = instance_id
+ self.instance_name = self.client._gapic_client.instance_path(
+ self.client.project, instance_id
+ )
+ self.table_id = table_id
+ self.table_name = self.client._gapic_client.table_path(
+ self.client.project, instance_id, table_id
+ )
+ self.app_profile_id = app_profile_id
+ self.default_operation_timeout = default_operation_timeout
+ self.default_attempt_timeout = default_attempt_timeout
+ self.default_read_rows_operation_timeout = default_read_rows_operation_timeout
+ self.default_read_rows_attempt_timeout = default_read_rows_attempt_timeout
+ self.default_mutate_rows_operation_timeout = (
+ default_mutate_rows_operation_timeout
+ )
+ self.default_mutate_rows_attempt_timeout = default_mutate_rows_attempt_timeout
+ self.default_read_rows_retryable_errors = (
+ default_read_rows_retryable_errors or ()
+ )
+ self.default_mutate_rows_retryable_errors = (
+ default_mutate_rows_retryable_errors or ()
+ )
+ self.default_retryable_errors = default_retryable_errors or ()
+ try:
+ self._register_instance_future = CrossSync._Sync_Impl.create_task(
+ self.client._register_instance,
+ self.instance_id,
+ self,
+ sync_executor=self.client._executor,
+ )
+ except RuntimeError as e:
+ raise RuntimeError(
+ f"{self.__class__.__name__} must be created within an async event loop context."
+ ) from e
+
+ def read_rows_stream(
+ self,
+ query: ReadRowsQuery,
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ ) -> Iterable[Row]:
+ """Read a set of rows from the table, based on the specified query.
+ Returns an iterator to asynchronously stream back row data.
+
+ Failed requests within operation_timeout will be retried based on the
+ retryable_errors list until operation_timeout is reached.
+
+ Args:
+ query: contains details about which rows to return
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_read_rows_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_read_rows_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_read_rows_retryable_errors
+ Returns:
+ Iterable[Row]: an asynchronous iterator that yields rows returned by the query
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing GoogleAPIError exceptions
+ from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised if the request encounters an unrecoverable error
+ """
+ (operation_timeout, attempt_timeout) = _get_timeouts(
+ operation_timeout, attempt_timeout, self
+ )
+ retryable_excs = _get_retryable_errors(retryable_errors, self)
+ row_merger = CrossSync._Sync_Impl._ReadRowsOperation(
+ query,
+ self,
+ operation_timeout=operation_timeout,
+ attempt_timeout=attempt_timeout,
+ retryable_exceptions=retryable_excs,
+ )
+ return row_merger.start_operation()
+
+ def read_rows(
+ self,
+ query: ReadRowsQuery,
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ ) -> list[Row]:
+ """Read a set of rows from the table, based on the specified query.
+ Retruns results as a list of Row objects when the request is complete.
+ For streamed results, use read_rows_stream.
+
+ Failed requests within operation_timeout will be retried based on the
+ retryable_errors list until operation_timeout is reached.
+
+ Args:
+ query: contains details about which rows to return
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_read_rows_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_read_rows_attempt_timeout.
+ If None, defaults to operation_timeout.
+ If None, defaults to the Table's default_read_rows_attempt_timeout,
+ or the operation_timeout if that is also None.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_read_rows_retryable_errors.
+ Returns:
+ list[Row]: a list of Rows returned by the query
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing GoogleAPIError exceptions
+ from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised if the request encounters an unrecoverable error
+ """
+ row_generator = self.read_rows_stream(
+ query,
+ operation_timeout=operation_timeout,
+ attempt_timeout=attempt_timeout,
+ retryable_errors=retryable_errors,
+ )
+ return [row for row in row_generator]
+
+ def read_row(
+ self,
+ row_key: str | bytes,
+ *,
+ row_filter: RowFilter | None = None,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ ) -> Row | None:
+ """Read a single row from the table, based on the specified key.
+
+ Failed requests within operation_timeout will be retried based on the
+ retryable_errors list until operation_timeout is reached.
+
+ Args:
+ query: contains details about which rows to return
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_read_rows_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_read_rows_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_read_rows_retryable_errors.
+ Returns:
+ Row | None: a Row object if the row exists, otherwise None
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing GoogleAPIError exceptions
+ from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised if the request encounters an unrecoverable error
+ """
+ if row_key is None:
+ raise ValueError("row_key must be string or bytes")
+ query = ReadRowsQuery(row_keys=row_key, row_filter=row_filter, limit=1)
+ results = self.read_rows(
+ query,
+ operation_timeout=operation_timeout,
+ attempt_timeout=attempt_timeout,
+ retryable_errors=retryable_errors,
+ )
+ if len(results) == 0:
+ return None
+ return results[0]
+
+ def read_rows_sharded(
+ self,
+ sharded_query: ShardedQuery,
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ ) -> list[Row]:
+ """Runs a sharded query in parallel, then return the results in a single list.
+ Results will be returned in the order of the input queries.
+
+ This function is intended to be run on the results on a query.shard() call.
+ For example::
+
+ table_shard_keys = await table.sample_row_keys()
+ query = ReadRowsQuery(...)
+ shard_queries = query.shard(table_shard_keys)
+ results = await table.read_rows_sharded(shard_queries)
+
+ Args:
+ sharded_query: a sharded query to execute
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_read_rows_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_read_rows_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_read_rows_retryable_errors.
+ Returns:
+ list[Row]: a list of Rows returned by the query
+ Raises:
+ ShardedReadRowsExceptionGroup: if any of the queries failed
+ ValueError: if the query_list is empty"""
+ if not sharded_query:
+ raise ValueError("empty sharded_query")
+ (operation_timeout, attempt_timeout) = _get_timeouts(
+ operation_timeout, attempt_timeout, self
+ )
+ rpc_timeout_generator = _attempt_timeout_generator(
+ operation_timeout, operation_timeout
+ )
+ concurrency_sem = CrossSync._Sync_Impl.Semaphore(_CONCURRENCY_LIMIT)
+
+ def read_rows_with_semaphore(query):
+ with concurrency_sem:
+ shard_timeout = next(rpc_timeout_generator)
+ if shard_timeout <= 0:
+ raise DeadlineExceeded(
+ "Operation timeout exceeded before starting query"
+ )
+ return self.read_rows(
+ query,
+ operation_timeout=shard_timeout,
+ attempt_timeout=min(attempt_timeout, shard_timeout),
+ retryable_errors=retryable_errors,
+ )
+
+ routine_list = [
+ partial(read_rows_with_semaphore, query) for query in sharded_query
+ ]
+ batch_result = CrossSync._Sync_Impl.gather_partials(
+ routine_list, return_exceptions=True, sync_executor=self.client._executor
+ )
+ error_dict = {}
+ shard_idx = 0
+ results_list = []
+ for result in batch_result:
+ if isinstance(result, Exception):
+ error_dict[shard_idx] = result
+ elif isinstance(result, BaseException):
+ raise result
+ else:
+ results_list.extend(result)
+ shard_idx += 1
+ if error_dict:
+ raise ShardedReadRowsExceptionGroup(
+ [
+ FailedQueryShardError(idx, sharded_query[idx], e)
+ for (idx, e) in error_dict.items()
+ ],
+ results_list,
+ len(sharded_query),
+ )
+ return results_list
+
+ def row_exists(
+ self,
+ row_key: str | bytes,
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.READ_ROWS,
+ ) -> bool:
+ """Return a boolean indicating whether the specified row exists in the table.
+ uses the filters: chain(limit cells per row = 1, strip value)
+
+ Args:
+ row_key: the key of the row to check
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_read_rows_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_read_rows_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_read_rows_retryable_errors.
+ Returns:
+ bool: a bool indicating whether the row exists
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing GoogleAPIError exceptions
+ from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised if the request encounters an unrecoverable error
+ """
+ if row_key is None:
+ raise ValueError("row_key must be string or bytes")
+ strip_filter = StripValueTransformerFilter(flag=True)
+ limit_filter = CellsRowLimitFilter(1)
+ chain_filter = RowFilterChain(filters=[limit_filter, strip_filter])
+ query = ReadRowsQuery(row_keys=row_key, limit=1, row_filter=chain_filter)
+ results = self.read_rows(
+ query,
+ operation_timeout=operation_timeout,
+ attempt_timeout=attempt_timeout,
+ retryable_errors=retryable_errors,
+ )
+ return len(results) > 0
+
+ def sample_row_keys(
+ self,
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ ) -> RowKeySamples:
+ """Return a set of RowKeySamples that delimit contiguous sections of the table of
+ approximately equal size
+
+ RowKeySamples output can be used with ReadRowsQuery.shard() to create a sharded query that
+ can be parallelized across multiple backend nodes read_rows and read_rows_stream
+ requests will call sample_row_keys internally for this purpose when sharding is enabled
+
+ RowKeySamples is simply a type alias for list[tuple[bytes, int]]; a list of
+ row_keys, along with offset positions in the table
+
+ Args:
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.i
+ Defaults to the Table's default_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_retryable_errors.
+ Returns:
+ RowKeySamples: a set of RowKeySamples the delimit contiguous sections of the table
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing GoogleAPIError exceptions
+ from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised if the request encounters an unrecoverable error
+ """
+ (operation_timeout, attempt_timeout) = _get_timeouts(
+ operation_timeout, attempt_timeout, self
+ )
+ attempt_timeout_gen = _attempt_timeout_generator(
+ attempt_timeout, operation_timeout
+ )
+ retryable_excs = _get_retryable_errors(retryable_errors, self)
+ predicate = retries.if_exception_type(*retryable_excs)
+ sleep_generator = retries.exponential_sleep_generator(0.01, 2, 60)
+
+ def execute_rpc():
+ results = self.client._gapic_client.sample_row_keys(
+ table_name=self.table_name,
+ app_profile_id=self.app_profile_id,
+ timeout=next(attempt_timeout_gen),
+ retry=None,
+ )
+ return [(s.row_key, s.offset_bytes) for s in results]
+
+ return CrossSync._Sync_Impl.retry_target(
+ execute_rpc,
+ predicate,
+ sleep_generator,
+ operation_timeout,
+ exception_factory=_retry_exception_factory,
+ )
+
+ def mutations_batcher(
+ self,
+ *,
+ flush_interval: float | None = 5,
+ flush_limit_mutation_count: int | None = 1000,
+ flush_limit_bytes: int = 20 * _MB_SIZE,
+ flow_control_max_mutation_count: int = 100000,
+ flow_control_max_bytes: int = 100 * _MB_SIZE,
+ batch_operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ batch_attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ batch_retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ ) -> "MutationsBatcher":
+ """Returns a new mutations batcher instance.
+
+ Can be used to iteratively add mutations that are flushed as a group,
+ to avoid excess network calls
+
+ Args:
+ flush_interval: Automatically flush every flush_interval seconds. If None,
+ a table default will be used
+ flush_limit_mutation_count: Flush immediately after flush_limit_mutation_count
+ mutations are added across all entries. If None, this limit is ignored.
+ flush_limit_bytes: Flush immediately after flush_limit_bytes bytes are added.
+ flow_control_max_mutation_count: Maximum number of inflight mutations.
+ flow_control_max_bytes: Maximum number of inflight bytes.
+ batch_operation_timeout: timeout for each mutate_rows operation, in seconds.
+ Defaults to the Table's default_mutate_rows_operation_timeout
+ batch_attempt_timeout: timeout for each individual request, in seconds.
+ Defaults to the Table's default_mutate_rows_attempt_timeout.
+ If None, defaults to batch_operation_timeout.
+ batch_retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_mutate_rows_retryable_errors.
+ Returns:
+ MutationsBatcher: a MutationsBatcher context manager that can batch requests
+ """
+ return CrossSync._Sync_Impl.MutationsBatcher(
+ self,
+ flush_interval=flush_interval,
+ flush_limit_mutation_count=flush_limit_mutation_count,
+ flush_limit_bytes=flush_limit_bytes,
+ flow_control_max_mutation_count=flow_control_max_mutation_count,
+ flow_control_max_bytes=flow_control_max_bytes,
+ batch_operation_timeout=batch_operation_timeout,
+ batch_attempt_timeout=batch_attempt_timeout,
+ batch_retryable_errors=batch_retryable_errors,
+ )
+
+ def mutate_row(
+ self,
+ row_key: str | bytes,
+ mutations: list[Mutation] | Mutation,
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ ):
+ """Mutates a row atomically.
+
+ Cells already present in the row are left unchanged unless explicitly changed
+ by ``mutation``.
+
+ Idempotent operations (i.e, all mutations have an explicit timestamp) will be
+ retried on server failure. Non-idempotent operations will not.
+
+ Args:
+ row_key: the row to apply mutations to
+ mutations: the set of mutations to apply to the row
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Only idempotent mutations will be retried. Defaults to the Table's
+ default_retryable_errors.
+ Raises:
+ google.api_core.exceptions.DeadlineExceeded: raised after operation timeout
+ will be chained with a RetryExceptionGroup containing all
+ GoogleAPIError exceptions from any retries that failed
+ google.api_core.exceptions.GoogleAPIError: raised on non-idempotent operations that cannot be
+ safely retried.
+ ValueError: if invalid arguments are provided"""
+ (operation_timeout, attempt_timeout) = _get_timeouts(
+ operation_timeout, attempt_timeout, self
+ )
+ if not mutations:
+ raise ValueError("No mutations provided")
+ mutations_list = mutations if isinstance(mutations, list) else [mutations]
+ if all((mutation.is_idempotent() for mutation in mutations_list)):
+ predicate = retries.if_exception_type(
+ *_get_retryable_errors(retryable_errors, self)
+ )
+ else:
+ predicate = retries.if_exception_type()
+ sleep_generator = retries.exponential_sleep_generator(0.01, 2, 60)
+ target = partial(
+ self.client._gapic_client.mutate_row,
+ row_key=row_key.encode("utf-8") if isinstance(row_key, str) else row_key,
+ mutations=[mutation._to_pb() for mutation in mutations_list],
+ table_name=self.table_name,
+ app_profile_id=self.app_profile_id,
+ timeout=attempt_timeout,
+ retry=None,
+ )
+ return CrossSync._Sync_Impl.retry_target(
+ target,
+ predicate,
+ sleep_generator,
+ operation_timeout,
+ exception_factory=_retry_exception_factory,
+ )
+
+ def bulk_mutate_rows(
+ self,
+ mutation_entries: list[RowMutationEntry],
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ ):
+ """Applies mutations for multiple rows in a single batched request.
+
+ Each individual RowMutationEntry is applied atomically, but separate entries
+ may be applied in arbitrary order (even for entries targetting the same row)
+ In total, the row_mutations can contain at most 100000 individual mutations
+ across all entries
+
+ Idempotent entries (i.e., entries with mutations with explicit timestamps)
+ will be retried on failure. Non-idempotent will not, and will reported in a
+ raised exception group
+
+ Args:
+ mutation_entries: the batches of mutations to apply
+ Each entry will be applied atomically, but entries will be applied
+ in arbitrary order
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget.
+ Defaults to the Table's default_mutate_rows_operation_timeout
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ Defaults to the Table's default_mutate_rows_attempt_timeout.
+ If None, defaults to operation_timeout.
+ retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_mutate_rows_retryable_errors
+ Raises:
+ MutationsExceptionGroup: if one or more mutations fails
+ Contains details about any failed entries in .exceptions
+ ValueError: if invalid arguments are provided"""
+ (operation_timeout, attempt_timeout) = _get_timeouts(
+ operation_timeout, attempt_timeout, self
+ )
+ retryable_excs = _get_retryable_errors(retryable_errors, self)
+ operation = CrossSync._Sync_Impl._MutateRowsOperation(
+ self.client._gapic_client,
+ self,
+ mutation_entries,
+ operation_timeout,
+ attempt_timeout,
+ retryable_exceptions=retryable_excs,
+ )
+ operation.start()
+
+ def check_and_mutate_row(
+ self,
+ row_key: str | bytes,
+ predicate: RowFilter | None,
+ *,
+ true_case_mutations: Mutation | list[Mutation] | None = None,
+ false_case_mutations: Mutation | list[Mutation] | None = None,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ ) -> bool:
+ """Mutates a row atomically based on the output of a predicate filter
+
+ Non-idempotent operation: will not be retried
+
+ Args:
+ row_key: the key of the row to mutate
+ predicate: the filter to be applied to the contents of the specified row.
+ Depending on whether or not any results are yielded,
+ either true_case_mutations or false_case_mutations will be executed.
+ If None, checks that the row contains any values at all.
+ true_case_mutations:
+ Changes to be atomically applied to the specified row if
+ predicate yields at least one cell when
+ applied to row_key. Entries are applied in order,
+ meaning that earlier mutations can be masked by later
+ ones. Must contain at least one entry if
+ false_case_mutations is empty, and at most 100000.
+ false_case_mutations:
+ Changes to be atomically applied to the specified row if
+ predicate_filter does not yield any cells when
+ applied to row_key. Entries are applied in order,
+ meaning that earlier mutations can be masked by later
+ ones. Must contain at least one entry if
+ `true_case_mutations` is empty, and at most 100000.
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will not be retried. Defaults to the Table's default_operation_timeout
+ Returns:
+ bool indicating whether the predicate was true or false
+ Raises:
+ google.api_core.exceptions.GoogleAPIError: exceptions from grpc call"""
+ (operation_timeout, _) = _get_timeouts(operation_timeout, None, self)
+ if true_case_mutations is not None and (
+ not isinstance(true_case_mutations, list)
+ ):
+ true_case_mutations = [true_case_mutations]
+ true_case_list = [m._to_pb() for m in true_case_mutations or []]
+ if false_case_mutations is not None and (
+ not isinstance(false_case_mutations, list)
+ ):
+ false_case_mutations = [false_case_mutations]
+ false_case_list = [m._to_pb() for m in false_case_mutations or []]
+ result = self.client._gapic_client.check_and_mutate_row(
+ true_mutations=true_case_list,
+ false_mutations=false_case_list,
+ predicate_filter=predicate._to_pb() if predicate is not None else None,
+ row_key=row_key.encode("utf-8") if isinstance(row_key, str) else row_key,
+ table_name=self.table_name,
+ app_profile_id=self.app_profile_id,
+ timeout=operation_timeout,
+ retry=None,
+ )
+ return result.predicate_matched
+
+ def read_modify_write_row(
+ self,
+ row_key: str | bytes,
+ rules: ReadModifyWriteRule | list[ReadModifyWriteRule],
+ *,
+ operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.DEFAULT,
+ ) -> Row:
+ """Reads and modifies a row atomically according to input ReadModifyWriteRules,
+ and returns the contents of all modified cells
+
+ The new value for the timestamp is the greater of the existing timestamp or
+ the current server time.
+
+ Non-idempotent operation: will not be retried
+
+ Args:
+ row_key: the key of the row to apply read/modify/write rules to
+ rules: A rule or set of rules to apply to the row.
+ Rules are applied in order, meaning that earlier rules will affect the
+ results of later ones.
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will not be retried.
+ Defaults to the Table's default_operation_timeout.
+ Returns:
+ Row: a Row containing cell data that was modified as part of the operation
+ Raises:
+ google.api_core.exceptions.GoogleAPIError: exceptions from grpc call
+ ValueError: if invalid arguments are provided"""
+ (operation_timeout, _) = _get_timeouts(operation_timeout, None, self)
+ if operation_timeout <= 0:
+ raise ValueError("operation_timeout must be greater than 0")
+ if rules is not None and (not isinstance(rules, list)):
+ rules = [rules]
+ if not rules:
+ raise ValueError("rules must contain at least one item")
+ result = self.client._gapic_client.read_modify_write_row(
+ rules=[rule._to_pb() for rule in rules],
+ row_key=row_key.encode("utf-8") if isinstance(row_key, str) else row_key,
+ table_name=self.table_name,
+ app_profile_id=self.app_profile_id,
+ timeout=operation_timeout,
+ retry=None,
+ )
+ return Row._from_pb(result.row)
+
+ def close(self):
+ """Called to close the Table instance and release any resources held by it."""
+ if self._register_instance_future:
+ self._register_instance_future.cancel()
+ self.client._remove_instance_registration(self.instance_id, self)
+
+ def __enter__(self):
+ """Implement async context manager protocol
+
+ Ensure registration task has time to run, so that
+ grpc channels will be warmed for the specified instance"""
+ if self._register_instance_future:
+ self._register_instance_future
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ """Implement async context manager protocol
+
+ Unregister this instance with the client, so that
+ grpc channels will no longer be warmed"""
+ self.close()
diff --git a/google/cloud/bigtable/data/_sync_autogen/mutations_batcher.py b/google/cloud/bigtable/data/_sync_autogen/mutations_batcher.py
new file mode 100644
index 000000000..2e4237b74
--- /dev/null
+++ b/google/cloud/bigtable/data/_sync_autogen/mutations_batcher.py
@@ -0,0 +1,449 @@
+# Copyright 2024 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.
+#
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+from typing import Sequence, TYPE_CHECKING, cast
+import atexit
+import warnings
+from collections import deque
+import concurrent.futures
+from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+from google.cloud.bigtable.data.exceptions import FailedMutationEntryError
+from google.cloud.bigtable.data._helpers import _get_retryable_errors
+from google.cloud.bigtable.data._helpers import _get_timeouts
+from google.cloud.bigtable.data._helpers import TABLE_DEFAULT
+from google.cloud.bigtable.data.mutations import _MUTATE_ROWS_REQUEST_MUTATION_LIMIT
+from google.cloud.bigtable.data.mutations import Mutation
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+if TYPE_CHECKING:
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+ from google.cloud.bigtable.data._sync_autogen.client import Table as TableType
+_MB_SIZE = 1024 * 1024
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("_FlowControl")
+class _FlowControl:
+ """
+ Manages flow control for batched mutations. Mutations are registered against
+ the FlowControl object before being sent, which will block if size or count
+ limits have reached capacity. As mutations completed, they are removed from
+ the FlowControl object, which will notify any blocked requests that there
+ is additional capacity.
+
+ Flow limits are not hard limits. If a single mutation exceeds the configured
+ limits, it will be allowed as a single batch when the capacity is available.
+
+ Args:
+ max_mutation_count: maximum number of mutations to send in a single rpc.
+ This corresponds to individual mutations in a single RowMutationEntry.
+ max_mutation_bytes: maximum number of bytes to send in a single rpc.
+ Raises:
+ ValueError: if max_mutation_count or max_mutation_bytes is less than 0
+ """
+
+ def __init__(self, max_mutation_count: int, max_mutation_bytes: int):
+ self._max_mutation_count = max_mutation_count
+ self._max_mutation_bytes = max_mutation_bytes
+ if self._max_mutation_count < 1:
+ raise ValueError("max_mutation_count must be greater than 0")
+ if self._max_mutation_bytes < 1:
+ raise ValueError("max_mutation_bytes must be greater than 0")
+ self._capacity_condition = CrossSync._Sync_Impl.Condition()
+ self._in_flight_mutation_count = 0
+ self._in_flight_mutation_bytes = 0
+
+ def _has_capacity(self, additional_count: int, additional_size: int) -> bool:
+ """Checks if there is capacity to send a new entry with the given size and count
+
+ FlowControl limits are not hard limits. If a single mutation exceeds
+ the configured flow limits, it will be sent in a single batch when
+ previous batches have completed.
+
+ Args:
+ additional_count: number of mutations in the pending entry
+ additional_size: size of the pending entry
+ Returns:
+ bool: True if there is capacity to send the pending entry, False otherwise
+ """
+ acceptable_size = max(self._max_mutation_bytes, additional_size)
+ acceptable_count = max(self._max_mutation_count, additional_count)
+ new_size = self._in_flight_mutation_bytes + additional_size
+ new_count = self._in_flight_mutation_count + additional_count
+ return new_size <= acceptable_size and new_count <= acceptable_count
+
+ def remove_from_flow(
+ self, mutations: RowMutationEntry | list[RowMutationEntry]
+ ) -> None:
+ """Removes mutations from flow control. This method should be called once
+ for each mutation that was sent to add_to_flow, after the corresponding
+ operation is complete.
+
+ Args:
+ mutations: mutation or list of mutations to remove from flow control"""
+ if not isinstance(mutations, list):
+ mutations = [mutations]
+ total_count = sum((len(entry.mutations) for entry in mutations))
+ total_size = sum((entry.size() for entry in mutations))
+ self._in_flight_mutation_count -= total_count
+ self._in_flight_mutation_bytes -= total_size
+ with self._capacity_condition:
+ self._capacity_condition.notify_all()
+
+ def add_to_flow(self, mutations: RowMutationEntry | list[RowMutationEntry]):
+ """Generator function that registers mutations with flow control. As mutations
+ are accepted into the flow control, they are yielded back to the caller,
+ to be sent in a batch. If the flow control is at capacity, the generator
+ will block until there is capacity available.
+
+ Args:
+ mutations: list mutations to break up into batches
+ Yields:
+ list[RowMutationEntry]:
+ list of mutations that have reserved space in the flow control.
+ Each batch contains at least one mutation."""
+ if not isinstance(mutations, list):
+ mutations = [mutations]
+ start_idx = 0
+ end_idx = 0
+ while end_idx < len(mutations):
+ start_idx = end_idx
+ batch_mutation_count = 0
+ with self._capacity_condition:
+ while end_idx < len(mutations):
+ next_entry = mutations[end_idx]
+ next_size = next_entry.size()
+ next_count = len(next_entry.mutations)
+ if (
+ self._has_capacity(next_count, next_size)
+ and batch_mutation_count + next_count
+ <= _MUTATE_ROWS_REQUEST_MUTATION_LIMIT
+ ):
+ end_idx += 1
+ batch_mutation_count += next_count
+ self._in_flight_mutation_bytes += next_size
+ self._in_flight_mutation_count += next_count
+ elif start_idx != end_idx:
+ break
+ else:
+ self._capacity_condition.wait_for(
+ lambda: self._has_capacity(next_count, next_size)
+ )
+ yield mutations[start_idx:end_idx]
+
+
+class MutationsBatcher:
+ """
+ Allows users to send batches using context manager API:
+
+ Runs mutate_row, mutate_rows, and check_and_mutate_row internally, combining
+ to use as few network requests as required
+
+ Will automatically flush the batcher:
+ - every flush_interval seconds
+ - after queue size reaches flush_limit_mutation_count
+ - after queue reaches flush_limit_bytes
+ - when batcher is closed or destroyed
+
+ Args:
+ table: Table to preform rpc calls
+ flush_interval: Automatically flush every flush_interval seconds.
+ If None, no time-based flushing is performed.
+ flush_limit_mutation_count: Flush immediately after flush_limit_mutation_count
+ mutations are added across all entries. If None, this limit is ignored.
+ flush_limit_bytes: Flush immediately after flush_limit_bytes bytes are added.
+ flow_control_max_mutation_count: Maximum number of inflight mutations.
+ flow_control_max_bytes: Maximum number of inflight bytes.
+ batch_operation_timeout: timeout for each mutate_rows operation, in seconds.
+ If TABLE_DEFAULT, defaults to the Table's default_mutate_rows_operation_timeout.
+ batch_attempt_timeout: timeout for each individual request, in seconds.
+ If TABLE_DEFAULT, defaults to the Table's default_mutate_rows_attempt_timeout.
+ If None, defaults to batch_operation_timeout.
+ batch_retryable_errors: a list of errors that will be retried if encountered.
+ Defaults to the Table's default_mutate_rows_retryable_errors.
+ """
+
+ def __init__(
+ self,
+ table: TableType,
+ *,
+ flush_interval: float | None = 5,
+ flush_limit_mutation_count: int | None = 1000,
+ flush_limit_bytes: int = 20 * _MB_SIZE,
+ flow_control_max_mutation_count: int = 100000,
+ flow_control_max_bytes: int = 100 * _MB_SIZE,
+ batch_operation_timeout: float | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ batch_attempt_timeout: float | None | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ batch_retryable_errors: Sequence[type[Exception]]
+ | TABLE_DEFAULT = TABLE_DEFAULT.MUTATE_ROWS,
+ ):
+ (self._operation_timeout, self._attempt_timeout) = _get_timeouts(
+ batch_operation_timeout, batch_attempt_timeout, table
+ )
+ self._retryable_errors: list[type[Exception]] = _get_retryable_errors(
+ batch_retryable_errors, table
+ )
+ self._closed = CrossSync._Sync_Impl.Event()
+ self._table = table
+ self._staged_entries: list[RowMutationEntry] = []
+ (self._staged_count, self._staged_bytes) = (0, 0)
+ self._flow_control = CrossSync._Sync_Impl._FlowControl(
+ flow_control_max_mutation_count, flow_control_max_bytes
+ )
+ self._flush_limit_bytes = flush_limit_bytes
+ self._flush_limit_count = (
+ flush_limit_mutation_count
+ if flush_limit_mutation_count is not None
+ else float("inf")
+ )
+ self._sync_rpc_executor = (
+ concurrent.futures.ThreadPoolExecutor(max_workers=8)
+ if not CrossSync._Sync_Impl.is_async
+ else None
+ )
+ self._sync_flush_executor = (
+ concurrent.futures.ThreadPoolExecutor(max_workers=4)
+ if not CrossSync._Sync_Impl.is_async
+ else None
+ )
+ self._flush_timer = CrossSync._Sync_Impl.create_task(
+ self._timer_routine, flush_interval, sync_executor=self._sync_flush_executor
+ )
+ self._flush_jobs: set[CrossSync._Sync_Impl.Future[None]] = set()
+ self._entries_processed_since_last_raise: int = 0
+ self._exceptions_since_last_raise: int = 0
+ self._exception_list_limit: int = 10
+ self._oldest_exceptions: list[Exception] = []
+ self._newest_exceptions: deque[Exception] = deque(
+ maxlen=self._exception_list_limit
+ )
+ atexit.register(self._on_exit)
+
+ def _timer_routine(self, interval: float | None) -> None:
+ """Set up a background task to flush the batcher every interval seconds
+
+ If interval is None, an empty future is returned
+
+ Args:
+ flush_interval: Automatically flush every flush_interval seconds.
+ If None, no time-based flushing is performed."""
+ if not interval or interval <= 0:
+ return None
+ while not self._closed.is_set():
+ CrossSync._Sync_Impl.event_wait(
+ self._closed, timeout=interval, async_break_early=False
+ )
+ if not self._closed.is_set() and self._staged_entries:
+ self._schedule_flush()
+
+ def append(self, mutation_entry: RowMutationEntry):
+ """Add a new set of mutations to the internal queue
+
+ Args:
+ mutation_entry: new entry to add to flush queue
+ Raises:
+ RuntimeError: if batcher is closed
+ ValueError: if an invalid mutation type is added"""
+ if self._closed.is_set():
+ raise RuntimeError("Cannot append to closed MutationsBatcher")
+ if isinstance(cast(Mutation, mutation_entry), Mutation):
+ raise ValueError(
+ f"invalid mutation type: {type(mutation_entry).__name__}. Only RowMutationEntry objects are supported by batcher"
+ )
+ self._staged_entries.append(mutation_entry)
+ self._staged_count += len(mutation_entry.mutations)
+ self._staged_bytes += mutation_entry.size()
+ if (
+ self._staged_count >= self._flush_limit_count
+ or self._staged_bytes >= self._flush_limit_bytes
+ ):
+ self._schedule_flush()
+ CrossSync._Sync_Impl.yield_to_event_loop()
+
+ def _schedule_flush(self) -> CrossSync._Sync_Impl.Future[None] | None:
+ """Update the flush task to include the latest staged entries
+
+ Returns:
+ Future[None] | None:
+ future representing the background task, if started"""
+ if self._staged_entries:
+ (entries, self._staged_entries) = (self._staged_entries, [])
+ (self._staged_count, self._staged_bytes) = (0, 0)
+ new_task = CrossSync._Sync_Impl.create_task(
+ self._flush_internal, entries, sync_executor=self._sync_flush_executor
+ )
+ if not new_task.done():
+ self._flush_jobs.add(new_task)
+ new_task.add_done_callback(self._flush_jobs.remove)
+ return new_task
+ return None
+
+ def _flush_internal(self, new_entries: list[RowMutationEntry]):
+ """Flushes a set of mutations to the server, and updates internal state
+
+ Args:
+ new_entries list of RowMutationEntry objects to flush"""
+ in_process_requests: list[
+ CrossSync._Sync_Impl.Future[list[FailedMutationEntryError]]
+ ] = []
+ for batch in self._flow_control.add_to_flow(new_entries):
+ batch_task = CrossSync._Sync_Impl.create_task(
+ self._execute_mutate_rows, batch, sync_executor=self._sync_rpc_executor
+ )
+ in_process_requests.append(batch_task)
+ found_exceptions = self._wait_for_batch_results(*in_process_requests)
+ self._entries_processed_since_last_raise += len(new_entries)
+ self._add_exceptions(found_exceptions)
+
+ def _execute_mutate_rows(
+ self, batch: list[RowMutationEntry]
+ ) -> list[FailedMutationEntryError]:
+ """Helper to execute mutation operation on a batch
+
+ Args:
+ batch: list of RowMutationEntry objects to send to server
+ timeout: timeout in seconds. Used as operation_timeout and attempt_timeout.
+ If not given, will use table defaults
+ Returns:
+ list[FailedMutationEntryError]:
+ list of FailedMutationEntryError objects for mutations that failed.
+ FailedMutationEntryError objects will not contain index information"""
+ try:
+ operation = CrossSync._Sync_Impl._MutateRowsOperation(
+ self._table.client._gapic_client,
+ self._table,
+ batch,
+ operation_timeout=self._operation_timeout,
+ attempt_timeout=self._attempt_timeout,
+ retryable_exceptions=self._retryable_errors,
+ )
+ operation.start()
+ except MutationsExceptionGroup as e:
+ for subexc in e.exceptions:
+ subexc.index = None
+ return list(e.exceptions)
+ finally:
+ self._flow_control.remove_from_flow(batch)
+ return []
+
+ def _add_exceptions(self, excs: list[Exception]):
+ """Add new list of exceptions to internal store. To avoid unbounded memory,
+ the batcher will store the first and last _exception_list_limit exceptions,
+ and discard any in between.
+
+ Args:
+ excs: list of exceptions to add to the internal store"""
+ self._exceptions_since_last_raise += len(excs)
+ if excs and len(self._oldest_exceptions) < self._exception_list_limit:
+ addition_count = self._exception_list_limit - len(self._oldest_exceptions)
+ self._oldest_exceptions.extend(excs[:addition_count])
+ excs = excs[addition_count:]
+ if excs:
+ self._newest_exceptions.extend(excs[-self._exception_list_limit :])
+
+ def _raise_exceptions(self):
+ """Raise any unreported exceptions from background flush operations
+
+ Raises:
+ MutationsExceptionGroup: exception group with all unreported exceptions"""
+ if self._oldest_exceptions or self._newest_exceptions:
+ (oldest, self._oldest_exceptions) = (self._oldest_exceptions, [])
+ newest = list(self._newest_exceptions)
+ self._newest_exceptions.clear()
+ (entry_count, self._entries_processed_since_last_raise) = (
+ self._entries_processed_since_last_raise,
+ 0,
+ )
+ (exc_count, self._exceptions_since_last_raise) = (
+ self._exceptions_since_last_raise,
+ 0,
+ )
+ raise MutationsExceptionGroup.from_truncated_lists(
+ first_list=oldest,
+ last_list=newest,
+ total_excs=exc_count,
+ entry_count=entry_count,
+ )
+
+ def __enter__(self):
+ """Allow use of context manager API"""
+ return self
+
+ def __exit__(self, exc_type, exc, tb):
+ """Allow use of context manager API.
+
+ Flushes the batcher and cleans up resources."""
+ self.close()
+
+ @property
+ def closed(self) -> bool:
+ """Returns:
+ - True if the batcher is closed, False otherwise"""
+ return self._closed.is_set()
+
+ def close(self):
+ """Flush queue and clean up resources"""
+ self._closed.set()
+ self._flush_timer.cancel()
+ self._schedule_flush()
+ if self._sync_flush_executor:
+ with self._sync_flush_executor:
+ self._sync_flush_executor.shutdown(wait=True)
+ if self._sync_rpc_executor:
+ with self._sync_rpc_executor:
+ self._sync_rpc_executor.shutdown(wait=True)
+ CrossSync._Sync_Impl.wait([*self._flush_jobs, self._flush_timer])
+ atexit.unregister(self._on_exit)
+ self._raise_exceptions()
+
+ def _on_exit(self):
+ """Called when program is exited. Raises warning if unflushed mutations remain"""
+ if not self._closed.is_set() and self._staged_entries:
+ warnings.warn(
+ f"MutationsBatcher for table {self._table.table_name} was not closed. {len(self._staged_entries)} Unflushed mutations will not be sent to the server."
+ )
+
+ @staticmethod
+ def _wait_for_batch_results(
+ *tasks: CrossSync._Sync_Impl.Future[list[FailedMutationEntryError]]
+ | CrossSync._Sync_Impl.Future[None],
+ ) -> list[Exception]:
+ """Takes in a list of futures representing _execute_mutate_rows tasks,
+ waits for them to complete, and returns a list of errors encountered.
+
+ Args:
+ *tasks: futures representing _execute_mutate_rows or _flush_internal tasks
+ Returns:
+ list[Exception]:
+ list of Exceptions encountered by any of the tasks. Errors are expected
+ to be FailedMutationEntryError, representing a failed mutation operation.
+ If a task fails with a different exception, it will be included in the
+ output list. Successful tasks will not be represented in the output list.
+ """
+ if not tasks:
+ return []
+ exceptions: list[Exception] = []
+ for task in tasks:
+ try:
+ exc_list = task.result()
+ if exc_list:
+ for exc in exc_list:
+ exc.index = None
+ exceptions.extend(exc_list)
+ except Exception as e:
+ exceptions.append(e)
+ return exceptions
diff --git a/google/cloud/bigtable/data/exceptions.py b/google/cloud/bigtable/data/exceptions.py
index 95cd44f2c..62f0b62fc 100644
--- a/google/cloud/bigtable/data/exceptions.py
+++ b/google/cloud/bigtable/data/exceptions.py
@@ -41,6 +41,21 @@ class _RowSetComplete(Exception):
pass
+class _ResetRow(Exception): # noqa: F811
+ """
+ Internal exception for _ReadRowsOperation
+
+ Denotes that the server sent a reset_row marker, telling the client to drop
+ all previous chunks for row_key and re-read from the beginning.
+
+ Args:
+ chunk: the reset_row chunk
+ """
+
+ def __init__(self, chunk):
+ self.chunk = chunk
+
+
class _MutateRowsIncomplete(RuntimeError):
"""
Exception raised when a mutate_rows call has unfinished work.
diff --git a/google/cloud/bigtable/data/execute_query/__init__.py b/google/cloud/bigtable/data/execute_query/__init__.py
index 94af7d1cd..31fd5e3cc 100644
--- a/google/cloud/bigtable/data/execute_query/__init__.py
+++ b/google/cloud/bigtable/data/execute_query/__init__.py
@@ -15,6 +15,9 @@
from google.cloud.bigtable.data.execute_query._async.execute_query_iterator import (
ExecuteQueryIteratorAsync,
)
+from google.cloud.bigtable.data.execute_query._sync_autogen.execute_query_iterator import (
+ ExecuteQueryIterator,
+)
from google.cloud.bigtable.data.execute_query.metadata import (
Metadata,
ProtoMetadata,
@@ -25,7 +28,10 @@
QueryResultRow,
Struct,
)
+from google.cloud.bigtable.data._cross_sync import CrossSync
+CrossSync.add_mapping("ExecuteQueryIterator", ExecuteQueryIteratorAsync)
+CrossSync._Sync_Impl.add_mapping("ExecuteQueryIterator", ExecuteQueryIterator)
__all__ = [
"ExecuteQueryValueType",
@@ -35,4 +41,5 @@
"Metadata",
"ProtoMetadata",
"ExecuteQueryIteratorAsync",
+ "ExecuteQueryIterator",
]
diff --git a/google/cloud/bigtable/data/execute_query/_async/execute_query_iterator.py b/google/cloud/bigtable/data/execute_query/_async/execute_query_iterator.py
index 32081939b..66f264610 100644
--- a/google/cloud/bigtable/data/execute_query/_async/execute_query_iterator.py
+++ b/google/cloud/bigtable/data/execute_query/_async/execute_query_iterator.py
@@ -14,12 +14,9 @@
from __future__ import annotations
-import asyncio
from typing import (
Any,
- AsyncIterator,
Dict,
- List,
Optional,
Sequence,
Tuple,
@@ -44,48 +41,60 @@
ExecuteQueryRequest as ExecuteQueryRequestPB,
)
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
if TYPE_CHECKING:
- from google.cloud.bigtable.data import BigtableDataClientAsync
+ if CrossSync.is_async:
+ from google.cloud.bigtable.data import BigtableDataClientAsync as DataClientType
+ else:
+ from google.cloud.bigtable.data import BigtableDataClient as DataClientType
+__CROSS_SYNC_OUTPUT__ = (
+ "google.cloud.bigtable.data.execute_query._sync_autogen.execute_query_iterator"
+)
-class ExecuteQueryIteratorAsync:
- """
- ExecuteQueryIteratorAsync handles collecting streaming responses from the
- ExecuteQuery RPC and parsing them to QueryResultRows.
-
- ExecuteQueryIteratorAsync implements Asynchronous Iterator interface and can
- be used with "async for" syntax. It is also a context manager.
-
- It is **not thread-safe**. It should not be used by multiple asyncio Tasks.
-
- Args:
- client: bigtable client
- instance_id: id of the instance on which the query is executed
- request_body: dict representing the body of the ExecuteQueryRequest
- attempt_timeout: the time budget for the entire operation, in seconds.
- Failed requests will be retried within the budget.
- Defaults to 600 seconds.
- operation_timeout: the time budget for an individual network request, in seconds.
- If it takes longer than this time to complete, the request will be cancelled with
- a DeadlineExceeded exception, and a retry will be attempted.
- Defaults to the 20 seconds. If None, defaults to operation_timeout.
- req_metadata: metadata used while sending the gRPC request
- retryable_excs: a list of errors that will be retried if encountered.
- Raises:
- RuntimeError: if the instance is not created within an async event loop context.
- """
+@CrossSync.convert_class(sync_name="ExecuteQueryIterator")
+class ExecuteQueryIteratorAsync:
+ @CrossSync.convert(
+ docstring_format_vars={
+ "NO_LOOP": (
+ "RuntimeError: if the instance is not created within an async event loop context.",
+ "None",
+ ),
+ "TASK_OR_THREAD": ("asyncio Tasks", "threads"),
+ }
+ )
def __init__(
self,
- client: BigtableDataClientAsync,
+ client: DataClientType,
instance_id: str,
app_profile_id: Optional[str],
request_body: Dict[str, Any],
attempt_timeout: float | None,
operation_timeout: float,
- req_metadata: Sequence[Tuple[str, str]],
- retryable_excs: List[type[Exception]],
+ req_metadata: Sequence[Tuple[str, str]] = (),
+ retryable_excs: Sequence[type[Exception]] = (),
) -> None:
+ """
+ Collects responses from ExecuteQuery requests and parses them into QueryResultRows.
+
+ It is **not thread-safe**. It should not be used by multiple {TASK_OR_THREAD}.
+
+ Args:
+ client: bigtable client
+ instance_id: id of the instance on which the query is executed
+ request_body: dict representing the body of the ExecuteQueryRequest
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget
+ req_metadata: metadata used while sending the gRPC request
+ retryable_excs: a list of errors that will be retried if encountered.
+ Raises:
+ {NO_LOOP}
+ """
self._table_name = None
self._app_profile_id = app_profile_id
self._client = client
@@ -99,7 +108,7 @@ def __init__(
self._attempt_timeout_gen = _attempt_timeout_generator(
attempt_timeout, operation_timeout
)
- self._async_stream = retries.retry_target_stream_async(
+ self._stream = CrossSync.retry_target_stream(
self._make_request_with_resume_token,
retries.if_exception_type(*retryable_excs),
retries.exponential_sleep_generator(0.01, 60, multiplier=2),
@@ -109,8 +118,11 @@ def __init__(
self._req_metadata = req_metadata
try:
- self._register_instance_task = asyncio.create_task(
- self._client._register_instance(instance_id, self)
+ self._register_instance_task = CrossSync.create_task(
+ self._client._register_instance,
+ instance_id,
+ self,
+ sync_executor=self._client._executor,
)
except RuntimeError as e:
raise RuntimeError(
@@ -132,6 +144,7 @@ def table_name(self) -> Optional[str]:
"""Returns the table_name of the iterator."""
return self._table_name
+ @CrossSync.convert
async def _make_request_with_resume_token(self):
"""
perfoms the rpc call using the correct resume token.
@@ -150,23 +163,25 @@ async def _make_request_with_resume_token(self):
retry=None,
)
- async def _await_metadata(self) -> None:
+ @CrossSync.convert(replace_symbols={"__anext__": "__next__"})
+ async def _fetch_metadata(self) -> None:
"""
If called before the first response was recieved, the first response
- is awaited as part of this call.
+ is retrieved as part of this call.
"""
if self._byte_cursor.metadata is None:
- metadata_msg = await self._async_stream.__anext__()
+ metadata_msg = await self._stream.__anext__()
self._byte_cursor.consume_metadata(metadata_msg)
- async def _next_impl(self) -> AsyncIterator[QueryResultRow]:
+ @CrossSync.convert
+ async def _next_impl(self) -> CrossSync.Iterator[QueryResultRow]:
"""
Generator wrapping the response stream which parses the stream results
and returns full `QueryResultRow`s.
"""
- await self._await_metadata()
+ await self._fetch_metadata()
- async for response in self._async_stream:
+ async for response in self._stream:
try:
bytes_to_parse = self._byte_cursor.consume(response)
if bytes_to_parse is None:
@@ -185,14 +200,17 @@ async def _next_impl(self) -> AsyncIterator[QueryResultRow]:
yield result
await self.close()
+ @CrossSync.convert(sync_name="__next__", replace_symbols={"__anext__": "__next__"})
async def __anext__(self) -> QueryResultRow:
if self._is_closed:
- raise StopAsyncIteration
+ raise CrossSync.StopIteration
return await self._result_generator.__anext__()
+ @CrossSync.convert(sync_name="__iter__")
def __aiter__(self):
return self
+ @CrossSync.convert
async def metadata(self) -> Optional[Metadata]:
"""
Returns query metadata from the server or None if the iterator was
@@ -203,11 +221,12 @@ async def metadata(self) -> Optional[Metadata]:
# Metadata should be present in the first response in a stream.
if self._byte_cursor.metadata is None:
try:
- await self._await_metadata()
- except StopIteration:
+ await self._fetch_metadata()
+ except CrossSync.StopIteration:
return None
return self._byte_cursor.metadata
+ @CrossSync.convert
async def close(self) -> None:
"""
Cancel all background tasks. Should be called all rows were processed.
diff --git a/google/cloud/bigtable/data/execute_query/_sync_autogen/execute_query_iterator.py b/google/cloud/bigtable/data/execute_query/_sync_autogen/execute_query_iterator.py
new file mode 100644
index 000000000..854148ff3
--- /dev/null
+++ b/google/cloud/bigtable/data/execute_query/_sync_autogen/execute_query_iterator.py
@@ -0,0 +1,186 @@
+# Copyright 2024 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.
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+from typing import Any, Dict, Optional, Sequence, Tuple, TYPE_CHECKING
+from google.api_core import retry as retries
+from google.cloud.bigtable.data.execute_query._byte_cursor import _ByteCursor
+from google.cloud.bigtable.data._helpers import (
+ _attempt_timeout_generator,
+ _retry_exception_factory,
+)
+from google.cloud.bigtable.data.exceptions import InvalidExecuteQueryResponse
+from google.cloud.bigtable.data.execute_query.values import QueryResultRow
+from google.cloud.bigtable.data.execute_query.metadata import Metadata, ProtoMetadata
+from google.cloud.bigtable.data.execute_query._reader import (
+ _QueryResultRowReader,
+ _Reader,
+)
+from google.cloud.bigtable_v2.types.bigtable import (
+ ExecuteQueryRequest as ExecuteQueryRequestPB,
+)
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+if TYPE_CHECKING:
+ from google.cloud.bigtable.data import BigtableDataClient as DataClientType
+
+
+class ExecuteQueryIterator:
+ def __init__(
+ self,
+ client: DataClientType,
+ instance_id: str,
+ app_profile_id: Optional[str],
+ request_body: Dict[str, Any],
+ attempt_timeout: float | None,
+ operation_timeout: float,
+ req_metadata: Sequence[Tuple[str, str]] = (),
+ retryable_excs: Sequence[type[Exception]] = (),
+ ) -> None:
+ """Collects responses from ExecuteQuery requests and parses them into QueryResultRows.
+
+ It is **not thread-safe**. It should not be used by multiple threads.
+
+ Args:
+ client: bigtable client
+ instance_id: id of the instance on which the query is executed
+ request_body: dict representing the body of the ExecuteQueryRequest
+ attempt_timeout: the time budget for an individual network request, in seconds.
+ If it takes longer than this time to complete, the request will be cancelled with
+ a DeadlineExceeded exception, and a retry will be attempted.
+ operation_timeout: the time budget for the entire operation, in seconds.
+ Failed requests will be retried within the budget
+ req_metadata: metadata used while sending the gRPC request
+ retryable_excs: a list of errors that will be retried if encountered.
+ Raises:
+ None"""
+ self._table_name = None
+ self._app_profile_id = app_profile_id
+ self._client = client
+ self._instance_id = instance_id
+ self._byte_cursor = _ByteCursor[ProtoMetadata]()
+ self._reader: _Reader[QueryResultRow] = _QueryResultRowReader(self._byte_cursor)
+ self._result_generator = self._next_impl()
+ self._register_instance_task = None
+ self._is_closed = False
+ self._request_body = request_body
+ self._attempt_timeout_gen = _attempt_timeout_generator(
+ attempt_timeout, operation_timeout
+ )
+ self._stream = CrossSync._Sync_Impl.retry_target_stream(
+ self._make_request_with_resume_token,
+ retries.if_exception_type(*retryable_excs),
+ retries.exponential_sleep_generator(0.01, 60, multiplier=2),
+ operation_timeout,
+ exception_factory=_retry_exception_factory,
+ )
+ self._req_metadata = req_metadata
+ try:
+ self._register_instance_task = CrossSync._Sync_Impl.create_task(
+ self._client._register_instance,
+ instance_id,
+ self,
+ sync_executor=self._client._executor,
+ )
+ except RuntimeError as e:
+ raise RuntimeError(
+ f"{self.__class__.__name__} must be created within an async event loop context."
+ ) from e
+
+ @property
+ def is_closed(self) -> bool:
+ """Returns True if the iterator is closed, False otherwise."""
+ return self._is_closed
+
+ @property
+ def app_profile_id(self) -> Optional[str]:
+ """Returns the app_profile_id of the iterator."""
+ return self._app_profile_id
+
+ @property
+ def table_name(self) -> Optional[str]:
+ """Returns the table_name of the iterator."""
+ return self._table_name
+
+ def _make_request_with_resume_token(self):
+ """perfoms the rpc call using the correct resume token."""
+ resume_token = self._byte_cursor.prepare_for_new_request()
+ request = ExecuteQueryRequestPB(
+ {**self._request_body, "resume_token": resume_token}
+ )
+ return self._client._gapic_client.execute_query(
+ request,
+ timeout=next(self._attempt_timeout_gen),
+ metadata=self._req_metadata,
+ retry=None,
+ )
+
+ def _fetch_metadata(self) -> None:
+ """If called before the first response was recieved, the first response
+ is retrieved as part of this call."""
+ if self._byte_cursor.metadata is None:
+ metadata_msg = self._stream.__next__()
+ self._byte_cursor.consume_metadata(metadata_msg)
+
+ def _next_impl(self) -> CrossSync._Sync_Impl.Iterator[QueryResultRow]:
+ """Generator wrapping the response stream which parses the stream results
+ and returns full `QueryResultRow`s."""
+ self._fetch_metadata()
+ for response in self._stream:
+ try:
+ bytes_to_parse = self._byte_cursor.consume(response)
+ if bytes_to_parse is None:
+ continue
+ results = self._reader.consume(bytes_to_parse)
+ if results is None:
+ continue
+ except ValueError as e:
+ raise InvalidExecuteQueryResponse(
+ "Invalid ExecuteQuery response received"
+ ) from e
+ for result in results:
+ yield result
+ self.close()
+
+ def __next__(self) -> QueryResultRow:
+ if self._is_closed:
+ raise CrossSync._Sync_Impl.StopIteration
+ return self._result_generator.__next__()
+
+ def __iter__(self):
+ return self
+
+ def metadata(self) -> Optional[Metadata]:
+ """Returns query metadata from the server or None if the iterator was
+ explicitly closed."""
+ if self._is_closed:
+ return None
+ if self._byte_cursor.metadata is None:
+ try:
+ self._fetch_metadata()
+ except CrossSync._Sync_Impl.StopIteration:
+ return None
+ return self._byte_cursor.metadata
+
+ def close(self) -> None:
+ """Cancel all background tasks. Should be called all rows were processed."""
+ if self._is_closed:
+ return
+ self._is_closed = True
+ if self._register_instance_task is not None:
+ self._register_instance_task.cancel()
+ self._client._remove_instance_registration(self._instance_id, self)
diff --git a/google/cloud/bigtable/data/mutations.py b/google/cloud/bigtable/data/mutations.py
index 335a15e12..2f4e441ed 100644
--- a/google/cloud/bigtable/data/mutations.py
+++ b/google/cloud/bigtable/data/mutations.py
@@ -366,3 +366,15 @@ def _from_dict(cls, input_dict: dict[str, Any]) -> RowMutationEntry:
Mutation._from_dict(mutation) for mutation in input_dict["mutations"]
],
)
+
+
+@dataclass
+class _EntryWithProto:
+ """
+ A dataclass to hold a RowMutationEntry and its corresponding proto representation.
+
+ Used in _MutateRowsOperation to avoid repeated conversion of RowMutationEntry to proto.
+ """
+
+ entry: RowMutationEntry
+ proto: types_pb.MutateRowsRequest.Entry
diff --git a/google/cloud/bigtable/gapic_version.py b/google/cloud/bigtable/gapic_version.py
index d56eed5c5..f0fcebfa4 100644
--- a/google/cloud/bigtable/gapic_version.py
+++ b/google/cloud/bigtable/gapic_version.py
@@ -13,4 +13,4 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
-__version__ = "2.26.0" # {x-release-please-version}
+__version__ = "2.27.0" # {x-release-please-version}
diff --git a/google/cloud/bigtable/table.py b/google/cloud/bigtable/table.py
index e3191a729..7429bd36f 100644
--- a/google/cloud/bigtable/table.py
+++ b/google/cloud/bigtable/table.py
@@ -533,7 +533,7 @@ def get_encryption_info(self):
for cluster_id, value_pb in table_pb.cluster_states.items()
}
- def read_row(self, row_key, filter_=None):
+ def read_row(self, row_key, filter_=None, retry=DEFAULT_RETRY_READ_ROWS):
"""Read a single row from this table.
For example:
@@ -550,6 +550,14 @@ def read_row(self, row_key, filter_=None):
:param filter_: (Optional) The filter to apply to the contents of the
row. If unset, returns the entire row.
+ :type retry: :class:`~google.api_core.retry.Retry`
+ :param retry:
+ (Optional) Retry delay and deadline arguments. To override, the
+ default value :attr:`DEFAULT_RETRY_READ_ROWS` can be used and
+ modified with the :meth:`~google.api_core.retry.Retry.with_delay`
+ method or the :meth:`~google.api_core.retry.Retry.with_deadline`
+ method.
+
:rtype: :class:`.PartialRowData`, :data:`NoneType `
:returns: The contents of the row if any chunks were returned in
the response, otherwise :data:`None`.
@@ -558,7 +566,9 @@ def read_row(self, row_key, filter_=None):
"""
row_set = RowSet()
row_set.add_row_key(row_key)
- result_iter = iter(self.read_rows(filter_=filter_, row_set=row_set))
+ result_iter = iter(
+ self.read_rows(filter_=filter_, row_set=row_set, retry=retry)
+ )
row = next(result_iter, None)
if next(result_iter, None) is not None:
raise ValueError("More than one row was returned.")
diff --git a/google/cloud/bigtable_admin/gapic_version.py b/google/cloud/bigtable_admin/gapic_version.py
index d56eed5c5..f0fcebfa4 100644
--- a/google/cloud/bigtable_admin/gapic_version.py
+++ b/google/cloud/bigtable_admin/gapic_version.py
@@ -13,4 +13,4 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
-__version__ = "2.26.0" # {x-release-please-version}
+__version__ = "2.27.0" # {x-release-please-version}
diff --git a/google/cloud/bigtable_admin_v2/gapic_version.py b/google/cloud/bigtable_admin_v2/gapic_version.py
index d56eed5c5..f0fcebfa4 100644
--- a/google/cloud/bigtable_admin_v2/gapic_version.py
+++ b/google/cloud/bigtable_admin_v2/gapic_version.py
@@ -13,4 +13,4 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
-__version__ = "2.26.0" # {x-release-please-version}
+__version__ = "2.27.0" # {x-release-please-version}
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/client.py b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/client.py
index b8173bf4b..b717eac8b 100644
--- a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/client.py
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/client.py
@@ -586,36 +586,6 @@ def _get_universe_domain(
raise ValueError("Universe Domain cannot be an empty string.")
return universe_domain
- @staticmethod
- def _compare_universes(
- client_universe: str, credentials: ga_credentials.Credentials
- ) -> bool:
- """Returns True iff the universe domains used by the client and credentials match.
-
- Args:
- client_universe (str): The universe domain configured via the client options.
- credentials (ga_credentials.Credentials): The credentials being used in the client.
-
- Returns:
- bool: True iff client_universe matches the universe in credentials.
-
- Raises:
- ValueError: when client_universe does not match the universe in credentials.
- """
-
- default_universe = BigtableInstanceAdminClient._DEFAULT_UNIVERSE
- credentials_universe = getattr(credentials, "universe_domain", default_universe)
-
- if client_universe != credentials_universe:
- raise ValueError(
- "The configured universe domain "
- f"({client_universe}) does not match the universe domain "
- f"found in the credentials ({credentials_universe}). "
- "If you haven't configured the universe domain explicitly, "
- f"`{default_universe}` is the default."
- )
- return True
-
def _validate_universe_domain(self):
"""Validates client's and credentials' universe domains are consistent.
@@ -625,13 +595,9 @@ def _validate_universe_domain(self):
Raises:
ValueError: If the configured universe domain is not valid.
"""
- self._is_universe_domain_valid = (
- self._is_universe_domain_valid
- or BigtableInstanceAdminClient._compare_universes(
- self.universe_domain, self.transport._credentials
- )
- )
- return self._is_universe_domain_valid
+
+ # NOTE (b/349488459): universe validation is disabled until further notice.
+ return True
@property
def api_endpoint(self):
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/README.rst b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/README.rst
new file mode 100644
index 000000000..9a01ee7c3
--- /dev/null
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/README.rst
@@ -0,0 +1,9 @@
+
+transport inheritance structure
+_______________________________
+
+`BigtableInstanceAdminTransport` is the ABC for all transports.
+- public child `BigtableInstanceAdminGrpcTransport` for sync gRPC transport (defined in `grpc.py`).
+- public child `BigtableInstanceAdminGrpcAsyncIOTransport` for async gRPC transport (defined in `grpc_asyncio.py`).
+- private child `_BaseBigtableInstanceAdminRestTransport` for base REST transport with inner classes `_BaseMETHOD` (defined in `rest_base.py`).
+- public child `BigtableInstanceAdminRestTransport` for sync REST transport with inner classes `METHOD` derived from the parent's corresponding `_BaseMETHOD` classes (defined in `rest.py`).
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/grpc_asyncio.py b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/grpc_asyncio.py
index 1fa85551c..716e14a86 100644
--- a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/grpc_asyncio.py
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/grpc_asyncio.py
@@ -13,6 +13,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
+import inspect
import warnings
from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
@@ -237,6 +238,9 @@ def __init__(
)
# Wrap messages. This must be done after self._grpc_channel exists
+ self._wrap_with_kind = (
+ "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters
+ )
self._prep_wrapped_messages(client_info)
@property
@@ -898,12 +902,12 @@ def list_hot_tablets(
def _prep_wrapped_messages(self, client_info):
"""Precompute the wrapped methods, overriding the base class method to use async wrappers."""
self._wrapped_methods = {
- self.create_instance: gapic_v1.method_async.wrap_method(
+ self.create_instance: self._wrap_method(
self.create_instance,
default_timeout=300.0,
client_info=client_info,
),
- self.get_instance: gapic_v1.method_async.wrap_method(
+ self.get_instance: self._wrap_method(
self.get_instance,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -918,7 +922,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.list_instances: gapic_v1.method_async.wrap_method(
+ self.list_instances: self._wrap_method(
self.list_instances,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -933,7 +937,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.update_instance: gapic_v1.method_async.wrap_method(
+ self.update_instance: self._wrap_method(
self.update_instance,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -948,7 +952,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.partial_update_instance: gapic_v1.method_async.wrap_method(
+ self.partial_update_instance: self._wrap_method(
self.partial_update_instance,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -963,17 +967,17 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.delete_instance: gapic_v1.method_async.wrap_method(
+ self.delete_instance: self._wrap_method(
self.delete_instance,
default_timeout=60.0,
client_info=client_info,
),
- self.create_cluster: gapic_v1.method_async.wrap_method(
+ self.create_cluster: self._wrap_method(
self.create_cluster,
default_timeout=60.0,
client_info=client_info,
),
- self.get_cluster: gapic_v1.method_async.wrap_method(
+ self.get_cluster: self._wrap_method(
self.get_cluster,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -988,7 +992,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.list_clusters: gapic_v1.method_async.wrap_method(
+ self.list_clusters: self._wrap_method(
self.list_clusters,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1003,7 +1007,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.update_cluster: gapic_v1.method_async.wrap_method(
+ self.update_cluster: self._wrap_method(
self.update_cluster,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1018,22 +1022,22 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.partial_update_cluster: gapic_v1.method_async.wrap_method(
+ self.partial_update_cluster: self._wrap_method(
self.partial_update_cluster,
default_timeout=None,
client_info=client_info,
),
- self.delete_cluster: gapic_v1.method_async.wrap_method(
+ self.delete_cluster: self._wrap_method(
self.delete_cluster,
default_timeout=60.0,
client_info=client_info,
),
- self.create_app_profile: gapic_v1.method_async.wrap_method(
+ self.create_app_profile: self._wrap_method(
self.create_app_profile,
default_timeout=60.0,
client_info=client_info,
),
- self.get_app_profile: gapic_v1.method_async.wrap_method(
+ self.get_app_profile: self._wrap_method(
self.get_app_profile,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1048,7 +1052,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.list_app_profiles: gapic_v1.method_async.wrap_method(
+ self.list_app_profiles: self._wrap_method(
self.list_app_profiles,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1063,7 +1067,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.update_app_profile: gapic_v1.method_async.wrap_method(
+ self.update_app_profile: self._wrap_method(
self.update_app_profile,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1078,12 +1082,12 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.delete_app_profile: gapic_v1.method_async.wrap_method(
+ self.delete_app_profile: self._wrap_method(
self.delete_app_profile,
default_timeout=60.0,
client_info=client_info,
),
- self.get_iam_policy: gapic_v1.method_async.wrap_method(
+ self.get_iam_policy: self._wrap_method(
self.get_iam_policy,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1098,12 +1102,12 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.set_iam_policy: gapic_v1.method_async.wrap_method(
+ self.set_iam_policy: self._wrap_method(
self.set_iam_policy,
default_timeout=60.0,
client_info=client_info,
),
- self.test_iam_permissions: gapic_v1.method_async.wrap_method(
+ self.test_iam_permissions: self._wrap_method(
self.test_iam_permissions,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1118,7 +1122,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.list_hot_tablets: gapic_v1.method_async.wrap_method(
+ self.list_hot_tablets: self._wrap_method(
self.list_hot_tablets,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1135,8 +1139,17 @@ def _prep_wrapped_messages(self, client_info):
),
}
+ def _wrap_method(self, func, *args, **kwargs):
+ if self._wrap_with_kind: # pragma: NO COVER
+ kwargs["kind"] = self.kind
+ return gapic_v1.method_async.wrap_method(func, *args, **kwargs)
+
def close(self):
return self.grpc_channel.close()
+ @property
+ def kind(self) -> str:
+ return "grpc_asyncio"
+
__all__ = ("BigtableInstanceAdminGrpcAsyncIOTransport",)
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest.py b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest.py
index e1737add1..45f08fa64 100644
--- a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest.py
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest.py
@@ -16,29 +16,21 @@
from google.auth.transport.requests import AuthorizedSession # type: ignore
import json # type: ignore
-import grpc # type: ignore
-from google.auth.transport.grpc import SslCredentials # type: ignore
from google.auth import credentials as ga_credentials # type: ignore
from google.api_core import exceptions as core_exceptions
from google.api_core import retry as retries
from google.api_core import rest_helpers
from google.api_core import rest_streaming
-from google.api_core import path_template
from google.api_core import gapic_v1
from google.protobuf import json_format
from google.api_core import operations_v1
+
from requests import __version__ as requests_version
import dataclasses
-import re
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
import warnings
-try:
- OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
-except AttributeError: # pragma: NO COVER
- OptionalRetry = Union[retries.Retry, object, None] # type: ignore
-
from google.cloud.bigtable_admin_v2.types import bigtable_instance_admin
from google.cloud.bigtable_admin_v2.types import instance
@@ -47,16 +39,20 @@
from google.protobuf import empty_pb2 # type: ignore
from google.longrunning import operations_pb2 # type: ignore
-from .base import (
- BigtableInstanceAdminTransport,
- DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO,
-)
+
+from .rest_base import _BaseBigtableInstanceAdminRestTransport
+from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
+
+try:
+ OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+except AttributeError: # pragma: NO COVER
+ OptionalRetry = Union[retries.Retry, object, None] # type: ignore
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
grpc_version=None,
- rest_version=requests_version,
+ rest_version=f"requests@{requests_version}",
)
@@ -699,8 +695,8 @@ class BigtableInstanceAdminRestStub:
_interceptor: BigtableInstanceAdminRestInterceptor
-class BigtableInstanceAdminRestTransport(BigtableInstanceAdminTransport):
- """REST backend transport for BigtableInstanceAdmin.
+class BigtableInstanceAdminRestTransport(_BaseBigtableInstanceAdminRestTransport):
+ """REST backend synchronous transport for BigtableInstanceAdmin.
Service for creating, configuring, and deleting Cloud
Bigtable Instances and Clusters. Provides access to the Instance
@@ -712,7 +708,6 @@ class BigtableInstanceAdminRestTransport(BigtableInstanceAdminTransport):
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
-
"""
def __init__(
@@ -766,21 +761,12 @@ def __init__(
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
- maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host)
- if maybe_url_match is None:
- raise ValueError(
- f"Unexpected hostname structure: {host}"
- ) # pragma: NO COVER
-
- url_match_items = maybe_url_match.groupdict()
-
- host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
-
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
always_use_jwt_access=always_use_jwt_access,
+ url_scheme=url_scheme,
api_audience=api_audience,
)
self._session = AuthorizedSession(
@@ -844,21 +830,35 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
# Return the client from cache.
return self._operations_client
- class _CreateAppProfile(BigtableInstanceAdminRestStub):
+ class _CreateAppProfile(
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateAppProfile,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateAppProfile")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "appProfileId": "",
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.CreateAppProfile")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -888,47 +888,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*}/appProfiles",
- "body": "app_profile",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateAppProfile._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_app_profile(
request, metadata
)
- pb_request = bigtable_instance_admin.CreateAppProfileRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseCreateAppProfile._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseCreateAppProfile._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseCreateAppProfile._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableInstanceAdminRestTransport._CreateAppProfile._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -944,21 +933,35 @@ def __call__(
resp = self._interceptor.post_create_app_profile(resp)
return resp
- class _CreateCluster(BigtableInstanceAdminRestStub):
+ class _CreateCluster(
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateCluster,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateCluster")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "clusterId": "",
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.CreateCluster")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -988,45 +991,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*}/clusters",
- "body": "cluster",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateCluster._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_cluster(request, metadata)
- pb_request = bigtable_instance_admin.CreateClusterRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseCreateCluster._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseCreateCluster._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseCreateCluster._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableInstanceAdminRestTransport._CreateCluster._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1040,19 +1030,35 @@ def __call__(
resp = self._interceptor.post_create_cluster(resp)
return resp
- class _CreateInstance(BigtableInstanceAdminRestStub):
+ class _CreateInstance(
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateInstance,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateInstance")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.CreateInstance")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1082,45 +1088,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*}/instances",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateInstance._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_instance(request, metadata)
- pb_request = bigtable_instance_admin.CreateInstanceRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseCreateInstance._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseCreateInstance._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseCreateInstance._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableInstanceAdminRestTransport._CreateInstance._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1134,21 +1127,34 @@ def __call__(
resp = self._interceptor.post_create_instance(resp)
return resp
- class _DeleteAppProfile(BigtableInstanceAdminRestStub):
+ class _DeleteAppProfile(
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteAppProfile,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteAppProfile")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "ignoreWarnings": False,
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.DeleteAppProfile")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1171,40 +1177,31 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*/appProfiles/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteAppProfile._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_app_profile(
request, metadata
)
- pb_request = bigtable_instance_admin.DeleteAppProfileRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseDeleteAppProfile._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseDeleteAppProfile._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = (
+ BigtableInstanceAdminRestTransport._DeleteAppProfile._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1212,19 +1209,34 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _DeleteCluster(BigtableInstanceAdminRestStub):
+ class _DeleteCluster(
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteCluster,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteCluster")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.DeleteCluster")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1247,38 +1259,27 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteCluster._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_cluster(request, metadata)
- pb_request = bigtable_instance_admin.DeleteClusterRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseDeleteCluster._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseDeleteCluster._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._DeleteCluster._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1286,19 +1287,34 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _DeleteInstance(BigtableInstanceAdminRestStub):
+ class _DeleteInstance(
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteInstance,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteInstance")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.DeleteInstance")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1321,38 +1337,27 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteInstance._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_instance(request, metadata)
- pb_request = bigtable_instance_admin.DeleteInstanceRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseDeleteInstance._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseDeleteInstance._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._DeleteInstance._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1360,19 +1365,34 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _GetAppProfile(BigtableInstanceAdminRestStub):
+ class _GetAppProfile(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetAppProfile,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetAppProfile")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.GetAppProfile")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1402,38 +1422,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*/appProfiles/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseGetAppProfile._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_app_profile(request, metadata)
- pb_request = bigtable_instance_admin.GetAppProfileRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseGetAppProfile._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseGetAppProfile._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._GetAppProfile._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1449,19 +1458,34 @@ def __call__(
resp = self._interceptor.post_get_app_profile(resp)
return resp
- class _GetCluster(BigtableInstanceAdminRestStub):
+ class _GetCluster(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetCluster,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetCluster")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.GetCluster")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1492,38 +1516,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseGetCluster._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_cluster(request, metadata)
- pb_request = bigtable_instance_admin.GetClusterRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseGetCluster._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseGetCluster._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._GetCluster._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1539,19 +1552,35 @@ def __call__(
resp = self._interceptor.post_get_cluster(resp)
return resp
- class _GetIamPolicy(BigtableInstanceAdminRestStub):
+ class _GetIamPolicy(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetIamPolicy,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetIamPolicy")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.GetIamPolicy")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1652,45 +1681,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*}:getIamPolicy",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseGetIamPolicy._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
- pb_request = request
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseGetIamPolicy._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseGetIamPolicy._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseGetIamPolicy._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableInstanceAdminRestTransport._GetIamPolicy._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1706,19 +1722,34 @@ def __call__(
resp = self._interceptor.post_get_iam_policy(resp)
return resp
- class _GetInstance(BigtableInstanceAdminRestStub):
+ class _GetInstance(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetInstance,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetInstance")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.GetInstance")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1751,38 +1782,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseGetInstance._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_instance(request, metadata)
- pb_request = bigtable_instance_admin.GetInstanceRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseGetInstance._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseGetInstance._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._GetInstance._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1798,19 +1818,34 @@ def __call__(
resp = self._interceptor.post_get_instance(resp)
return resp
- class _ListAppProfiles(BigtableInstanceAdminRestStub):
+ class _ListAppProfiles(
+ _BaseBigtableInstanceAdminRestTransport._BaseListAppProfiles,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListAppProfiles")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.ListAppProfiles")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1839,40 +1874,31 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*}/appProfiles",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseListAppProfiles._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_app_profiles(
request, metadata
)
- pb_request = bigtable_instance_admin.ListAppProfilesRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseListAppProfiles._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseListAppProfiles._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = (
+ BigtableInstanceAdminRestTransport._ListAppProfiles._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1888,19 +1914,34 @@ def __call__(
resp = self._interceptor.post_list_app_profiles(resp)
return resp
- class _ListClusters(BigtableInstanceAdminRestStub):
+ class _ListClusters(
+ _BaseBigtableInstanceAdminRestTransport._BaseListClusters,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListClusters")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.ListClusters")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1929,38 +1970,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*}/clusters",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseListClusters._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_clusters(request, metadata)
- pb_request = bigtable_instance_admin.ListClustersRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseListClusters._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseListClusters._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._ListClusters._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1976,19 +2006,34 @@ def __call__(
resp = self._interceptor.post_list_clusters(resp)
return resp
- class _ListHotTablets(BigtableInstanceAdminRestStub):
+ class _ListHotTablets(
+ _BaseBigtableInstanceAdminRestTransport._BaseListHotTablets,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListHotTablets")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.ListHotTablets")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2017,40 +2062,29 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/hotTablets",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseListHotTablets._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_hot_tablets(
request, metadata
)
- pb_request = bigtable_instance_admin.ListHotTabletsRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseListHotTablets._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseListHotTablets._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._ListHotTablets._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2066,19 +2100,34 @@ def __call__(
resp = self._interceptor.post_list_hot_tablets(resp)
return resp
- class _ListInstances(BigtableInstanceAdminRestStub):
+ class _ListInstances(
+ _BaseBigtableInstanceAdminRestTransport._BaseListInstances,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListInstances")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.ListInstances")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2107,38 +2156,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*}/instances",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseListInstances._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_instances(request, metadata)
- pb_request = bigtable_instance_admin.ListInstancesRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseListInstances._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseListInstances._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableInstanceAdminRestTransport._ListInstances._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2154,21 +2192,35 @@ def __call__(
resp = self._interceptor.post_list_instances(resp)
return resp
- class _PartialUpdateCluster(BigtableInstanceAdminRestStub):
+ class _PartialUpdateCluster(
+ _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateCluster,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("PartialUpdateCluster")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "updateMask": {},
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.PartialUpdateCluster")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2198,47 +2250,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "patch",
- "uri": "/v2/{cluster.name=projects/*/instances/*/clusters/*}",
- "body": "cluster",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateCluster._get_http_options()
+ )
request, metadata = self._interceptor.pre_partial_update_cluster(
request, metadata
)
- pb_request = bigtable_instance_admin.PartialUpdateClusterRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateCluster._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateCluster._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateCluster._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableInstanceAdminRestTransport._PartialUpdateCluster._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2252,21 +2293,35 @@ def __call__(
resp = self._interceptor.post_partial_update_cluster(resp)
return resp
- class _PartialUpdateInstance(BigtableInstanceAdminRestStub):
+ class _PartialUpdateInstance(
+ _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateInstance,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("PartialUpdateInstance")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "updateMask": {},
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.PartialUpdateInstance")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2296,49 +2351,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "patch",
- "uri": "/v2/{instance.name=projects/*/instances/*}",
- "body": "instance",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateInstance._get_http_options()
+ )
request, metadata = self._interceptor.pre_partial_update_instance(
request, metadata
)
- pb_request = bigtable_instance_admin.PartialUpdateInstanceRequest.pb(
- request
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateInstance._get_transcoded_request(
+ http_options, request
)
- transcoded_request = path_template.transcode(http_options, pb_request)
- # Jsonify the request body
-
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateInstance._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateInstance._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableInstanceAdminRestTransport._PartialUpdateInstance._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2352,19 +2394,35 @@ def __call__(
resp = self._interceptor.post_partial_update_instance(resp)
return resp
- class _SetIamPolicy(BigtableInstanceAdminRestStub):
+ class _SetIamPolicy(
+ _BaseBigtableInstanceAdminRestTransport._BaseSetIamPolicy,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("SetIamPolicy")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.SetIamPolicy")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2465,45 +2523,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*}:setIamPolicy",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseSetIamPolicy._get_http_options()
+ )
request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
- pb_request = request
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseSetIamPolicy._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseSetIamPolicy._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseSetIamPolicy._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableInstanceAdminRestTransport._SetIamPolicy._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2519,19 +2564,35 @@ def __call__(
resp = self._interceptor.post_set_iam_policy(resp)
return resp
- class _TestIamPermissions(BigtableInstanceAdminRestStub):
+ class _TestIamPermissions(
+ _BaseBigtableInstanceAdminRestTransport._BaseTestIamPermissions,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("TestIamPermissions")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.TestIamPermissions")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2557,47 +2618,36 @@ def __call__(
Response message for ``TestIamPermissions`` method.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*}:testIamPermissions",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseTestIamPermissions._get_http_options()
+ )
request, metadata = self._interceptor.pre_test_iam_permissions(
request, metadata
)
- pb_request = request
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseTestIamPermissions._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseTestIamPermissions._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseTestIamPermissions._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableInstanceAdminRestTransport._TestIamPermissions._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2613,21 +2663,35 @@ def __call__(
resp = self._interceptor.post_test_iam_permissions(resp)
return resp
- class _UpdateAppProfile(BigtableInstanceAdminRestStub):
+ class _UpdateAppProfile(
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateAppProfile,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("UpdateAppProfile")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "updateMask": {},
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.UpdateAppProfile")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2657,47 +2721,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "patch",
- "uri": "/v2/{app_profile.name=projects/*/instances/*/appProfiles/*}",
- "body": "app_profile",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateAppProfile._get_http_options()
+ )
request, metadata = self._interceptor.pre_update_app_profile(
request, metadata
)
- pb_request = bigtable_instance_admin.UpdateAppProfileRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseUpdateAppProfile._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseUpdateAppProfile._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseUpdateAppProfile._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableInstanceAdminRestTransport._UpdateAppProfile._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2711,9 +2764,35 @@ def __call__(
resp = self._interceptor.post_update_app_profile(resp)
return resp
- class _UpdateCluster(BigtableInstanceAdminRestStub):
+ class _UpdateCluster(
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateCluster,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("UpdateCluster")
+ return hash("BigtableInstanceAdminRestTransport.UpdateCluster")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2745,44 +2824,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "put",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*}",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateCluster._get_http_options()
+ )
request, metadata = self._interceptor.pre_update_cluster(request, metadata)
- pb_request = instance.Cluster.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseUpdateCluster._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseUpdateCluster._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseUpdateCluster._get_query_params_json(
+ transcoded_request
)
- query_params["$alt"] = "json;enum-encoding=int"
-
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableInstanceAdminRestTransport._UpdateCluster._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2796,19 +2863,35 @@ def __call__(
resp = self._interceptor.post_update_cluster(resp)
return resp
- class _UpdateInstance(BigtableInstanceAdminRestStub):
+ class _UpdateInstance(
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateInstance,
+ BigtableInstanceAdminRestStub,
+ ):
def __hash__(self):
- return hash("UpdateInstance")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableInstanceAdminRestTransport.UpdateInstance")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2845,45 +2928,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "put",
- "uri": "/v2/{name=projects/*/instances/*}",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateInstance._get_http_options()
+ )
request, metadata = self._interceptor.pre_update_instance(request, metadata)
- pb_request = instance.Instance.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableInstanceAdminRestTransport._BaseUpdateInstance._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableInstanceAdminRestTransport._BaseUpdateInstance._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableInstanceAdminRestTransport._BaseUpdateInstance._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableInstanceAdminRestTransport._UpdateInstance._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest_base.py b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest_base.py
new file mode 100644
index 000000000..7b0c1a4ba
--- /dev/null
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_instance_admin/transports/rest_base.py
@@ -0,0 +1,1194 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 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 json # type: ignore
+from google.api_core import path_template
+from google.api_core import gapic_v1
+
+from google.protobuf import json_format
+from .base import BigtableInstanceAdminTransport, DEFAULT_CLIENT_INFO
+
+import re
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+
+from google.cloud.bigtable_admin_v2.types import bigtable_instance_admin
+from google.cloud.bigtable_admin_v2.types import instance
+from google.iam.v1 import iam_policy_pb2 # type: ignore
+from google.iam.v1 import policy_pb2 # type: ignore
+from google.protobuf import empty_pb2 # type: ignore
+from google.longrunning import operations_pb2 # type: ignore
+
+
+class _BaseBigtableInstanceAdminRestTransport(BigtableInstanceAdminTransport):
+ """Base REST backend transport for BigtableInstanceAdmin.
+
+ Note: This class is not meant to be used directly. Use its sync and
+ async sub-classes instead.
+
+ This class defines the same methods as the primary client, so the
+ primary client can load the underlying transport implementation
+ and call it.
+
+ It sends JSON representations of protocol buffers over HTTP/1.1
+ """
+
+ def __init__(
+ self,
+ *,
+ host: str = "bigtableadmin.googleapis.com",
+ credentials: Optional[Any] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ url_scheme: str = "https",
+ api_audience: Optional[str] = None,
+ ) -> None:
+ """Instantiate the transport.
+ Args:
+ host (Optional[str]):
+ The hostname to connect to (default: 'bigtableadmin.googleapis.com').
+ credentials (Optional[Any]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you are developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+ url_scheme: the protocol scheme for the API endpoint. Normally
+ "https", but for testing or local servers,
+ "http" can be specified.
+ """
+ # Run the base constructor
+ maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host)
+ if maybe_url_match is None:
+ raise ValueError(
+ f"Unexpected hostname structure: {host}"
+ ) # pragma: NO COVER
+
+ url_match_items = maybe_url_match.groupdict()
+
+ host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+ super().__init__(
+ host=host,
+ credentials=credentials,
+ client_info=client_info,
+ always_use_jwt_access=always_use_jwt_access,
+ api_audience=api_audience,
+ )
+
+ class _BaseCreateAppProfile:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "appProfileId": "",
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*}/appProfiles",
+ "body": "app_profile",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.CreateAppProfileRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateAppProfile._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCreateCluster:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "clusterId": "",
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*}/clusters",
+ "body": "cluster",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.CreateClusterRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateCluster._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCreateInstance:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*}/instances",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.CreateInstanceRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseCreateInstance._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteAppProfile:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "ignoreWarnings": False,
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*/appProfiles/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.DeleteAppProfileRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteAppProfile._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteCluster:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.DeleteClusterRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteCluster._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteInstance:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.DeleteInstanceRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseDeleteInstance._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetAppProfile:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*/appProfiles/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.GetAppProfileRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetAppProfile._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetCluster:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.GetClusterRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetCluster._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetIamPolicy:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*}:getIamPolicy",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = request
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetIamPolicy._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetInstance:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.GetInstanceRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseGetInstance._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListAppProfiles:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*}/appProfiles",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.ListAppProfilesRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseListAppProfiles._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListClusters:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*}/clusters",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.ListClustersRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseListClusters._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListHotTablets:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/hotTablets",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.ListHotTabletsRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseListHotTablets._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListInstances:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*}/instances",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.ListInstancesRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseListInstances._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BasePartialUpdateCluster:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "updateMask": {},
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "patch",
+ "uri": "/v2/{cluster.name=projects/*/instances/*/clusters/*}",
+ "body": "cluster",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.PartialUpdateClusterRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateCluster._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BasePartialUpdateInstance:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "updateMask": {},
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "patch",
+ "uri": "/v2/{instance.name=projects/*/instances/*}",
+ "body": "instance",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.PartialUpdateInstanceRequest.pb(
+ request
+ )
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BasePartialUpdateInstance._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseSetIamPolicy:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*}:setIamPolicy",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = request
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseSetIamPolicy._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseTestIamPermissions:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*}:testIamPermissions",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = request
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseTestIamPermissions._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUpdateAppProfile:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "updateMask": {},
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "patch",
+ "uri": "/v2/{app_profile.name=projects/*/instances/*/appProfiles/*}",
+ "body": "app_profile",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_instance_admin.UpdateAppProfileRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateAppProfile._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUpdateCluster:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "put",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*}",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = instance.Cluster.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUpdateInstance:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "put",
+ "uri": "/v2/{name=projects/*/instances/*}",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = instance.Instance.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableInstanceAdminRestTransport._BaseUpdateInstance._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+
+__all__ = ("_BaseBigtableInstanceAdminRestTransport",)
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/client.py b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/client.py
index 55d50ee81..502f0085c 100644
--- a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/client.py
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/client.py
@@ -610,36 +610,6 @@ def _get_universe_domain(
raise ValueError("Universe Domain cannot be an empty string.")
return universe_domain
- @staticmethod
- def _compare_universes(
- client_universe: str, credentials: ga_credentials.Credentials
- ) -> bool:
- """Returns True iff the universe domains used by the client and credentials match.
-
- Args:
- client_universe (str): The universe domain configured via the client options.
- credentials (ga_credentials.Credentials): The credentials being used in the client.
-
- Returns:
- bool: True iff client_universe matches the universe in credentials.
-
- Raises:
- ValueError: when client_universe does not match the universe in credentials.
- """
-
- default_universe = BigtableTableAdminClient._DEFAULT_UNIVERSE
- credentials_universe = getattr(credentials, "universe_domain", default_universe)
-
- if client_universe != credentials_universe:
- raise ValueError(
- "The configured universe domain "
- f"({client_universe}) does not match the universe domain "
- f"found in the credentials ({credentials_universe}). "
- "If you haven't configured the universe domain explicitly, "
- f"`{default_universe}` is the default."
- )
- return True
-
def _validate_universe_domain(self):
"""Validates client's and credentials' universe domains are consistent.
@@ -649,13 +619,9 @@ def _validate_universe_domain(self):
Raises:
ValueError: If the configured universe domain is not valid.
"""
- self._is_universe_domain_valid = (
- self._is_universe_domain_valid
- or BigtableTableAdminClient._compare_universes(
- self.universe_domain, self.transport._credentials
- )
- )
- return self._is_universe_domain_valid
+
+ # NOTE (b/349488459): universe validation is disabled until further notice.
+ return True
@property
def api_endpoint(self):
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/README.rst b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/README.rst
new file mode 100644
index 000000000..0e8f40ec3
--- /dev/null
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/README.rst
@@ -0,0 +1,9 @@
+
+transport inheritance structure
+_______________________________
+
+`BigtableTableAdminTransport` is the ABC for all transports.
+- public child `BigtableTableAdminGrpcTransport` for sync gRPC transport (defined in `grpc.py`).
+- public child `BigtableTableAdminGrpcAsyncIOTransport` for async gRPC transport (defined in `grpc_asyncio.py`).
+- private child `_BaseBigtableTableAdminRestTransport` for base REST transport with inner classes `_BaseMETHOD` (defined in `rest_base.py`).
+- public child `BigtableTableAdminRestTransport` for sync REST transport with inner classes `METHOD` derived from the parent's corresponding `_BaseMETHOD` classes (defined in `rest.py`).
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/grpc_asyncio.py b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/grpc_asyncio.py
index e8b31ed36..520c7c83c 100644
--- a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/grpc_asyncio.py
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/grpc_asyncio.py
@@ -13,6 +13,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
+import inspect
import warnings
from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
@@ -239,6 +240,9 @@ def __init__(
)
# Wrap messages. This must be done after self._grpc_channel exists
+ self._wrap_with_kind = (
+ "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters
+ )
self._prep_wrapped_messages(client_info)
@property
@@ -1188,17 +1192,17 @@ def test_iam_permissions(
def _prep_wrapped_messages(self, client_info):
"""Precompute the wrapped methods, overriding the base class method to use async wrappers."""
self._wrapped_methods = {
- self.create_table: gapic_v1.method_async.wrap_method(
+ self.create_table: self._wrap_method(
self.create_table,
default_timeout=300.0,
client_info=client_info,
),
- self.create_table_from_snapshot: gapic_v1.method_async.wrap_method(
+ self.create_table_from_snapshot: self._wrap_method(
self.create_table_from_snapshot,
default_timeout=None,
client_info=client_info,
),
- self.list_tables: gapic_v1.method_async.wrap_method(
+ self.list_tables: self._wrap_method(
self.list_tables,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1213,7 +1217,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.get_table: gapic_v1.method_async.wrap_method(
+ self.get_table: self._wrap_method(
self.get_table,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1228,57 +1232,57 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.update_table: gapic_v1.method_async.wrap_method(
+ self.update_table: self._wrap_method(
self.update_table,
default_timeout=None,
client_info=client_info,
),
- self.delete_table: gapic_v1.method_async.wrap_method(
+ self.delete_table: self._wrap_method(
self.delete_table,
default_timeout=300.0,
client_info=client_info,
),
- self.undelete_table: gapic_v1.method_async.wrap_method(
+ self.undelete_table: self._wrap_method(
self.undelete_table,
default_timeout=None,
client_info=client_info,
),
- self.create_authorized_view: gapic_v1.method_async.wrap_method(
+ self.create_authorized_view: self._wrap_method(
self.create_authorized_view,
default_timeout=None,
client_info=client_info,
),
- self.list_authorized_views: gapic_v1.method_async.wrap_method(
+ self.list_authorized_views: self._wrap_method(
self.list_authorized_views,
default_timeout=None,
client_info=client_info,
),
- self.get_authorized_view: gapic_v1.method_async.wrap_method(
+ self.get_authorized_view: self._wrap_method(
self.get_authorized_view,
default_timeout=None,
client_info=client_info,
),
- self.update_authorized_view: gapic_v1.method_async.wrap_method(
+ self.update_authorized_view: self._wrap_method(
self.update_authorized_view,
default_timeout=None,
client_info=client_info,
),
- self.delete_authorized_view: gapic_v1.method_async.wrap_method(
+ self.delete_authorized_view: self._wrap_method(
self.delete_authorized_view,
default_timeout=None,
client_info=client_info,
),
- self.modify_column_families: gapic_v1.method_async.wrap_method(
+ self.modify_column_families: self._wrap_method(
self.modify_column_families,
default_timeout=300.0,
client_info=client_info,
),
- self.drop_row_range: gapic_v1.method_async.wrap_method(
+ self.drop_row_range: self._wrap_method(
self.drop_row_range,
default_timeout=3600.0,
client_info=client_info,
),
- self.generate_consistency_token: gapic_v1.method_async.wrap_method(
+ self.generate_consistency_token: self._wrap_method(
self.generate_consistency_token,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1293,7 +1297,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.check_consistency: gapic_v1.method_async.wrap_method(
+ self.check_consistency: self._wrap_method(
self.check_consistency,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1308,12 +1312,12 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.snapshot_table: gapic_v1.method_async.wrap_method(
+ self.snapshot_table: self._wrap_method(
self.snapshot_table,
default_timeout=None,
client_info=client_info,
),
- self.get_snapshot: gapic_v1.method_async.wrap_method(
+ self.get_snapshot: self._wrap_method(
self.get_snapshot,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1328,7 +1332,7 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.list_snapshots: gapic_v1.method_async.wrap_method(
+ self.list_snapshots: self._wrap_method(
self.list_snapshots,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1343,17 +1347,17 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.delete_snapshot: gapic_v1.method_async.wrap_method(
+ self.delete_snapshot: self._wrap_method(
self.delete_snapshot,
default_timeout=300.0,
client_info=client_info,
),
- self.create_backup: gapic_v1.method_async.wrap_method(
+ self.create_backup: self._wrap_method(
self.create_backup,
default_timeout=60.0,
client_info=client_info,
),
- self.get_backup: gapic_v1.method_async.wrap_method(
+ self.get_backup: self._wrap_method(
self.get_backup,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1368,17 +1372,17 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.update_backup: gapic_v1.method_async.wrap_method(
+ self.update_backup: self._wrap_method(
self.update_backup,
default_timeout=60.0,
client_info=client_info,
),
- self.delete_backup: gapic_v1.method_async.wrap_method(
+ self.delete_backup: self._wrap_method(
self.delete_backup,
default_timeout=300.0,
client_info=client_info,
),
- self.list_backups: gapic_v1.method_async.wrap_method(
+ self.list_backups: self._wrap_method(
self.list_backups,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1393,17 +1397,17 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.restore_table: gapic_v1.method_async.wrap_method(
+ self.restore_table: self._wrap_method(
self.restore_table,
default_timeout=60.0,
client_info=client_info,
),
- self.copy_backup: gapic_v1.method_async.wrap_method(
+ self.copy_backup: self._wrap_method(
self.copy_backup,
default_timeout=None,
client_info=client_info,
),
- self.get_iam_policy: gapic_v1.method_async.wrap_method(
+ self.get_iam_policy: self._wrap_method(
self.get_iam_policy,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1418,12 +1422,12 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.set_iam_policy: gapic_v1.method_async.wrap_method(
+ self.set_iam_policy: self._wrap_method(
self.set_iam_policy,
default_timeout=60.0,
client_info=client_info,
),
- self.test_iam_permissions: gapic_v1.method_async.wrap_method(
+ self.test_iam_permissions: self._wrap_method(
self.test_iam_permissions,
default_retry=retries.AsyncRetry(
initial=1.0,
@@ -1440,8 +1444,17 @@ def _prep_wrapped_messages(self, client_info):
),
}
+ def _wrap_method(self, func, *args, **kwargs):
+ if self._wrap_with_kind: # pragma: NO COVER
+ kwargs["kind"] = self.kind
+ return gapic_v1.method_async.wrap_method(func, *args, **kwargs)
+
def close(self):
return self.grpc_channel.close()
+ @property
+ def kind(self) -> str:
+ return "grpc_asyncio"
+
__all__ = ("BigtableTableAdminGrpcAsyncIOTransport",)
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest.py b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest.py
index 230b13a43..b25ddec60 100644
--- a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest.py
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest.py
@@ -16,29 +16,21 @@
from google.auth.transport.requests import AuthorizedSession # type: ignore
import json # type: ignore
-import grpc # type: ignore
-from google.auth.transport.grpc import SslCredentials # type: ignore
from google.auth import credentials as ga_credentials # type: ignore
from google.api_core import exceptions as core_exceptions
from google.api_core import retry as retries
from google.api_core import rest_helpers
from google.api_core import rest_streaming
-from google.api_core import path_template
from google.api_core import gapic_v1
from google.protobuf import json_format
from google.api_core import operations_v1
+
from requests import __version__ as requests_version
import dataclasses
-import re
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
import warnings
-try:
- OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
-except AttributeError: # pragma: NO COVER
- OptionalRetry = Union[retries.Retry, object, None] # type: ignore
-
from google.cloud.bigtable_admin_v2.types import bigtable_table_admin
from google.cloud.bigtable_admin_v2.types import table
@@ -48,16 +40,20 @@
from google.protobuf import empty_pb2 # type: ignore
from google.longrunning import operations_pb2 # type: ignore
-from .base import (
- BigtableTableAdminTransport,
- DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO,
-)
+
+from .rest_base import _BaseBigtableTableAdminRestTransport
+from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
+
+try:
+ OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+except AttributeError: # pragma: NO COVER
+ OptionalRetry = Union[retries.Retry, object, None] # type: ignore
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
grpc_version=None,
- rest_version=requests_version,
+ rest_version=f"requests@{requests_version}",
)
@@ -945,8 +941,8 @@ class BigtableTableAdminRestStub:
_interceptor: BigtableTableAdminRestInterceptor
-class BigtableTableAdminRestTransport(BigtableTableAdminTransport):
- """REST backend transport for BigtableTableAdmin.
+class BigtableTableAdminRestTransport(_BaseBigtableTableAdminRestTransport):
+ """REST backend synchronous transport for BigtableTableAdmin.
Service for creating, configuring, and deleting Cloud
Bigtable tables.
@@ -959,7 +955,6 @@ class BigtableTableAdminRestTransport(BigtableTableAdminTransport):
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
-
"""
def __init__(
@@ -1013,21 +1008,12 @@ def __init__(
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
- maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host)
- if maybe_url_match is None:
- raise ValueError(
- f"Unexpected hostname structure: {host}"
- ) # pragma: NO COVER
-
- url_match_items = maybe_url_match.groupdict()
-
- host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
-
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
always_use_jwt_access=always_use_jwt_access,
+ url_scheme=url_scheme,
api_audience=api_audience,
)
self._session = AuthorizedSession(
@@ -1091,19 +1077,35 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
# Return the client from cache.
return self._operations_client
- class _CheckConsistency(BigtableTableAdminRestStub):
+ class _CheckConsistency(
+ _BaseBigtableTableAdminRestTransport._BaseCheckConsistency,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("CheckConsistency")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.CheckConsistency")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1132,47 +1134,34 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}:checkConsistency",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseCheckConsistency._get_http_options()
+ )
request, metadata = self._interceptor.pre_check_consistency(
request, metadata
)
- pb_request = bigtable_table_admin.CheckConsistencyRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseCheckConsistency._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseCheckConsistency._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseCheckConsistency._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._CheckConsistency._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1188,19 +1177,34 @@ def __call__(
resp = self._interceptor.post_check_consistency(resp)
return resp
- class _CopyBackup(BigtableTableAdminRestStub):
+ class _CopyBackup(
+ _BaseBigtableTableAdminRestTransport._BaseCopyBackup, BigtableTableAdminRestStub
+ ):
def __hash__(self):
- return hash("CopyBackup")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.CopyBackup")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1230,45 +1234,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/backups:copy",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseCopyBackup._get_http_options()
+ )
request, metadata = self._interceptor.pre_copy_backup(request, metadata)
- pb_request = bigtable_table_admin.CopyBackupRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseCopyBackup._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseCopyBackup._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseCopyBackup._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._CopyBackup._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1282,21 +1273,35 @@ def __call__(
resp = self._interceptor.post_copy_backup(resp)
return resp
- class _CreateAuthorizedView(BigtableTableAdminRestStub):
+ class _CreateAuthorizedView(
+ _BaseBigtableTableAdminRestTransport._BaseCreateAuthorizedView,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateAuthorizedView")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "authorizedViewId": "",
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.CreateAuthorizedView")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1326,47 +1331,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*/tables/*}/authorizedViews",
- "body": "authorized_view",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseCreateAuthorizedView._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_authorized_view(
request, metadata
)
- pb_request = bigtable_table_admin.CreateAuthorizedViewRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseCreateAuthorizedView._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseCreateAuthorizedView._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseCreateAuthorizedView._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableTableAdminRestTransport._CreateAuthorizedView._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1380,21 +1374,35 @@ def __call__(
resp = self._interceptor.post_create_authorized_view(resp)
return resp
- class _CreateBackup(BigtableTableAdminRestStub):
+ class _CreateBackup(
+ _BaseBigtableTableAdminRestTransport._BaseCreateBackup,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateBackup")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "backupId": "",
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.CreateBackup")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1424,45 +1432,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/backups",
- "body": "backup",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseCreateBackup._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_backup(request, metadata)
- pb_request = bigtable_table_admin.CreateBackupRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseCreateBackup._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseCreateBackup._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseCreateBackup._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._CreateBackup._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1476,19 +1471,35 @@ def __call__(
resp = self._interceptor.post_create_backup(resp)
return resp
- class _CreateTable(BigtableTableAdminRestStub):
+ class _CreateTable(
+ _BaseBigtableTableAdminRestTransport._BaseCreateTable,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.CreateTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1519,45 +1530,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*}/tables",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseCreateTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_table(request, metadata)
- pb_request = bigtable_table_admin.CreateTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseCreateTable._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseCreateTable._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseCreateTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._CreateTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1573,19 +1571,35 @@ def __call__(
resp = self._interceptor.post_create_table(resp)
return resp
- class _CreateTableFromSnapshot(BigtableTableAdminRestStub):
+ class _CreateTableFromSnapshot(
+ _BaseBigtableTableAdminRestTransport._BaseCreateTableFromSnapshot,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("CreateTableFromSnapshot")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.CreateTableFromSnapshot")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1623,47 +1637,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*}/tables:createFromSnapshot",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseCreateTableFromSnapshot._get_http_options()
+ )
request, metadata = self._interceptor.pre_create_table_from_snapshot(
request, metadata
)
- pb_request = bigtable_table_admin.CreateTableFromSnapshotRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseCreateTableFromSnapshot._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseCreateTableFromSnapshot._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseCreateTableFromSnapshot._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableTableAdminRestTransport._CreateTableFromSnapshot._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1677,19 +1680,34 @@ def __call__(
resp = self._interceptor.post_create_table_from_snapshot(resp)
return resp
- class _DeleteAuthorizedView(BigtableTableAdminRestStub):
+ class _DeleteAuthorizedView(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteAuthorizedView,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteAuthorizedView")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.DeleteAuthorizedView")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1712,40 +1730,31 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseDeleteAuthorizedView._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_authorized_view(
request, metadata
)
- pb_request = bigtable_table_admin.DeleteAuthorizedViewRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseDeleteAuthorizedView._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseDeleteAuthorizedView._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = (
+ BigtableTableAdminRestTransport._DeleteAuthorizedView._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1753,19 +1762,34 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _DeleteBackup(BigtableTableAdminRestStub):
+ class _DeleteBackup(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteBackup,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteBackup")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.DeleteBackup")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1788,38 +1812,27 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*/backups/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseDeleteBackup._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_backup(request, metadata)
- pb_request = bigtable_table_admin.DeleteBackupRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseDeleteBackup._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseDeleteBackup._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._DeleteBackup._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1827,19 +1840,34 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _DeleteSnapshot(BigtableTableAdminRestStub):
+ class _DeleteSnapshot(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteSnapshot,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteSnapshot")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.DeleteSnapshot")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1869,38 +1897,27 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*/snapshots/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseDeleteSnapshot._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_snapshot(request, metadata)
- pb_request = bigtable_table_admin.DeleteSnapshotRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseDeleteSnapshot._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseDeleteSnapshot._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._DeleteSnapshot._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1908,19 +1925,34 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _DeleteTable(BigtableTableAdminRestStub):
+ class _DeleteTable(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteTable,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("DeleteTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.DeleteTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -1943,38 +1975,27 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "delete",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseDeleteTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_delete_table(request, metadata)
- pb_request = bigtable_table_admin.DeleteTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseDeleteTable._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseDeleteTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._DeleteTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1982,19 +2003,35 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _DropRowRange(BigtableTableAdminRestStub):
+ class _DropRowRange(
+ _BaseBigtableTableAdminRestTransport._BaseDropRowRange,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("DropRowRange")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.DropRowRange")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2017,45 +2054,32 @@ def __call__(
sent along with the request as metadata.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}:dropRowRange",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseDropRowRange._get_http_options()
+ )
request, metadata = self._interceptor.pre_drop_row_range(request, metadata)
- pb_request = bigtable_table_admin.DropRowRangeRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseDropRowRange._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseDropRowRange._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseDropRowRange._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._DropRowRange._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2063,19 +2087,35 @@ def __call__(
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
- class _GenerateConsistencyToken(BigtableTableAdminRestStub):
+ class _GenerateConsistencyToken(
+ _BaseBigtableTableAdminRestTransport._BaseGenerateConsistencyToken,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("GenerateConsistencyToken")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.GenerateConsistencyToken")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2105,49 +2145,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}:generateConsistencyToken",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseGenerateConsistencyToken._get_http_options()
+ )
request, metadata = self._interceptor.pre_generate_consistency_token(
request, metadata
)
- pb_request = bigtable_table_admin.GenerateConsistencyTokenRequest.pb(
- request
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseGenerateConsistencyToken._get_transcoded_request(
+ http_options, request
)
- transcoded_request = path_template.transcode(http_options, pb_request)
- # Jsonify the request body
-
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseGenerateConsistencyToken._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseGenerateConsistencyToken._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableTableAdminRestTransport._GenerateConsistencyToken._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2163,19 +2190,34 @@ def __call__(
resp = self._interceptor.post_generate_consistency_token(resp)
return resp
- class _GetAuthorizedView(BigtableTableAdminRestStub):
+ class _GetAuthorizedView(
+ _BaseBigtableTableAdminRestTransport._BaseGetAuthorizedView,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetAuthorizedView")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.GetAuthorizedView")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2208,40 +2250,29 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseGetAuthorizedView._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_authorized_view(
request, metadata
)
- pb_request = bigtable_table_admin.GetAuthorizedViewRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseGetAuthorizedView._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseGetAuthorizedView._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._GetAuthorizedView._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2257,19 +2288,33 @@ def __call__(
resp = self._interceptor.post_get_authorized_view(resp)
return resp
- class _GetBackup(BigtableTableAdminRestStub):
+ class _GetBackup(
+ _BaseBigtableTableAdminRestTransport._BaseGetBackup, BigtableTableAdminRestStub
+ ):
def __hash__(self):
- return hash("GetBackup")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.GetBackup")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2296,38 +2341,27 @@ def __call__(
A backup of a Cloud Bigtable table.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*/backups/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseGetBackup._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_backup(request, metadata)
- pb_request = bigtable_table_admin.GetBackupRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseGetBackup._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseGetBackup._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._GetBackup._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2343,19 +2377,35 @@ def __call__(
resp = self._interceptor.post_get_backup(resp)
return resp
- class _GetIamPolicy(BigtableTableAdminRestStub):
+ class _GetIamPolicy(
+ _BaseBigtableTableAdminRestTransport._BaseGetIamPolicy,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetIamPolicy")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.GetIamPolicy")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -2456,50 +2506,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*/tables/*}:getIamPolicy",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*/clusters/*/backups/*}:getIamPolicy",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseGetIamPolicy._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
- pb_request = request
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseGetIamPolicy._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseGetIamPolicy._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseGetIamPolicy._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._GetIamPolicy._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2515,19 +2547,34 @@ def __call__(
resp = self._interceptor.post_get_iam_policy(resp)
return resp
- class _GetSnapshot(BigtableTableAdminRestStub):
+ class _GetSnapshot(
+ _BaseBigtableTableAdminRestTransport._BaseGetSnapshot,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("GetSnapshot")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.GetSnapshot")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2574,38 +2621,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*/clusters/*/snapshots/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseGetSnapshot._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_snapshot(request, metadata)
- pb_request = bigtable_table_admin.GetSnapshotRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseGetSnapshot._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseGetSnapshot._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._GetSnapshot._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2621,19 +2657,33 @@ def __call__(
resp = self._interceptor.post_get_snapshot(resp)
return resp
- class _GetTable(BigtableTableAdminRestStub):
+ class _GetTable(
+ _BaseBigtableTableAdminRestTransport._BaseGetTable, BigtableTableAdminRestStub
+ ):
def __hash__(self):
- return hash("GetTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.GetTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2664,38 +2714,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseGetTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_get_table(request, metadata)
- pb_request = bigtable_table_admin.GetTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseGetTable._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseGetTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._GetTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2711,19 +2750,34 @@ def __call__(
resp = self._interceptor.post_get_table(resp)
return resp
- class _ListAuthorizedViews(BigtableTableAdminRestStub):
+ class _ListAuthorizedViews(
+ _BaseBigtableTableAdminRestTransport._BaseListAuthorizedViews,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListAuthorizedViews")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.ListAuthorizedViews")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2752,40 +2806,31 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*/tables/*}/authorizedViews",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseListAuthorizedViews._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_authorized_views(
request, metadata
)
- pb_request = bigtable_table_admin.ListAuthorizedViewsRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseListAuthorizedViews._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseListAuthorizedViews._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = (
+ BigtableTableAdminRestTransport._ListAuthorizedViews._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2801,19 +2846,34 @@ def __call__(
resp = self._interceptor.post_list_authorized_views(resp)
return resp
- class _ListBackups(BigtableTableAdminRestStub):
+ class _ListBackups(
+ _BaseBigtableTableAdminRestTransport._BaseListBackups,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListBackups")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.ListBackups")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2842,38 +2902,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/backups",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseListBackups._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_backups(request, metadata)
- pb_request = bigtable_table_admin.ListBackupsRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseListBackups._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseListBackups._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._ListBackups._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2889,19 +2938,34 @@ def __call__(
resp = self._interceptor.post_list_backups(resp)
return resp
- class _ListSnapshots(BigtableTableAdminRestStub):
+ class _ListSnapshots(
+ _BaseBigtableTableAdminRestTransport._BaseListSnapshots,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("ListSnapshots")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.ListSnapshots")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -2944,38 +3008,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/snapshots",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseListSnapshots._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_snapshots(request, metadata)
- pb_request = bigtable_table_admin.ListSnapshotsRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseListSnapshots._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseListSnapshots._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._ListSnapshots._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -2991,19 +3044,33 @@ def __call__(
resp = self._interceptor.post_list_snapshots(resp)
return resp
- class _ListTables(BigtableTableAdminRestStub):
+ class _ListTables(
+ _BaseBigtableTableAdminRestTransport._BaseListTables, BigtableTableAdminRestStub
+ ):
def __hash__(self):
- return hash("ListTables")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.ListTables")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ )
+ return response
def __call__(
self,
@@ -3032,38 +3099,27 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{parent=projects/*/instances/*}/tables",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseListTables._get_http_options()
+ )
request, metadata = self._interceptor.pre_list_tables(request, metadata)
- pb_request = bigtable_table_admin.ListTablesRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseListTables._get_transcoded_request(
+ http_options, request
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseListTables._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableTableAdminRestTransport._ListTables._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3079,19 +3135,35 @@ def __call__(
resp = self._interceptor.post_list_tables(resp)
return resp
- class _ModifyColumnFamilies(BigtableTableAdminRestStub):
+ class _ModifyColumnFamilies(
+ _BaseBigtableTableAdminRestTransport._BaseModifyColumnFamilies,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("ModifyColumnFamilies")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.ModifyColumnFamilies")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3122,47 +3194,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}:modifyColumnFamilies",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseModifyColumnFamilies._get_http_options()
+ )
request, metadata = self._interceptor.pre_modify_column_families(
request, metadata
)
- pb_request = bigtable_table_admin.ModifyColumnFamiliesRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseModifyColumnFamilies._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseModifyColumnFamilies._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseModifyColumnFamilies._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableTableAdminRestTransport._ModifyColumnFamilies._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3178,19 +3239,35 @@ def __call__(
resp = self._interceptor.post_modify_column_families(resp)
return resp
- class _RestoreTable(BigtableTableAdminRestStub):
+ class _RestoreTable(
+ _BaseBigtableTableAdminRestTransport._BaseRestoreTable,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("RestoreTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.RestoreTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3220,45 +3297,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{parent=projects/*/instances/*}/tables:restore",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseRestoreTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_restore_table(request, metadata)
- pb_request = bigtable_table_admin.RestoreTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseRestoreTable._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseRestoreTable._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseRestoreTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._RestoreTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3272,19 +3336,35 @@ def __call__(
resp = self._interceptor.post_restore_table(resp)
return resp
- class _SetIamPolicy(BigtableTableAdminRestStub):
+ class _SetIamPolicy(
+ _BaseBigtableTableAdminRestTransport._BaseSetIamPolicy,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("SetIamPolicy")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.SetIamPolicy")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3385,50 +3465,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*/tables/*}:setIamPolicy",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*/clusters/*/backups/*}:setIamPolicy",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseSetIamPolicy._get_http_options()
+ )
request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
- pb_request = request
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseSetIamPolicy._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseSetIamPolicy._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseSetIamPolicy._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._SetIamPolicy._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3444,19 +3506,35 @@ def __call__(
resp = self._interceptor.post_set_iam_policy(resp)
return resp
- class _SnapshotTable(BigtableTableAdminRestStub):
+ class _SnapshotTable(
+ _BaseBigtableTableAdminRestTransport._BaseSnapshotTable,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("SnapshotTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.SnapshotTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3493,45 +3571,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}:snapshot",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseSnapshotTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_snapshot_table(request, metadata)
- pb_request = bigtable_table_admin.SnapshotTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseSnapshotTable._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseSnapshotTable._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseSnapshotTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._SnapshotTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3545,19 +3610,35 @@ def __call__(
resp = self._interceptor.post_snapshot_table(resp)
return resp
- class _TestIamPermissions(BigtableTableAdminRestStub):
+ class _TestIamPermissions(
+ _BaseBigtableTableAdminRestTransport._BaseTestIamPermissions,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("TestIamPermissions")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.TestIamPermissions")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3583,52 +3664,36 @@ def __call__(
Response message for ``TestIamPermissions`` method.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*/tables/*}:testIamPermissions",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{resource=projects/*/instances/*/clusters/*/backups/*}:testIamPermissions",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseTestIamPermissions._get_http_options()
+ )
request, metadata = self._interceptor.pre_test_iam_permissions(
request, metadata
)
- pb_request = request
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseTestIamPermissions._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseTestIamPermissions._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseTestIamPermissions._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableTableAdminRestTransport._TestIamPermissions._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3644,19 +3709,35 @@ def __call__(
resp = self._interceptor.post_test_iam_permissions(resp)
return resp
- class _UndeleteTable(BigtableTableAdminRestStub):
+ class _UndeleteTable(
+ _BaseBigtableTableAdminRestTransport._BaseUndeleteTable,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("UndeleteTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.UndeleteTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3686,45 +3767,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*/tables/*}:undelete",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseUndeleteTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_undelete_table(request, metadata)
- pb_request = bigtable_table_admin.UndeleteTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseUndeleteTable._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseUndeleteTable._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseUndeleteTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._UndeleteTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3738,19 +3806,35 @@ def __call__(
resp = self._interceptor.post_undelete_table(resp)
return resp
- class _UpdateAuthorizedView(BigtableTableAdminRestStub):
+ class _UpdateAuthorizedView(
+ _BaseBigtableTableAdminRestTransport._BaseUpdateAuthorizedView,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("UpdateAuthorizedView")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.UpdateAuthorizedView")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3780,47 +3864,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "patch",
- "uri": "/v2/{authorized_view.name=projects/*/instances/*/tables/*/authorizedViews/*}",
- "body": "authorized_view",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseUpdateAuthorizedView._get_http_options()
+ )
request, metadata = self._interceptor.pre_update_authorized_view(
request, metadata
)
- pb_request = bigtable_table_admin.UpdateAuthorizedViewRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseUpdateAuthorizedView._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseUpdateAuthorizedView._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseUpdateAuthorizedView._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = (
+ BigtableTableAdminRestTransport._UpdateAuthorizedView._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
+ )
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3834,21 +3907,35 @@ def __call__(
resp = self._interceptor.post_update_authorized_view(resp)
return resp
- class _UpdateBackup(BigtableTableAdminRestStub):
+ class _UpdateBackup(
+ _BaseBigtableTableAdminRestTransport._BaseUpdateBackup,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("UpdateBackup")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "updateMask": {},
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.UpdateBackup")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3875,45 +3962,32 @@ def __call__(
A backup of a Cloud Bigtable table.
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "patch",
- "uri": "/v2/{backup.name=projects/*/instances/*/clusters/*/backups/*}",
- "body": "backup",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseUpdateBackup._get_http_options()
+ )
request, metadata = self._interceptor.pre_update_backup(request, metadata)
- pb_request = bigtable_table_admin.UpdateBackupRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseUpdateBackup._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseUpdateBackup._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseUpdateBackup._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._UpdateBackup._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -3929,21 +4003,35 @@ def __call__(
resp = self._interceptor.post_update_backup(resp)
return resp
- class _UpdateTable(BigtableTableAdminRestStub):
+ class _UpdateTable(
+ _BaseBigtableTableAdminRestTransport._BaseUpdateTable,
+ BigtableTableAdminRestStub,
+ ):
def __hash__(self):
- return hash("UpdateTable")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
- "updateMask": {},
- }
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableTableAdminRestTransport.UpdateTable")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -3973,45 +4061,32 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "patch",
- "uri": "/v2/{table.name=projects/*/instances/*/tables/*}",
- "body": "table",
- },
- ]
+ http_options = (
+ _BaseBigtableTableAdminRestTransport._BaseUpdateTable._get_http_options()
+ )
request, metadata = self._interceptor.pre_update_table(request, metadata)
- pb_request = bigtable_table_admin.UpdateTableRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableTableAdminRestTransport._BaseUpdateTable._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableTableAdminRestTransport._BaseUpdateTable._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableTableAdminRestTransport._BaseUpdateTable._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableTableAdminRestTransport._UpdateTable._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
diff --git a/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest_base.py b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest_base.py
new file mode 100644
index 000000000..fbaf89e52
--- /dev/null
+++ b/google/cloud/bigtable_admin_v2/services/bigtable_table_admin/transports/rest_base.py
@@ -0,0 +1,1714 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 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 json # type: ignore
+from google.api_core import path_template
+from google.api_core import gapic_v1
+
+from google.protobuf import json_format
+from .base import BigtableTableAdminTransport, DEFAULT_CLIENT_INFO
+
+import re
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+
+from google.cloud.bigtable_admin_v2.types import bigtable_table_admin
+from google.cloud.bigtable_admin_v2.types import table
+from google.cloud.bigtable_admin_v2.types import table as gba_table
+from google.iam.v1 import iam_policy_pb2 # type: ignore
+from google.iam.v1 import policy_pb2 # type: ignore
+from google.protobuf import empty_pb2 # type: ignore
+from google.longrunning import operations_pb2 # type: ignore
+
+
+class _BaseBigtableTableAdminRestTransport(BigtableTableAdminTransport):
+ """Base REST backend transport for BigtableTableAdmin.
+
+ Note: This class is not meant to be used directly. Use its sync and
+ async sub-classes instead.
+
+ This class defines the same methods as the primary client, so the
+ primary client can load the underlying transport implementation
+ and call it.
+
+ It sends JSON representations of protocol buffers over HTTP/1.1
+ """
+
+ def __init__(
+ self,
+ *,
+ host: str = "bigtableadmin.googleapis.com",
+ credentials: Optional[Any] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ url_scheme: str = "https",
+ api_audience: Optional[str] = None,
+ ) -> None:
+ """Instantiate the transport.
+ Args:
+ host (Optional[str]):
+ The hostname to connect to (default: 'bigtableadmin.googleapis.com').
+ credentials (Optional[Any]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you are developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+ url_scheme: the protocol scheme for the API endpoint. Normally
+ "https", but for testing or local servers,
+ "http" can be specified.
+ """
+ # Run the base constructor
+ maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host)
+ if maybe_url_match is None:
+ raise ValueError(
+ f"Unexpected hostname structure: {host}"
+ ) # pragma: NO COVER
+
+ url_match_items = maybe_url_match.groupdict()
+
+ host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+ super().__init__(
+ host=host,
+ credentials=credentials,
+ client_info=client_info,
+ always_use_jwt_access=always_use_jwt_access,
+ api_audience=api_audience,
+ )
+
+ class _BaseCheckConsistency:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}:checkConsistency",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.CheckConsistencyRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseCheckConsistency._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCopyBackup:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/backups:copy",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.CopyBackupRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseCopyBackup._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCreateAuthorizedView:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "authorizedViewId": "",
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*/tables/*}/authorizedViews",
+ "body": "authorized_view",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.CreateAuthorizedViewRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseCreateAuthorizedView._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCreateBackup:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "backupId": "",
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/backups",
+ "body": "backup",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.CreateBackupRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseCreateBackup._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCreateTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*}/tables",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.CreateTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseCreateTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseCreateTableFromSnapshot:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*}/tables:createFromSnapshot",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.CreateTableFromSnapshotRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseCreateTableFromSnapshot._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteAuthorizedView:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.DeleteAuthorizedViewRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteAuthorizedView._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteBackup:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*/backups/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.DeleteBackupRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteBackup._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteSnapshot:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*/snapshots/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.DeleteSnapshotRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteSnapshot._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDeleteTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "delete",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.DeleteTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseDeleteTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseDropRowRange:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}:dropRowRange",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.DropRowRangeRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseDropRowRange._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGenerateConsistencyToken:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}:generateConsistencyToken",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.GenerateConsistencyTokenRequest.pb(
+ request
+ )
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseGenerateConsistencyToken._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetAuthorizedView:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.GetAuthorizedViewRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseGetAuthorizedView._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetBackup:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*/backups/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.GetBackupRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseGetBackup._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetIamPolicy:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*/tables/*}:getIamPolicy",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*/clusters/*/backups/*}:getIamPolicy",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = request
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseGetIamPolicy._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetSnapshot:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*/clusters/*/snapshots/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.GetSnapshotRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseGetSnapshot._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGetTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.GetTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseGetTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListAuthorizedViews:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*/tables/*}/authorizedViews",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.ListAuthorizedViewsRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseListAuthorizedViews._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListBackups:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/backups",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.ListBackupsRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseListBackups._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListSnapshots:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*/clusters/*}/snapshots",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.ListSnapshotsRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseListSnapshots._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseListTables:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{parent=projects/*/instances/*}/tables",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.ListTablesRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseListTables._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseModifyColumnFamilies:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}:modifyColumnFamilies",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.ModifyColumnFamiliesRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseModifyColumnFamilies._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseRestoreTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{parent=projects/*/instances/*}/tables:restore",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.RestoreTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseRestoreTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseSetIamPolicy:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*/tables/*}:setIamPolicy",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*/clusters/*/backups/*}:setIamPolicy",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = request
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseSetIamPolicy._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseSnapshotTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}:snapshot",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.SnapshotTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseSnapshotTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseTestIamPermissions:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*/tables/*}:testIamPermissions",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{resource=projects/*/instances/*/clusters/*/backups/*}:testIamPermissions",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = request
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseTestIamPermissions._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUndeleteTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*/tables/*}:undelete",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.UndeleteTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseUndeleteTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUpdateAuthorizedView:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "patch",
+ "uri": "/v2/{authorized_view.name=projects/*/instances/*/tables/*/authorizedViews/*}",
+ "body": "authorized_view",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.UpdateAuthorizedViewRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseUpdateAuthorizedView._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUpdateBackup:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "updateMask": {},
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "patch",
+ "uri": "/v2/{backup.name=projects/*/instances/*/clusters/*/backups/*}",
+ "body": "backup",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.UpdateBackupRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseUpdateBackup._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseUpdateTable:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+ "updateMask": {},
+ }
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "patch",
+ "uri": "/v2/{table.name=projects/*/instances/*/tables/*}",
+ "body": "table",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable_table_admin.UpdateTableRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableTableAdminRestTransport._BaseUpdateTable._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+
+__all__ = ("_BaseBigtableTableAdminRestTransport",)
diff --git a/google/cloud/bigtable_v2/gapic_version.py b/google/cloud/bigtable_v2/gapic_version.py
index d56eed5c5..f0fcebfa4 100644
--- a/google/cloud/bigtable_v2/gapic_version.py
+++ b/google/cloud/bigtable_v2/gapic_version.py
@@ -13,4 +13,4 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
-__version__ = "2.26.0" # {x-release-please-version}
+__version__ = "2.27.0" # {x-release-please-version}
diff --git a/google/cloud/bigtable_v2/services/bigtable/async_client.py b/google/cloud/bigtable_v2/services/bigtable/async_client.py
index 54b7f2c63..b36f525fa 100644
--- a/google/cloud/bigtable_v2/services/bigtable/async_client.py
+++ b/google/cloud/bigtable_v2/services/bigtable/async_client.py
@@ -335,16 +335,32 @@ def read_rows(
self._client._transport.read_rows
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
+ header_params = {}
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.table_name)
+ if regex_match and regex_match.group("table_name"):
+ header_params["table_name"] = regex_match.group("table_name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.authorized_view_name)
+ if regex_match and regex_match.group("authorized_view_name"):
+ header_params["authorized_view_name"] = regex_match.group(
+ "authorized_view_name"
)
+ if header_params:
+ metadata = tuple(metadata)
+ if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
+
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -438,16 +454,32 @@ def sample_row_keys(
self._client._transport.sample_row_keys
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
+ header_params = {}
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.table_name)
+ if regex_match and regex_match.group("table_name"):
+ header_params["table_name"] = regex_match.group("table_name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.authorized_view_name)
+ if regex_match and regex_match.group("authorized_view_name"):
+ header_params["authorized_view_name"] = regex_match.group(
+ "authorized_view_name"
)
+ if header_params:
+ metadata = tuple(metadata)
+ if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
+
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -562,16 +594,32 @@ async def mutate_row(
self._client._transport.mutate_row
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
+ header_params = {}
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.table_name)
+ if regex_match and regex_match.group("table_name"):
+ header_params["table_name"] = regex_match.group("table_name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.authorized_view_name)
+ if regex_match and regex_match.group("authorized_view_name"):
+ header_params["authorized_view_name"] = regex_match.group(
+ "authorized_view_name"
)
+ if header_params:
+ metadata = tuple(metadata)
+ if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
+
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -680,16 +728,32 @@ def mutate_rows(
self._client._transport.mutate_rows
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
+ header_params = {}
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.table_name)
+ if regex_match and regex_match.group("table_name"):
+ header_params["table_name"] = regex_match.group("table_name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.authorized_view_name)
+ if regex_match and regex_match.group("authorized_view_name"):
+ header_params["authorized_view_name"] = regex_match.group(
+ "authorized_view_name"
)
+ if header_params:
+ metadata = tuple(metadata)
+ if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
+
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -841,16 +905,32 @@ async def check_and_mutate_row(
self._client._transport.check_and_mutate_row
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
+ header_params = {}
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.table_name)
+ if regex_match and regex_match.group("table_name"):
+ header_params["table_name"] = regex_match.group("table_name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.authorized_view_name)
+ if regex_match and regex_match.group("authorized_view_name"):
+ header_params["authorized_view_name"] = regex_match.group(
+ "authorized_view_name"
)
+ if header_params:
+ metadata = tuple(metadata)
+ if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
+
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -941,13 +1021,20 @@ async def ping_and_warm(
self._client._transport.ping_and_warm
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
+ header_params = {}
+
+ routing_param_regex = re.compile("^(?Pprojects/[^/]+/instances/[^/]+)$")
+ regex_match = routing_param_regex.match(request.name)
+ if regex_match and regex_match.group("name"):
+ header_params["name"] = regex_match.group("name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ if header_params:
+ metadata = tuple(metadata)
if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
- )
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -1069,16 +1156,32 @@ async def read_modify_write_row(
self._client._transport.read_modify_write_row
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
+ header_params = {}
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.table_name)
+ if regex_match and regex_match.group("table_name"):
+ header_params["table_name"] = regex_match.group("table_name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ routing_param_regex = re.compile(
+ "^(?Pprojects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)$"
+ )
+ regex_match = routing_param_regex.match(request.authorized_view_name)
+ if regex_match and regex_match.group("authorized_view_name"):
+ header_params["authorized_view_name"] = regex_match.group(
+ "authorized_view_name"
)
+ if header_params:
+ metadata = tuple(metadata)
+ if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
+
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -1183,13 +1286,11 @@ def generate_initial_change_stream_partitions(
# Certain fields should be provided within the metadata header;
# add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
- )
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("table_name", request.table_name),)
+ ),
+ )
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -1287,13 +1388,11 @@ def read_change_stream(
# Certain fields should be provided within the metadata header;
# add these here.
- metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("table_name", request.table_name),)
- ),
- )
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("table_name", request.table_name),)
+ ),
+ )
# Validate the universe domain.
self._client._validate_universe_domain()
@@ -1390,15 +1489,20 @@ def execute_query(
self._client._transport.execute_query
]
- # Certain fields should be provided within the metadata header;
- # add these here.
- metadata = tuple(metadata)
+ header_params = {}
+
+ routing_param_regex = re.compile("^(?Pprojects/[^/]+/instances/[^/]+)$")
+ regex_match = routing_param_regex.match(request.instance_name)
+ if regex_match and regex_match.group("name"):
+ header_params["name"] = regex_match.group("name")
+
+ if request.app_profile_id:
+ header_params["app_profile_id"] = request.app_profile_id
+
+ if header_params:
+ metadata = tuple(metadata)
if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += (
- gapic_v1.routing_header.to_grpc_metadata(
- (("instance_name", request.instance_name),)
- ),
- )
+ metadata += (gapic_v1.routing_header.to_grpc_metadata(header_params),)
# Validate the universe domain.
self._client._validate_universe_domain()
diff --git a/google/cloud/bigtable_v2/services/bigtable/client.py b/google/cloud/bigtable_v2/services/bigtable/client.py
index 86fa6b3a5..a2534d539 100644
--- a/google/cloud/bigtable_v2/services/bigtable/client.py
+++ b/google/cloud/bigtable_v2/services/bigtable/client.py
@@ -55,7 +55,6 @@
from .transports.base import BigtableTransport, DEFAULT_CLIENT_INFO
from .transports.grpc import BigtableGrpcTransport
from .transports.grpc_asyncio import BigtableGrpcAsyncIOTransport
-from .transports.pooled_grpc_asyncio import PooledBigtableGrpcAsyncIOTransport
from .transports.rest import BigtableRestTransport
@@ -70,7 +69,6 @@ class BigtableClientMeta(type):
_transport_registry = OrderedDict() # type: Dict[str, Type[BigtableTransport]]
_transport_registry["grpc"] = BigtableGrpcTransport
_transport_registry["grpc_asyncio"] = BigtableGrpcAsyncIOTransport
- _transport_registry["pooled_grpc_asyncio"] = PooledBigtableGrpcAsyncIOTransport
_transport_registry["rest"] = BigtableRestTransport
def get_transport_class(
@@ -505,36 +503,6 @@ def _get_universe_domain(
raise ValueError("Universe Domain cannot be an empty string.")
return universe_domain
- @staticmethod
- def _compare_universes(
- client_universe: str, credentials: ga_credentials.Credentials
- ) -> bool:
- """Returns True iff the universe domains used by the client and credentials match.
-
- Args:
- client_universe (str): The universe domain configured via the client options.
- credentials (ga_credentials.Credentials): The credentials being used in the client.
-
- Returns:
- bool: True iff client_universe matches the universe in credentials.
-
- Raises:
- ValueError: when client_universe does not match the universe in credentials.
- """
-
- default_universe = BigtableClient._DEFAULT_UNIVERSE
- credentials_universe = getattr(credentials, "universe_domain", default_universe)
-
- if client_universe != credentials_universe:
- raise ValueError(
- "The configured universe domain "
- f"({client_universe}) does not match the universe domain "
- f"found in the credentials ({credentials_universe}). "
- "If you haven't configured the universe domain explicitly, "
- f"`{default_universe}` is the default."
- )
- return True
-
def _validate_universe_domain(self):
"""Validates client's and credentials' universe domains are consistent.
@@ -544,13 +512,9 @@ def _validate_universe_domain(self):
Raises:
ValueError: If the configured universe domain is not valid.
"""
- self._is_universe_domain_valid = (
- self._is_universe_domain_valid
- or BigtableClient._compare_universes(
- self.universe_domain, self.transport._credentials
- )
- )
- return self._is_universe_domain_valid
+
+ # NOTE (b/349488459): universe validation is disabled until further notice.
+ return True
@property
def api_endpoint(self):
diff --git a/google/cloud/bigtable_v2/services/bigtable/transports/README.rst b/google/cloud/bigtable_v2/services/bigtable/transports/README.rst
new file mode 100644
index 000000000..254812cd3
--- /dev/null
+++ b/google/cloud/bigtable_v2/services/bigtable/transports/README.rst
@@ -0,0 +1,9 @@
+
+transport inheritance structure
+_______________________________
+
+`BigtableTransport` is the ABC for all transports.
+- public child `BigtableGrpcTransport` for sync gRPC transport (defined in `grpc.py`).
+- public child `BigtableGrpcAsyncIOTransport` for async gRPC transport (defined in `grpc_asyncio.py`).
+- private child `_BaseBigtableRestTransport` for base REST transport with inner classes `_BaseMETHOD` (defined in `rest_base.py`).
+- public child `BigtableRestTransport` for sync REST transport with inner classes `METHOD` derived from the parent's corresponding `_BaseMETHOD` classes (defined in `rest.py`).
diff --git a/google/cloud/bigtable_v2/services/bigtable/transports/__init__.py b/google/cloud/bigtable_v2/services/bigtable/transports/__init__.py
index ae5c1cf72..ae007bc2b 100644
--- a/google/cloud/bigtable_v2/services/bigtable/transports/__init__.py
+++ b/google/cloud/bigtable_v2/services/bigtable/transports/__init__.py
@@ -19,7 +19,6 @@
from .base import BigtableTransport
from .grpc import BigtableGrpcTransport
from .grpc_asyncio import BigtableGrpcAsyncIOTransport
-from .pooled_grpc_asyncio import PooledBigtableGrpcAsyncIOTransport
from .rest import BigtableRestTransport
from .rest import BigtableRestInterceptor
@@ -28,14 +27,12 @@
_transport_registry = OrderedDict() # type: Dict[str, Type[BigtableTransport]]
_transport_registry["grpc"] = BigtableGrpcTransport
_transport_registry["grpc_asyncio"] = BigtableGrpcAsyncIOTransport
-_transport_registry["pooled_grpc_asyncio"] = PooledBigtableGrpcAsyncIOTransport
_transport_registry["rest"] = BigtableRestTransport
__all__ = (
"BigtableTransport",
"BigtableGrpcTransport",
"BigtableGrpcAsyncIOTransport",
- "PooledBigtableGrpcAsyncIOTransport",
"BigtableRestTransport",
"BigtableRestInterceptor",
)
diff --git a/google/cloud/bigtable_v2/services/bigtable/transports/grpc_asyncio.py b/google/cloud/bigtable_v2/services/bigtable/transports/grpc_asyncio.py
index 40d6a3fa4..6f6e1fe85 100644
--- a/google/cloud/bigtable_v2/services/bigtable/transports/grpc_asyncio.py
+++ b/google/cloud/bigtable_v2/services/bigtable/transports/grpc_asyncio.py
@@ -13,6 +13,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
+import inspect
import warnings
from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
@@ -228,6 +229,9 @@ def __init__(
)
# Wrap messages. This must be done after self._grpc_channel exists
+ self._wrap_with_kind = (
+ "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters
+ )
self._prep_wrapped_messages(client_info)
@property
@@ -551,17 +555,17 @@ def execute_query(
def _prep_wrapped_messages(self, client_info):
"""Precompute the wrapped methods, overriding the base class method to use async wrappers."""
self._wrapped_methods = {
- self.read_rows: gapic_v1.method_async.wrap_method(
+ self.read_rows: self._wrap_method(
self.read_rows,
default_timeout=43200.0,
client_info=client_info,
),
- self.sample_row_keys: gapic_v1.method_async.wrap_method(
+ self.sample_row_keys: self._wrap_method(
self.sample_row_keys,
default_timeout=60.0,
client_info=client_info,
),
- self.mutate_row: gapic_v1.method_async.wrap_method(
+ self.mutate_row: self._wrap_method(
self.mutate_row,
default_retry=retries.AsyncRetry(
initial=0.01,
@@ -576,45 +580,54 @@ def _prep_wrapped_messages(self, client_info):
default_timeout=60.0,
client_info=client_info,
),
- self.mutate_rows: gapic_v1.method_async.wrap_method(
+ self.mutate_rows: self._wrap_method(
self.mutate_rows,
default_timeout=600.0,
client_info=client_info,
),
- self.check_and_mutate_row: gapic_v1.method_async.wrap_method(
+ self.check_and_mutate_row: self._wrap_method(
self.check_and_mutate_row,
default_timeout=20.0,
client_info=client_info,
),
- self.ping_and_warm: gapic_v1.method_async.wrap_method(
+ self.ping_and_warm: self._wrap_method(
self.ping_and_warm,
default_timeout=None,
client_info=client_info,
),
- self.read_modify_write_row: gapic_v1.method_async.wrap_method(
+ self.read_modify_write_row: self._wrap_method(
self.read_modify_write_row,
default_timeout=20.0,
client_info=client_info,
),
- self.generate_initial_change_stream_partitions: gapic_v1.method_async.wrap_method(
+ self.generate_initial_change_stream_partitions: self._wrap_method(
self.generate_initial_change_stream_partitions,
default_timeout=60.0,
client_info=client_info,
),
- self.read_change_stream: gapic_v1.method_async.wrap_method(
+ self.read_change_stream: self._wrap_method(
self.read_change_stream,
default_timeout=43200.0,
client_info=client_info,
),
- self.execute_query: gapic_v1.method_async.wrap_method(
+ self.execute_query: self._wrap_method(
self.execute_query,
default_timeout=None,
client_info=client_info,
),
}
+ def _wrap_method(self, func, *args, **kwargs):
+ if self._wrap_with_kind: # pragma: NO COVER
+ kwargs["kind"] = self.kind
+ return gapic_v1.method_async.wrap_method(func, *args, **kwargs)
+
def close(self):
return self.grpc_channel.close()
+ @property
+ def kind(self) -> str:
+ return "grpc_asyncio"
+
__all__ = ("BigtableGrpcAsyncIOTransport",)
diff --git a/google/cloud/bigtable_v2/services/bigtable/transports/pooled_grpc_asyncio.py b/google/cloud/bigtable_v2/services/bigtable/transports/pooled_grpc_asyncio.py
deleted file mode 100644
index 372e5796d..000000000
--- a/google/cloud/bigtable_v2/services/bigtable/transports/pooled_grpc_asyncio.py
+++ /dev/null
@@ -1,426 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2022 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 asyncio
-import warnings
-from functools import partialmethod
-from functools import partial
-from typing import (
- Awaitable,
- Callable,
- Dict,
- Optional,
- Sequence,
- Tuple,
- Union,
- List,
- Type,
-)
-
-from google.api_core import gapic_v1
-from google.api_core import grpc_helpers_async
-from google.auth import credentials as ga_credentials # type: ignore
-from google.auth.transport.grpc import SslCredentials # type: ignore
-
-import grpc # type: ignore
-from grpc.experimental import aio # type: ignore
-
-from google.cloud.bigtable_v2.types import bigtable
-from .base import BigtableTransport, DEFAULT_CLIENT_INFO
-from .grpc_asyncio import BigtableGrpcAsyncIOTransport
-
-
-class PooledMultiCallable:
- def __init__(self, channel_pool: "PooledChannel", *args, **kwargs):
- self._init_args = args
- self._init_kwargs = kwargs
- self.next_channel_fn = channel_pool.next_channel
-
-
-class PooledUnaryUnaryMultiCallable(PooledMultiCallable, aio.UnaryUnaryMultiCallable):
- def __call__(self, *args, **kwargs) -> aio.UnaryUnaryCall:
- return self.next_channel_fn().unary_unary(
- *self._init_args, **self._init_kwargs
- )(*args, **kwargs)
-
-
-class PooledUnaryStreamMultiCallable(PooledMultiCallable, aio.UnaryStreamMultiCallable):
- def __call__(self, *args, **kwargs) -> aio.UnaryStreamCall:
- return self.next_channel_fn().unary_stream(
- *self._init_args, **self._init_kwargs
- )(*args, **kwargs)
-
-
-class PooledStreamUnaryMultiCallable(PooledMultiCallable, aio.StreamUnaryMultiCallable):
- def __call__(self, *args, **kwargs) -> aio.StreamUnaryCall:
- return self.next_channel_fn().stream_unary(
- *self._init_args, **self._init_kwargs
- )(*args, **kwargs)
-
-
-class PooledStreamStreamMultiCallable(
- PooledMultiCallable, aio.StreamStreamMultiCallable
-):
- def __call__(self, *args, **kwargs) -> aio.StreamStreamCall:
- return self.next_channel_fn().stream_stream(
- *self._init_args, **self._init_kwargs
- )(*args, **kwargs)
-
-
-class PooledChannel(aio.Channel):
- def __init__(
- self,
- pool_size: int = 3,
- host: str = "bigtable.googleapis.com",
- credentials: Optional[ga_credentials.Credentials] = None,
- credentials_file: Optional[str] = None,
- quota_project_id: Optional[str] = None,
- default_scopes: Optional[Sequence[str]] = None,
- scopes: Optional[Sequence[str]] = None,
- default_host: Optional[str] = None,
- insecure: bool = False,
- **kwargs,
- ):
- self._pool: List[aio.Channel] = []
- self._next_idx = 0
- if insecure:
- self._create_channel = partial(aio.insecure_channel, host)
- else:
- self._create_channel = partial(
- grpc_helpers_async.create_channel,
- target=host,
- credentials=credentials,
- credentials_file=credentials_file,
- quota_project_id=quota_project_id,
- default_scopes=default_scopes,
- scopes=scopes,
- default_host=default_host,
- **kwargs,
- )
- for i in range(pool_size):
- self._pool.append(self._create_channel())
-
- def next_channel(self) -> aio.Channel:
- channel = self._pool[self._next_idx]
- self._next_idx = (self._next_idx + 1) % len(self._pool)
- return channel
-
- def unary_unary(self, *args, **kwargs) -> grpc.aio.UnaryUnaryMultiCallable:
- return PooledUnaryUnaryMultiCallable(self, *args, **kwargs)
-
- def unary_stream(self, *args, **kwargs) -> grpc.aio.UnaryStreamMultiCallable:
- return PooledUnaryStreamMultiCallable(self, *args, **kwargs)
-
- def stream_unary(self, *args, **kwargs) -> grpc.aio.StreamUnaryMultiCallable:
- return PooledStreamUnaryMultiCallable(self, *args, **kwargs)
-
- def stream_stream(self, *args, **kwargs) -> grpc.aio.StreamStreamMultiCallable:
- return PooledStreamStreamMultiCallable(self, *args, **kwargs)
-
- async def close(self, grace=None):
- close_fns = [channel.close(grace=grace) for channel in self._pool]
- return await asyncio.gather(*close_fns)
-
- async def channel_ready(self):
- ready_fns = [channel.channel_ready() for channel in self._pool]
- return asyncio.gather(*ready_fns)
-
- async def __aenter__(self):
- return self
-
- async def __aexit__(self, exc_type, exc_val, exc_tb):
- await self.close()
-
- def get_state(self, try_to_connect: bool = False) -> grpc.ChannelConnectivity:
- raise NotImplementedError()
-
- async def wait_for_state_change(self, last_observed_state):
- raise NotImplementedError()
-
- async def replace_channel(
- self, channel_idx, grace=None, swap_sleep=1, new_channel=None
- ) -> aio.Channel:
- """
- Replaces a channel in the pool with a fresh one.
-
- The `new_channel` will start processing new requests immidiately,
- but the old channel will continue serving existing clients for `grace` seconds
-
- Args:
- channel_idx(int): the channel index in the pool to replace
- grace(Optional[float]): The time to wait until all active RPCs are
- finished. If a grace period is not specified (by passing None for
- grace), all existing RPCs are cancelled immediately.
- swap_sleep(Optional[float]): The number of seconds to sleep in between
- replacing channels and closing the old one
- new_channel(grpc.aio.Channel): a new channel to insert into the pool
- at `channel_idx`. If `None`, a new channel will be created.
- """
- if channel_idx >= len(self._pool) or channel_idx < 0:
- raise ValueError(
- f"invalid channel_idx {channel_idx} for pool size {len(self._pool)}"
- )
- if new_channel is None:
- new_channel = self._create_channel()
- old_channel = self._pool[channel_idx]
- self._pool[channel_idx] = new_channel
- await asyncio.sleep(swap_sleep)
- await old_channel.close(grace=grace)
- return new_channel
-
-
-class PooledBigtableGrpcAsyncIOTransport(BigtableGrpcAsyncIOTransport):
- """Pooled gRPC AsyncIO backend transport for Bigtable.
-
- Service for reading from and writing to existing Bigtable
- tables.
-
- This class defines the same methods as the primary client, so the
- primary client can load the underlying transport implementation
- and call it.
-
- It sends protocol buffers over the wire using gRPC (which is built on
- top of HTTP/2); the ``grpcio`` package must be installed.
-
- This class allows channel pooling, so multiple channels can be used concurrently
- when making requests. Channels are rotated in a round-robin fashion.
- """
-
- @classmethod
- def with_fixed_size(cls, pool_size) -> Type["PooledBigtableGrpcAsyncIOTransport"]:
- """
- Creates a new class with a fixed channel pool size.
-
- A fixed channel pool makes compatibility with other transports easier,
- as the initializer signature is the same.
- """
-
- class PooledTransportFixed(cls):
- __init__ = partialmethod(cls.__init__, pool_size=pool_size)
-
- PooledTransportFixed.__name__ = f"{cls.__name__}_{pool_size}"
- PooledTransportFixed.__qualname__ = PooledTransportFixed.__name__
- return PooledTransportFixed
-
- @classmethod
- def create_channel(
- cls,
- pool_size: int = 3,
- host: str = "bigtable.googleapis.com",
- credentials: Optional[ga_credentials.Credentials] = None,
- credentials_file: Optional[str] = None,
- scopes: Optional[Sequence[str]] = None,
- quota_project_id: Optional[str] = None,
- **kwargs,
- ) -> aio.Channel:
- """Create and return a PooledChannel object, representing a pool of gRPC AsyncIO channels
- Args:
- pool_size (int): The number of channels in the pool.
- host (Optional[str]): The host for the channel to use.
- credentials (Optional[~.Credentials]): The
- authorization credentials to attach to requests. These
- credentials identify this application to the service. If
- none are specified, the client will attempt to ascertain
- the credentials from the environment.
- credentials_file (Optional[str]): A file with credentials that can
- be loaded with :func:`google.auth.load_credentials_from_file`.
- This argument is ignored if ``channel`` is provided.
- scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
- service. These are only used when credentials are not specified and
- are passed to :func:`google.auth.default`.
- quota_project_id (Optional[str]): An optional project to use for billing
- and quota.
- kwargs (Optional[dict]): Keyword arguments, which are passed to the
- channel creation.
- Returns:
- PooledChannel: a channel pool object
- """
-
- return PooledChannel(
- pool_size,
- host,
- credentials=credentials,
- credentials_file=credentials_file,
- quota_project_id=quota_project_id,
- default_scopes=cls.AUTH_SCOPES,
- scopes=scopes,
- default_host=cls.DEFAULT_HOST,
- **kwargs,
- )
-
- def __init__(
- self,
- *,
- pool_size: int = 3,
- host: str = "bigtable.googleapis.com",
- credentials: Optional[ga_credentials.Credentials] = None,
- credentials_file: Optional[str] = None,
- scopes: Optional[Sequence[str]] = None,
- api_mtls_endpoint: Optional[str] = None,
- client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
- ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
- client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
- quota_project_id: Optional[str] = None,
- client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
- always_use_jwt_access: Optional[bool] = False,
- api_audience: Optional[str] = None,
- ) -> None:
- """Instantiate the transport.
-
- Args:
- pool_size (int): the number of grpc channels to maintain in a pool
- host (Optional[str]):
- The hostname to connect to.
- credentials (Optional[google.auth.credentials.Credentials]): The
- authorization credentials to attach to requests. These
- credentials identify the application to the service; if none
- are specified, the client will attempt to ascertain the
- credentials from the environment.
- This argument is ignored if ``channel`` is provided.
- credentials_file (Optional[str]): A file with credentials that can
- be loaded with :func:`google.auth.load_credentials_from_file`.
- This argument is ignored if ``channel`` is provided.
- scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
- service. These are only used when credentials are not specified and
- are passed to :func:`google.auth.default`.
- api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
- If provided, it overrides the ``host`` argument and tries to create
- a mutual TLS channel with client SSL credentials from
- ``client_cert_source`` or application default SSL credentials.
- client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
- Deprecated. A callback to provide client SSL certificate bytes and
- private key bytes, both in PEM format. It is ignored if
- ``api_mtls_endpoint`` is None.
- ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
- for the grpc channel. It is ignored if ``channel`` is provided.
- client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
- A callback to provide client certificate bytes and private key bytes,
- both in PEM format. It is used to configure a mutual TLS channel. It is
- ignored if ``channel`` or ``ssl_channel_credentials`` is provided.
- quota_project_id (Optional[str]): An optional project to use for billing
- and quota.
- client_info (google.api_core.gapic_v1.client_info.ClientInfo):
- The client info used to send a user-agent string along with
- API requests. If ``None``, then default info will be used.
- Generally, you only need to set this if you're developing
- your own client library.
- always_use_jwt_access (Optional[bool]): Whether self signed JWT should
- be used for service account credentials.
-
- Raises:
- google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
- creation failed for any reason.
- google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
- and ``credentials_file`` are passed.
- ValueError: if ``pool_size`` <= 0
- """
- if pool_size <= 0:
- raise ValueError(f"invalid pool_size: {pool_size}")
- self._ssl_channel_credentials = ssl_channel_credentials
- self._stubs: Dict[str, Callable] = {}
-
- if api_mtls_endpoint:
- warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
- if client_cert_source:
- warnings.warn("client_cert_source is deprecated", DeprecationWarning)
-
- if api_mtls_endpoint:
- host = api_mtls_endpoint
-
- # Create SSL credentials with client_cert_source or application
- # default SSL credentials.
- if client_cert_source:
- cert, key = client_cert_source()
- self._ssl_channel_credentials = grpc.ssl_channel_credentials(
- certificate_chain=cert, private_key=key
- )
- else:
- self._ssl_channel_credentials = SslCredentials().ssl_credentials
-
- else:
- if client_cert_source_for_mtls and not ssl_channel_credentials:
- cert, key = client_cert_source_for_mtls()
- self._ssl_channel_credentials = grpc.ssl_channel_credentials(
- certificate_chain=cert, private_key=key
- )
-
- # The base transport sets the host, credentials and scopes
- BigtableTransport.__init__(
- self,
- host=host,
- credentials=credentials,
- credentials_file=credentials_file,
- scopes=scopes,
- quota_project_id=quota_project_id,
- client_info=client_info,
- always_use_jwt_access=always_use_jwt_access,
- api_audience=api_audience,
- )
- self._quota_project_id = quota_project_id
- self._grpc_channel = type(self).create_channel(
- pool_size,
- self._host,
- # use the credentials which are saved
- credentials=self._credentials,
- # Set ``credentials_file`` to ``None`` here as
- # the credentials that we saved earlier should be used.
- credentials_file=None,
- scopes=self._scopes,
- ssl_credentials=self._ssl_channel_credentials,
- quota_project_id=self._quota_project_id,
- options=[
- ("grpc.max_send_message_length", -1),
- ("grpc.max_receive_message_length", -1),
- ],
- )
-
- # Wrap messages. This must be done after self._grpc_channel exists
- self._prep_wrapped_messages(client_info)
-
- @property
- def pool_size(self) -> int:
- """The number of grpc channels in the pool."""
- return len(self._grpc_channel._pool)
-
- @property
- def channels(self) -> List[grpc.Channel]:
- """Acccess the internal list of grpc channels."""
- return self._grpc_channel._pool
-
- async def replace_channel(
- self, channel_idx, grace=None, swap_sleep=1, new_channel=None
- ) -> aio.Channel:
- """
- Replaces a channel in the pool with a fresh one.
-
- The `new_channel` will start processing new requests immidiately,
- but the old channel will continue serving existing clients for `grace` seconds
-
- Args:
- channel_idx(int): the channel index in the pool to replace
- grace(Optional[float]): The time to wait until all active RPCs are
- finished. If a grace period is not specified (by passing None for
- grace), all existing RPCs are cancelled immediately.
- swap_sleep(Optional[float]): The number of seconds to sleep in between
- replacing channels and closing the old one
- new_channel(grpc.aio.Channel): a new channel to insert into the pool
- at `channel_idx`. If `None`, a new channel will be created.
- """
- return await self._grpc_channel.replace_channel(
- channel_idx, grace, swap_sleep, new_channel
- )
-
-
-__all__ = ("PooledBigtableGrpcAsyncIOTransport",)
diff --git a/google/cloud/bigtable_v2/services/bigtable/transports/rest.py b/google/cloud/bigtable_v2/services/bigtable/transports/rest.py
index a3391005f..221b04b8a 100644
--- a/google/cloud/bigtable_v2/services/bigtable/transports/rest.py
+++ b/google/cloud/bigtable_v2/services/bigtable/transports/rest.py
@@ -16,38 +16,37 @@
from google.auth.transport.requests import AuthorizedSession # type: ignore
import json # type: ignore
-import grpc # type: ignore
-from google.auth.transport.grpc import SslCredentials # type: ignore
from google.auth import credentials as ga_credentials # type: ignore
from google.api_core import exceptions as core_exceptions
from google.api_core import retry as retries
from google.api_core import rest_helpers
from google.api_core import rest_streaming
-from google.api_core import path_template
from google.api_core import gapic_v1
from google.protobuf import json_format
+
from requests import __version__ as requests_version
import dataclasses
-import re
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
import warnings
+
+from google.cloud.bigtable_v2.types import bigtable
+
+
+from .rest_base import _BaseBigtableRestTransport
+from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
+
try:
OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
except AttributeError: # pragma: NO COVER
OptionalRetry = Union[retries.Retry, object, None] # type: ignore
-from google.cloud.bigtable_v2.types import bigtable
-
-from .base import BigtableTransport, DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
-
-
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
grpc_version=None,
- rest_version=requests_version,
+ rest_version=f"requests@{requests_version}",
)
@@ -382,8 +381,8 @@ class BigtableRestStub:
_interceptor: BigtableRestInterceptor
-class BigtableRestTransport(BigtableTransport):
- """REST backend transport for Bigtable.
+class BigtableRestTransport(_BaseBigtableRestTransport):
+ """REST backend synchronous transport for Bigtable.
Service for reading from and writing to existing Bigtable
tables.
@@ -393,7 +392,6 @@ class BigtableRestTransport(BigtableTransport):
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
-
"""
def __init__(
@@ -447,21 +445,12 @@ def __init__(
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
- maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host)
- if maybe_url_match is None:
- raise ValueError(
- f"Unexpected hostname structure: {host}"
- ) # pragma: NO COVER
-
- url_match_items = maybe_url_match.groupdict()
-
- host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
-
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
always_use_jwt_access=always_use_jwt_access,
+ url_scheme=url_scheme,
api_audience=api_audience,
)
self._session = AuthorizedSession(
@@ -472,19 +461,34 @@ def __init__(
self._interceptor = interceptor or BigtableRestInterceptor()
self._prep_wrapped_messages(client_info)
- class _CheckAndMutateRow(BigtableRestStub):
+ class _CheckAndMutateRow(
+ _BaseBigtableRestTransport._BaseCheckAndMutateRow, BigtableRestStub
+ ):
def __hash__(self):
- return hash("CheckAndMutateRow")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.CheckAndMutateRow")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -513,52 +517,34 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:checkAndMutateRow",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:checkAndMutateRow",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseCheckAndMutateRow._get_http_options()
+ )
request, metadata = self._interceptor.pre_check_and_mutate_row(
request, metadata
)
- pb_request = bigtable.CheckAndMutateRowRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableRestTransport._BaseCheckAndMutateRow._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseCheckAndMutateRow._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableRestTransport._BaseCheckAndMutateRow._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._CheckAndMutateRow._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -574,19 +560,33 @@ def __call__(
resp = self._interceptor.post_check_and_mutate_row(resp)
return resp
- class _ExecuteQuery(BigtableRestStub):
+ class _ExecuteQuery(_BaseBigtableRestTransport._BaseExecuteQuery, BigtableRestStub):
def __hash__(self):
- return hash("ExecuteQuery")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.ExecuteQuery")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ stream=True,
+ )
+ return response
def __call__(
self,
@@ -615,45 +615,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{instance_name=projects/*/instances/*}:executeQuery",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseExecuteQuery._get_http_options()
+ )
request, metadata = self._interceptor.pre_execute_query(request, metadata)
- pb_request = bigtable.ExecuteQueryRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = (
+ _BaseBigtableRestTransport._BaseExecuteQuery._get_transcoded_request(
+ http_options, request
+ )
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseExecuteQuery._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BaseExecuteQuery._get_query_params_json(
+ transcoded_request
)
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._ExecuteQuery._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -668,19 +659,36 @@ def __call__(
resp = self._interceptor.post_execute_query(resp)
return resp
- class _GenerateInitialChangeStreamPartitions(BigtableRestStub):
+ class _GenerateInitialChangeStreamPartitions(
+ _BaseBigtableRestTransport._BaseGenerateInitialChangeStreamPartitions,
+ BigtableRestStub,
+ ):
def __hash__(self):
- return hash("GenerateInitialChangeStreamPartitions")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.GenerateInitialChangeStreamPartitions")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ stream=True,
+ )
+ return response
def __call__(
self,
@@ -714,52 +722,37 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:generateInitialChangeStreamPartitions",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseGenerateInitialChangeStreamPartitions._get_http_options()
+ )
(
request,
metadata,
) = self._interceptor.pre_generate_initial_change_stream_partitions(
request, metadata
)
- pb_request = bigtable.GenerateInitialChangeStreamPartitionsRequest.pb(
- request
+ transcoded_request = _BaseBigtableRestTransport._BaseGenerateInitialChangeStreamPartitions._get_transcoded_request(
+ http_options, request
)
- transcoded_request = path_template.transcode(http_options, pb_request)
- # Jsonify the request body
-
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseGenerateInitialChangeStreamPartitions._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableRestTransport._BaseGenerateInitialChangeStreamPartitions._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._GenerateInitialChangeStreamPartitions._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -776,19 +769,32 @@ def __call__(
)
return resp
- class _MutateRow(BigtableRestStub):
+ class _MutateRow(_BaseBigtableRestTransport._BaseMutateRow, BigtableRestStub):
def __hash__(self):
- return hash("MutateRow")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.MutateRow")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -817,50 +823,34 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:mutateRow",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:mutateRow",
- "body": "*",
- },
- ]
+ http_options = _BaseBigtableRestTransport._BaseMutateRow._get_http_options()
request, metadata = self._interceptor.pre_mutate_row(request, metadata)
- pb_request = bigtable.MutateRowRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = (
+ _BaseBigtableRestTransport._BaseMutateRow._get_transcoded_request(
+ http_options, request
+ )
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseMutateRow._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BaseMutateRow._get_query_params_json(
+ transcoded_request
)
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._MutateRow._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -876,19 +866,33 @@ def __call__(
resp = self._interceptor.post_mutate_row(resp)
return resp
- class _MutateRows(BigtableRestStub):
+ class _MutateRows(_BaseBigtableRestTransport._BaseMutateRows, BigtableRestStub):
def __hash__(self):
- return hash("MutateRows")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.MutateRows")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ stream=True,
+ )
+ return response
def __call__(
self,
@@ -917,50 +921,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:mutateRows",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:mutateRows",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseMutateRows._get_http_options()
+ )
request, metadata = self._interceptor.pre_mutate_rows(request, metadata)
- pb_request = bigtable.MutateRowsRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = (
+ _BaseBigtableRestTransport._BaseMutateRows._get_transcoded_request(
+ http_options, request
+ )
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseMutateRows._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BaseMutateRows._get_query_params_json(
+ transcoded_request
)
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._MutateRows._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -975,19 +965,32 @@ def __call__(
resp = self._interceptor.post_mutate_rows(resp)
return resp
- class _PingAndWarm(BigtableRestStub):
+ class _PingAndWarm(_BaseBigtableRestTransport._BasePingAndWarm, BigtableRestStub):
def __hash__(self):
- return hash("PingAndWarm")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.PingAndWarm")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1017,45 +1020,36 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{name=projects/*/instances/*}:ping",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BasePingAndWarm._get_http_options()
+ )
request, metadata = self._interceptor.pre_ping_and_warm(request, metadata)
- pb_request = bigtable.PingAndWarmRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = (
+ _BaseBigtableRestTransport._BasePingAndWarm._get_transcoded_request(
+ http_options, request
+ )
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BasePingAndWarm._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BasePingAndWarm._get_query_params_json(
+ transcoded_request
)
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._PingAndWarm._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1071,19 +1065,35 @@ def __call__(
resp = self._interceptor.post_ping_and_warm(resp)
return resp
- class _ReadChangeStream(BigtableRestStub):
+ class _ReadChangeStream(
+ _BaseBigtableRestTransport._BaseReadChangeStream, BigtableRestStub
+ ):
def __hash__(self):
- return hash("ReadChangeStream")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.ReadChangeStream")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ stream=True,
+ )
+ return response
def __call__(
self,
@@ -1114,47 +1124,38 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:readChangeStream",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseReadChangeStream._get_http_options()
+ )
request, metadata = self._interceptor.pre_read_change_stream(
request, metadata
)
- pb_request = bigtable.ReadChangeStreamRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableRestTransport._BaseReadChangeStream._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = (
+ _BaseBigtableRestTransport._BaseReadChangeStream._get_request_body_json(
+ transcoded_request
+ )
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BaseReadChangeStream._get_query_params_json(
+ transcoded_request
)
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._ReadChangeStream._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1169,19 +1170,34 @@ def __call__(
resp = self._interceptor.post_read_change_stream(resp)
return resp
- class _ReadModifyWriteRow(BigtableRestStub):
+ class _ReadModifyWriteRow(
+ _BaseBigtableRestTransport._BaseReadModifyWriteRow, BigtableRestStub
+ ):
def __hash__(self):
- return hash("ReadModifyWriteRow")
-
- __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
-
- @classmethod
- def _get_unset_required_fields(cls, message_dict):
- return {
- k: v
- for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
- if k not in message_dict
- }
+ return hash("BigtableRestTransport.ReadModifyWriteRow")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+ return response
def __call__(
self,
@@ -1210,52 +1226,34 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:readModifyWriteRow",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:readModifyWriteRow",
- "body": "*",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseReadModifyWriteRow._get_http_options()
+ )
request, metadata = self._interceptor.pre_read_modify_write_row(
request, metadata
)
- pb_request = bigtable.ReadModifyWriteRowRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = _BaseBigtableRestTransport._BaseReadModifyWriteRow._get_transcoded_request(
+ http_options, request
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseReadModifyWriteRow._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
- )
+ query_params = _BaseBigtableRestTransport._BaseReadModifyWriteRow._get_query_params_json(
+ transcoded_request
)
- query_params.update(self._get_unset_required_fields(query_params))
-
- query_params["$alt"] = "json;enum-encoding=int"
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._ReadModifyWriteRow._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1271,9 +1269,33 @@ def __call__(
resp = self._interceptor.post_read_modify_write_row(resp)
return resp
- class _ReadRows(BigtableRestStub):
+ class _ReadRows(_BaseBigtableRestTransport._BaseReadRows, BigtableRestStub):
def __hash__(self):
- return hash("ReadRows")
+ return hash("BigtableRestTransport.ReadRows")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ stream=True,
+ )
+ return response
def __call__(
self,
@@ -1302,49 +1324,34 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "post",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:readRows",
- "body": "*",
- },
- {
- "method": "post",
- "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:readRows",
- "body": "*",
- },
- ]
+ http_options = _BaseBigtableRestTransport._BaseReadRows._get_http_options()
request, metadata = self._interceptor.pre_read_rows(request, metadata)
- pb_request = bigtable.ReadRowsRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- # Jsonify the request body
+ transcoded_request = (
+ _BaseBigtableRestTransport._BaseReadRows._get_transcoded_request(
+ http_options, request
+ )
+ )
- body = json_format.MessageToJson(
- transcoded_request["body"], use_integers_for_enums=True
+ body = _BaseBigtableRestTransport._BaseReadRows._get_request_body_json(
+ transcoded_request
)
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BaseReadRows._get_query_params_json(
+ transcoded_request
)
)
- query_params["$alt"] = "json;enum-encoding=int"
-
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
- data=body,
+ response = BigtableRestTransport._ReadRows._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
+ body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
@@ -1357,9 +1364,34 @@ def __call__(
resp = self._interceptor.post_read_rows(resp)
return resp
- class _SampleRowKeys(BigtableRestStub):
+ class _SampleRowKeys(
+ _BaseBigtableRestTransport._BaseSampleRowKeys, BigtableRestStub
+ ):
def __hash__(self):
- return hash("SampleRowKeys")
+ return hash("BigtableRestTransport.SampleRowKeys")
+
+ @staticmethod
+ def _get_response(
+ host,
+ metadata,
+ query_params,
+ session,
+ timeout,
+ transcoded_request,
+ body=None,
+ ):
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(session, method)(
+ "{host}{uri}".format(host=host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ stream=True,
+ )
+ return response
def __call__(
self,
@@ -1388,41 +1420,31 @@ def __call__(
"""
- http_options: List[Dict[str, str]] = [
- {
- "method": "get",
- "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:sampleRowKeys",
- },
- {
- "method": "get",
- "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:sampleRowKeys",
- },
- ]
+ http_options = (
+ _BaseBigtableRestTransport._BaseSampleRowKeys._get_http_options()
+ )
request, metadata = self._interceptor.pre_sample_row_keys(request, metadata)
- pb_request = bigtable.SampleRowKeysRequest.pb(request)
- transcoded_request = path_template.transcode(http_options, pb_request)
-
- uri = transcoded_request["uri"]
- method = transcoded_request["method"]
+ transcoded_request = (
+ _BaseBigtableRestTransport._BaseSampleRowKeys._get_transcoded_request(
+ http_options, request
+ )
+ )
# Jsonify the query params
- query_params = json.loads(
- json_format.MessageToJson(
- transcoded_request["query_params"],
- use_integers_for_enums=True,
+ query_params = (
+ _BaseBigtableRestTransport._BaseSampleRowKeys._get_query_params_json(
+ transcoded_request
)
)
- query_params["$alt"] = "json;enum-encoding=int"
-
# Send the request
- headers = dict(metadata)
- headers["Content-Type"] = "application/json"
- response = getattr(self._session, method)(
- "{host}{uri}".format(host=self._host, uri=uri),
- timeout=timeout,
- headers=headers,
- params=rest_helpers.flatten_query_params(query_params, strict=True),
+ response = BigtableRestTransport._SampleRowKeys._get_response(
+ self._host,
+ metadata,
+ query_params,
+ self._session,
+ timeout,
+ transcoded_request,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
diff --git a/google/cloud/bigtable_v2/services/bigtable/transports/rest_base.py b/google/cloud/bigtable_v2/services/bigtable/transports/rest_base.py
new file mode 100644
index 000000000..9d2292a3c
--- /dev/null
+++ b/google/cloud/bigtable_v2/services/bigtable/transports/rest_base.py
@@ -0,0 +1,654 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 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 json # type: ignore
+from google.api_core import path_template
+from google.api_core import gapic_v1
+
+from google.protobuf import json_format
+from .base import BigtableTransport, DEFAULT_CLIENT_INFO
+
+import re
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+
+from google.cloud.bigtable_v2.types import bigtable
+
+
+class _BaseBigtableRestTransport(BigtableTransport):
+ """Base REST backend transport for Bigtable.
+
+ Note: This class is not meant to be used directly. Use its sync and
+ async sub-classes instead.
+
+ This class defines the same methods as the primary client, so the
+ primary client can load the underlying transport implementation
+ and call it.
+
+ It sends JSON representations of protocol buffers over HTTP/1.1
+ """
+
+ def __init__(
+ self,
+ *,
+ host: str = "bigtable.googleapis.com",
+ credentials: Optional[Any] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ url_scheme: str = "https",
+ api_audience: Optional[str] = None,
+ ) -> None:
+ """Instantiate the transport.
+ Args:
+ host (Optional[str]):
+ The hostname to connect to (default: 'bigtable.googleapis.com').
+ credentials (Optional[Any]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you are developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+ url_scheme: the protocol scheme for the API endpoint. Normally
+ "https", but for testing or local servers,
+ "http" can be specified.
+ """
+ # Run the base constructor
+ maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host)
+ if maybe_url_match is None:
+ raise ValueError(
+ f"Unexpected hostname structure: {host}"
+ ) # pragma: NO COVER
+
+ url_match_items = maybe_url_match.groupdict()
+
+ host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+ super().__init__(
+ host=host,
+ credentials=credentials,
+ client_info=client_info,
+ always_use_jwt_access=always_use_jwt_access,
+ api_audience=api_audience,
+ )
+
+ class _BaseCheckAndMutateRow:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:checkAndMutateRow",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:checkAndMutateRow",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.CheckAndMutateRowRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseCheckAndMutateRow._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseExecuteQuery:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{instance_name=projects/*/instances/*}:executeQuery",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.ExecuteQueryRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseExecuteQuery._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseGenerateInitialChangeStreamPartitions:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:generateInitialChangeStreamPartitions",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.GenerateInitialChangeStreamPartitionsRequest.pb(
+ request
+ )
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseGenerateInitialChangeStreamPartitions._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseMutateRow:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:mutateRow",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:mutateRow",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.MutateRowRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseMutateRow._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseMutateRows:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:mutateRows",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:mutateRows",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.MutateRowsRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseMutateRows._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BasePingAndWarm:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{name=projects/*/instances/*}:ping",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.PingAndWarmRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BasePingAndWarm._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseReadChangeStream:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:readChangeStream",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.ReadChangeStreamRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseReadChangeStream._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseReadModifyWriteRow:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+ @classmethod
+ def _get_unset_required_fields(cls, message_dict):
+ return {
+ k: v
+ for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+ if k not in message_dict
+ }
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:readModifyWriteRow",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:readModifyWriteRow",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.ReadModifyWriteRowRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+ query_params.update(
+ _BaseBigtableRestTransport._BaseReadModifyWriteRow._get_unset_required_fields(
+ query_params
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseReadRows:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:readRows",
+ "body": "*",
+ },
+ {
+ "method": "post",
+ "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:readRows",
+ "body": "*",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.ReadRowsRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_request_body_json(transcoded_request):
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"], use_integers_for_enums=True
+ )
+ return body
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+ class _BaseSampleRowKeys:
+ def __hash__(self): # pragma: NO COVER
+ return NotImplementedError("__hash__ must be implemented.")
+
+ @staticmethod
+ def _get_http_options():
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "get",
+ "uri": "/v2/{table_name=projects/*/instances/*/tables/*}:sampleRowKeys",
+ },
+ {
+ "method": "get",
+ "uri": "/v2/{authorized_view_name=projects/*/instances/*/tables/*/authorizedViews/*}:sampleRowKeys",
+ },
+ ]
+ return http_options
+
+ @staticmethod
+ def _get_transcoded_request(http_options, request):
+ pb_request = bigtable.SampleRowKeysRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+ return transcoded_request
+
+ @staticmethod
+ def _get_query_params_json(transcoded_request):
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ use_integers_for_enums=True,
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+ return query_params
+
+
+__all__ = ("_BaseBigtableRestTransport",)
diff --git a/google/cloud/bigtable_v2/types/feature_flags.py b/google/cloud/bigtable_v2/types/feature_flags.py
index bad6c163b..1e408bb3a 100644
--- a/google/cloud/bigtable_v2/types/feature_flags.py
+++ b/google/cloud/bigtable_v2/types/feature_flags.py
@@ -70,6 +70,12 @@ class FeatureFlags(proto.Message):
client_side_metrics_enabled (bool):
Notify the server that the client has client
side metrics enabled.
+ traffic_director_enabled (bool):
+ Notify the server that the client using
+ Traffic Director endpoint.
+ direct_access_requested (bool):
+ Notify the server that the client explicitly
+ opted in for Direct Access.
"""
reverse_scans: bool = proto.Field(
@@ -100,6 +106,14 @@ class FeatureFlags(proto.Message):
proto.BOOL,
number=8,
)
+ traffic_director_enabled: bool = proto.Field(
+ proto.BOOL,
+ number=9,
+ )
+ direct_access_requested: bool = proto.Field(
+ proto.BOOL,
+ number=10,
+ )
__all__ = tuple(sorted(__protobuf__.manifest))
diff --git a/noxfile.py b/noxfile.py
index 5fb94526d..548bfd0ec 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -28,19 +28,29 @@
import nox
FLAKE8_VERSION = "flake8==6.1.0"
-BLACK_VERSION = "black[jupyter]==23.7.0"
+BLACK_VERSION = "black[jupyter]==23.3.0"
ISORT_VERSION = "isort==5.11.0"
LINT_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"]
DEFAULT_PYTHON_VERSION = "3.8"
-UNIT_TEST_PYTHON_VERSIONS: List[str] = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+UNIT_TEST_PYTHON_VERSIONS: List[str] = [
+ "3.7",
+ "3.8",
+ "3.9",
+ "3.10",
+ "3.11",
+ "3.12",
+ "3.13",
+]
UNIT_TEST_STANDARD_DEPENDENCIES = [
"mock",
"asyncmock",
"pytest",
"pytest-cov",
"pytest-asyncio",
+ BLACK_VERSION,
+ "autoflake",
]
UNIT_TEST_EXTERNAL_DEPENDENCIES: List[str] = []
UNIT_TEST_LOCAL_DEPENDENCIES: List[str] = []
@@ -48,7 +58,7 @@
UNIT_TEST_EXTRAS: List[str] = []
UNIT_TEST_EXTRAS_BY_PYTHON: Dict[str, List[str]] = {}
-SYSTEM_TEST_PYTHON_VERSIONS: List[str] = ["3.8"]
+SYSTEM_TEST_PYTHON_VERSIONS: List[str] = ["3.8", "3.12"]
SYSTEM_TEST_STANDARD_DEPENDENCIES: List[str] = [
"mock",
"pytest",
@@ -56,6 +66,8 @@
]
SYSTEM_TEST_EXTERNAL_DEPENDENCIES: List[str] = [
"pytest-asyncio==0.21.2",
+ BLACK_VERSION,
+ "pyyaml==6.0.2",
]
SYSTEM_TEST_LOCAL_DEPENDENCIES: List[str] = []
SYSTEM_TEST_DEPENDENCIES: List[str] = []
@@ -147,6 +159,8 @@ def mypy(session):
"tests/system/v2_client",
"--exclude",
"tests/unit/v2_client",
+ "--disable-error-code",
+ "func-returns-value", # needed for CrossSync.rm_aio
)
@@ -193,7 +207,7 @@ def install_unittest_dependencies(session, *constraints):
def unit(session, protobuf_implementation):
# Install all test dependencies, then install this package in-place.
- if protobuf_implementation == "cpp" and session.python in ("3.11", "3.12"):
+ if protobuf_implementation == "cpp" and session.python in ("3.11", "3.12", "3.13"):
session.skip("cpp implementation is not supported in python 3.11+")
constraints_path = str(
@@ -256,7 +270,7 @@ def install_systemtest_dependencies(session, *constraints):
session.install("-e", ".", *constraints)
-@nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS)
+@nox.session(python="3.8")
def system_emulated(session):
import subprocess
import signal
@@ -284,9 +298,8 @@ def system_emulated(session):
@nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS)
-def conformance(session):
- TEST_REPO_URL = "https://github.com/googleapis/cloud-bigtable-clients-test.git"
- CLONE_REPO_DIR = "cloud-bigtable-clients-test"
+@nox.parametrize("client_type", ["async", "sync", "legacy"])
+def conformance(session, client_type):
# install dependencies
constraints_path = str(
CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
@@ -294,11 +307,13 @@ def conformance(session):
install_unittest_dependencies(session, "-c", constraints_path)
with session.chdir("test_proxy"):
# download the conformance test suite
- clone_dir = os.path.join(CURRENT_DIRECTORY, CLONE_REPO_DIR)
- if not os.path.exists(clone_dir):
- print("downloading copy of test repo")
- session.run("git", "clone", TEST_REPO_URL, CLONE_REPO_DIR, external=True)
- session.run("bash", "-e", "run_tests.sh", external=True)
+ session.run(
+ "bash",
+ "-e",
+ "run_tests.sh",
+ external=True,
+ env={"CLIENT_TYPE": client_type},
+ )
@nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS)
@@ -357,7 +372,7 @@ def cover(session):
session.run("coverage", "erase")
-@nox.session(python="3.9")
+@nox.session(python="3.10")
def docs(session):
"""Build the docs for this library."""
@@ -449,7 +464,7 @@ def docfx(session):
def prerelease_deps(session, protobuf_implementation):
"""Run all tests with prerelease versions of dependencies installed."""
- if protobuf_implementation == "cpp" and session.python in ("3.11", "3.12"):
+ if protobuf_implementation == "cpp" and session.python in ("3.11", "3.12", "3.13"):
session.skip("cpp implementation is not supported in python 3.11+")
# Install all dependencies
@@ -548,3 +563,13 @@ def prerelease_deps(session, protobuf_implementation):
"PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
},
)
+
+
+@nox.session(python="3.10")
+def generate_sync(session):
+ """
+ Re-generate sync files for the library from CrossSync-annotated async source
+ """
+ session.install(BLACK_VERSION)
+ session.install("autoflake")
+ session.run("python", ".cross_sync/generate.py", ".")
diff --git a/owlbot.py b/owlbot.py
index 0ec4cd61c..16ce11b4f 100644
--- a/owlbot.py
+++ b/owlbot.py
@@ -97,64 +97,6 @@ def get_staging_dirs(
s.move(templated_files, excludes=[".coveragerc", "README.rst", ".github/release-please.yml", "noxfile.py"])
-# ----------------------------------------------------------------------------
-# Customize gapics to include PooledBigtableGrpcAsyncIOTransport
-# ----------------------------------------------------------------------------
-def insert(file, before_line, insert_line, after_line, escape=None):
- target = before_line + "\n" + after_line
- if escape:
- for c in escape:
- target = target.replace(c, '\\' + c)
- replacement = before_line + "\n" + insert_line + "\n" + after_line
- s.replace(file, target, replacement)
-
-
-insert(
- "google/cloud/bigtable_v2/services/bigtable/client.py",
- "from .transports.grpc_asyncio import BigtableGrpcAsyncIOTransport",
- "from .transports.pooled_grpc_asyncio import PooledBigtableGrpcAsyncIOTransport",
- "from .transports.rest import BigtableRestTransport"
-)
-insert(
- "google/cloud/bigtable_v2/services/bigtable/client.py",
- ' _transport_registry["grpc_asyncio"] = BigtableGrpcAsyncIOTransport',
- ' _transport_registry["pooled_grpc_asyncio"] = PooledBigtableGrpcAsyncIOTransport',
- ' _transport_registry["rest"] = BigtableRestTransport',
- escape='[]"'
-)
-insert(
- "google/cloud/bigtable_v2/services/bigtable/transports/__init__.py",
- '_transport_registry["grpc_asyncio"] = BigtableGrpcAsyncIOTransport',
- '_transport_registry["pooled_grpc_asyncio"] = PooledBigtableGrpcAsyncIOTransport',
- '_transport_registry["rest"] = BigtableRestTransport',
- escape='[]"'
-)
-insert(
- "google/cloud/bigtable_v2/services/bigtable/transports/__init__.py",
- "from .grpc_asyncio import BigtableGrpcAsyncIOTransport",
- "from .pooled_grpc_asyncio import PooledBigtableGrpcAsyncIOTransport",
- "from .rest import BigtableRestTransport"
-)
-insert(
- "google/cloud/bigtable_v2/services/bigtable/transports/__init__.py",
- ' "BigtableGrpcAsyncIOTransport",',
- ' "PooledBigtableGrpcAsyncIOTransport",',
- ' "BigtableRestTransport",',
- escape='"'
-)
-
-# ----------------------------------------------------------------------------
-# Patch duplicate routing header: https://github.com/googleapis/gapic-generator-python/issues/2078
-# ----------------------------------------------------------------------------
-for file in ["async_client.py"]:
- s.replace(
- f"google/cloud/bigtable_v2/services/bigtable/{file}",
- "metadata \= tuple\(metadata\) \+ \(",
- """metadata = tuple(metadata)
- if all(m[0] != gapic_v1.routing_header.ROUTING_METADATA_KEY for m in metadata):
- metadata += ("""
- )
-
# ----------------------------------------------------------------------------
# Samples templates
# ----------------------------------------------------------------------------
diff --git a/python-api-core b/python-api-core
deleted file mode 160000
index 17ff5f1d8..000000000
--- a/python-api-core
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 17ff5f1d83a9a6f50a0226fb0e794634bd584f17
diff --git a/samples/__init__.py b/samples/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/beam/__init__.py b/samples/beam/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/beam/hello_world_write_test.py b/samples/beam/hello_world_write_test.py
index 4e9a47c7d..ba0e98096 100644
--- a/samples/beam/hello_world_write_test.py
+++ b/samples/beam/hello_world_write_test.py
@@ -14,45 +14,33 @@
import os
import uuid
-from google.cloud import bigtable
import pytest
-import hello_world_write
+from . import hello_world_write
+from ..utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
+TABLE_ID = f"mobile-time-series-beam-{str(uuid.uuid4())[:16]}"
@pytest.fixture(scope="module", autouse=True)
-def table_id():
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
+def table():
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None}
+ ) as table:
+ yield table
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
- table.create(column_families={"stats_summary": None})
- yield table_id
-
- table.delete()
-
-
-def test_hello_world_write(table_id):
+def test_hello_world_write(table):
hello_world_write.run(
[
"--bigtable-project=%s" % PROJECT,
"--bigtable-instance=%s" % BIGTABLE_INSTANCE,
- "--bigtable-table=%s" % table_id,
+ "--bigtable-table=%s" % TABLE_ID,
]
)
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table = instance.table(table_id)
-
rows = table.read_rows()
count = 0
for _ in rows:
diff --git a/samples/beam/noxfile.py b/samples/beam/noxfile.py
index 80ffdb178..d0b343a91 100644
--- a/samples/beam/noxfile.py
+++ b/samples/beam/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/beam/requirements-test.txt b/samples/beam/requirements-test.txt
index 40543aaba..e079f8a60 100644
--- a/samples/beam/requirements-test.txt
+++ b/samples/beam/requirements-test.txt
@@ -1 +1 @@
-pytest==8.3.3
+pytest
diff --git a/samples/hello/__init__.py b/samples/hello/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/hello/async_main.py b/samples/hello/async_main.py
index d608bb073..34159bedb 100644
--- a/samples/hello/async_main.py
+++ b/samples/hello/async_main.py
@@ -26,16 +26,16 @@
import argparse
import asyncio
+from ..utils import wait_for_table
# [START bigtable_async_hw_imports]
from google.cloud import bigtable
from google.cloud.bigtable.data import row_filters
-from google.cloud.bigtable.data import RowMutationEntry
-from google.cloud.bigtable.data import SetCell
-from google.cloud.bigtable.data import ReadRowsQuery
-
# [END bigtable_async_hw_imports]
+# use to ignore warnings
+row_filters
+
async def main(project_id, instance_id, table_id):
# [START bigtable_async_hw_connect]
@@ -65,63 +65,66 @@ async def main(project_id, instance_id, table_id):
print("Table {} already exists.".format(table_id))
# [END bigtable_async_hw_create_table]
- # [START bigtable_async_hw_write_rows]
- print("Writing some greetings to the table.")
- greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
- mutations = []
- column = "greeting"
- for i, value in enumerate(greetings):
- # Note: This example uses sequential numeric IDs for simplicity,
- # but this can result in poor performance in a production
- # application. Since rows are stored in sorted order by key,
- # sequential keys can result in poor distribution of operations
- # across nodes.
- #
- # For more information about how to design a Bigtable schema for
- # the best performance, see the documentation:
- #
- # https://cloud.google.com/bigtable/docs/schema-design
- row_key = "greeting{}".format(i).encode()
- row_mutation = RowMutationEntry(
- row_key, SetCell(column_family_id, column, value)
- )
- mutations.append(row_mutation)
- await table.bulk_mutate_rows(mutations)
- # [END bigtable_async_hw_write_rows]
-
- # [START bigtable_async_hw_create_filter]
- # Create a filter to only retrieve the most recent version of the cell
- # for each column across entire row.
- row_filter = row_filters.CellsColumnLimitFilter(1)
- # [END bigtable_async_hw_create_filter]
-
- # [START bigtable_async_hw_get_with_filter]
- # [START bigtable_async_hw_get_by_key]
- print("Getting a single greeting by row key.")
- key = "greeting0".encode()
-
- row = await table.read_row(key, row_filter=row_filter)
- cell = row.cells[0]
- print(cell.value.decode("utf-8"))
- # [END bigtable_async_hw_get_by_key]
- # [END bigtable_async_hw_get_with_filter]
-
- # [START bigtable_async_hw_scan_with_filter]
- # [START bigtable_async_hw_scan_all]
- print("Scanning for all greetings:")
- query = ReadRowsQuery(row_filter=row_filter)
- async for row in await table.read_rows_stream(query):
+ try:
+ # let table creation complete
+ wait_for_table(admin_table)
+ # [START bigtable_async_hw_write_rows]
+ print("Writing some greetings to the table.")
+ greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
+ mutations = []
+ column = "greeting"
+ for i, value in enumerate(greetings):
+ # Note: This example uses sequential numeric IDs for simplicity,
+ # but this can result in poor performance in a production
+ # application. Since rows are stored in sorted order by key,
+ # sequential keys can result in poor distribution of operations
+ # across nodes.
+ #
+ # For more information about how to design a Bigtable schema for
+ # the best performance, see the documentation:
+ #
+ # https://cloud.google.com/bigtable/docs/schema-design
+ row_key = "greeting{}".format(i).encode()
+ row_mutation = bigtable.data.RowMutationEntry(
+ row_key, bigtable.data.SetCell(column_family_id, column, value)
+ )
+ mutations.append(row_mutation)
+ await table.bulk_mutate_rows(mutations)
+ # [END bigtable_async_hw_write_rows]
+
+ # [START bigtable_async_hw_create_filter]
+ # Create a filter to only retrieve the most recent version of the cell
+ # for each column across entire row.
+ row_filter = bigtable.data.row_filters.CellsColumnLimitFilter(1)
+ # [END bigtable_async_hw_create_filter]
+
+ # [START bigtable_async_hw_get_with_filter]
+ # [START bigtable_async_hw_get_by_key]
+ print("Getting a single greeting by row key.")
+ key = "greeting0".encode()
+
+ row = await table.read_row(key, row_filter=row_filter)
cell = row.cells[0]
print(cell.value.decode("utf-8"))
- # [END bigtable_async_hw_scan_all]
- # [END bigtable_async_hw_scan_with_filter]
-
- # [START bigtable_async_hw_delete_table]
- # the async client only supports the data API. Table deletion as an admin operation
- # use admin client to create the table
- print("Deleting the {} table.".format(table_id))
- admin_table.delete()
- # [END bigtable_async_hw_delete_table]
+ # [END bigtable_async_hw_get_by_key]
+ # [END bigtable_async_hw_get_with_filter]
+
+ # [START bigtable_async_hw_scan_with_filter]
+ # [START bigtable_async_hw_scan_all]
+ print("Scanning for all greetings:")
+ query = bigtable.data.ReadRowsQuery(row_filter=row_filter)
+ async for row in await table.read_rows_stream(query):
+ cell = row.cells[0]
+ print(cell.value.decode("utf-8"))
+ # [END bigtable_async_hw_scan_all]
+ # [END bigtable_async_hw_scan_with_filter]
+ finally:
+ # [START bigtable_async_hw_delete_table]
+ # the async client only supports the data API. Table deletion as an admin operation
+ # use admin client to create the table
+ print("Deleting the {} table.".format(table_id))
+ admin_table.delete()
+ # [END bigtable_async_hw_delete_table]
if __name__ == "__main__":
diff --git a/samples/hello/async_main_test.py b/samples/hello/async_main_test.py
index a47ac2d33..aa65a8652 100644
--- a/samples/hello/async_main_test.py
+++ b/samples/hello/async_main_test.py
@@ -13,27 +13,24 @@
# limitations under the License.
import os
-import random
import asyncio
+import uuid
-from async_main import main
+from .async_main import main
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_NAME_FORMAT = "hello-world-test-{}"
-TABLE_NAME_RANGE = 10000
+TABLE_ID = f"hello-world-test-async-{str(uuid.uuid4())[:16]}"
def test_async_main(capsys):
- table_name = TABLE_NAME_FORMAT.format(random.randrange(TABLE_NAME_RANGE))
-
- asyncio.run(main(PROJECT, BIGTABLE_INSTANCE, table_name))
+ asyncio.run(main(PROJECT, BIGTABLE_INSTANCE, TABLE_ID))
out, _ = capsys.readouterr()
- assert "Creating the {} table.".format(table_name) in out
+ assert "Creating the {} table.".format(TABLE_ID) in out
assert "Writing some greetings to the table." in out
assert "Getting a single greeting by row key." in out
assert "Hello World!" in out
assert "Scanning for all greetings" in out
assert "Hello Cloud Bigtable!" in out
- assert "Deleting the {} table.".format(table_name) in out
+ assert "Deleting the {} table.".format(TABLE_ID) in out
diff --git a/samples/hello/main.py b/samples/hello/main.py
index 3b7de34b0..41124e826 100644
--- a/samples/hello/main.py
+++ b/samples/hello/main.py
@@ -25,6 +25,7 @@
"""
import argparse
+from ..utils import wait_for_table
# [START bigtable_hw_imports]
import datetime
@@ -35,6 +36,10 @@
# [END bigtable_hw_imports]
+# use to avoid warnings
+row_filters
+column_family
+
def main(project_id, instance_id, table_id):
# [START bigtable_hw_connect]
@@ -51,7 +56,7 @@ def main(project_id, instance_id, table_id):
print("Creating column family cf1 with Max Version GC rule...")
# Create a column family with GC policy : most recent N versions
# Define the GC policy to retain only the most recent 2 versions
- max_versions_rule = column_family.MaxVersionsGCRule(2)
+ max_versions_rule = bigtable.column_family.MaxVersionsGCRule(2)
column_family_id = "cf1"
column_families = {column_family_id: max_versions_rule}
if not table.exists():
@@ -60,63 +65,68 @@ def main(project_id, instance_id, table_id):
print("Table {} already exists.".format(table_id))
# [END bigtable_hw_create_table]
- # [START bigtable_hw_write_rows]
- print("Writing some greetings to the table.")
- greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
- rows = []
- column = "greeting".encode()
- for i, value in enumerate(greetings):
- # Note: This example uses sequential numeric IDs for simplicity,
- # but this can result in poor performance in a production
- # application. Since rows are stored in sorted order by key,
- # sequential keys can result in poor distribution of operations
- # across nodes.
- #
- # For more information about how to design a Bigtable schema for
- # the best performance, see the documentation:
- #
- # https://cloud.google.com/bigtable/docs/schema-design
- row_key = "greeting{}".format(i).encode()
- row = table.direct_row(row_key)
- row.set_cell(
- column_family_id, column, value, timestamp=datetime.datetime.utcnow()
- )
- rows.append(row)
- table.mutate_rows(rows)
- # [END bigtable_hw_write_rows]
-
- # [START bigtable_hw_create_filter]
- # Create a filter to only retrieve the most recent version of the cell
- # for each column across entire row.
- row_filter = row_filters.CellsColumnLimitFilter(1)
- # [END bigtable_hw_create_filter]
-
- # [START bigtable_hw_get_with_filter]
- # [START bigtable_hw_get_by_key]
- print("Getting a single greeting by row key.")
- key = "greeting0".encode()
-
- row = table.read_row(key, row_filter)
- cell = row.cells[column_family_id][column][0]
- print(cell.value.decode("utf-8"))
- # [END bigtable_hw_get_by_key]
- # [END bigtable_hw_get_with_filter]
-
- # [START bigtable_hw_scan_with_filter]
- # [START bigtable_hw_scan_all]
- print("Scanning for all greetings:")
- partial_rows = table.read_rows(filter_=row_filter)
-
- for row in partial_rows:
+ try:
+ # let table creation complete
+ wait_for_table(table)
+
+ # [START bigtable_hw_write_rows]
+ print("Writing some greetings to the table.")
+ greetings = ["Hello World!", "Hello Cloud Bigtable!", "Hello Python!"]
+ rows = []
+ column = "greeting".encode()
+ for i, value in enumerate(greetings):
+ # Note: This example uses sequential numeric IDs for simplicity,
+ # but this can result in poor performance in a production
+ # application. Since rows are stored in sorted order by key,
+ # sequential keys can result in poor distribution of operations
+ # across nodes.
+ #
+ # For more information about how to design a Bigtable schema for
+ # the best performance, see the documentation:
+ #
+ # https://cloud.google.com/bigtable/docs/schema-design
+ row_key = "greeting{}".format(i).encode()
+ row = table.direct_row(row_key)
+ row.set_cell(
+ column_family_id, column, value, timestamp=datetime.datetime.utcnow()
+ )
+ rows.append(row)
+ table.mutate_rows(rows)
+ # [END bigtable_hw_write_rows]
+
+ # [START bigtable_hw_create_filter]
+ # Create a filter to only retrieve the most recent version of the cell
+ # for each column across entire row.
+ row_filter = bigtable.row_filters.CellsColumnLimitFilter(1)
+ # [END bigtable_hw_create_filter]
+
+ # [START bigtable_hw_get_with_filter]
+ # [START bigtable_hw_get_by_key]
+ print("Getting a single greeting by row key.")
+ key = "greeting0".encode()
+
+ row = table.read_row(key, row_filter)
cell = row.cells[column_family_id][column][0]
print(cell.value.decode("utf-8"))
- # [END bigtable_hw_scan_all]
- # [END bigtable_hw_scan_with_filter]
-
- # [START bigtable_hw_delete_table]
- print("Deleting the {} table.".format(table_id))
- table.delete()
- # [END bigtable_hw_delete_table]
+ # [END bigtable_hw_get_by_key]
+ # [END bigtable_hw_get_with_filter]
+
+ # [START bigtable_hw_scan_with_filter]
+ # [START bigtable_hw_scan_all]
+ print("Scanning for all greetings:")
+ partial_rows = table.read_rows(filter_=row_filter)
+
+ for row in partial_rows:
+ cell = row.cells[column_family_id][column][0]
+ print(cell.value.decode("utf-8"))
+ # [END bigtable_hw_scan_all]
+ # [END bigtable_hw_scan_with_filter]
+
+ finally:
+ # [START bigtable_hw_delete_table]
+ print("Deleting the {} table.".format(table_id))
+ table.delete()
+ # [END bigtable_hw_delete_table]
if __name__ == "__main__":
diff --git a/samples/hello/main_test.py b/samples/hello/main_test.py
index 641b34d11..28814d909 100644
--- a/samples/hello/main_test.py
+++ b/samples/hello/main_test.py
@@ -13,26 +13,23 @@
# limitations under the License.
import os
-import random
+import uuid
-from main import main
+from .main import main
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_NAME_FORMAT = "hello-world-test-{}"
-TABLE_NAME_RANGE = 10000
+TABLE_ID = f"hello-world-test-{str(uuid.uuid4())[:16]}"
def test_main(capsys):
- table_name = TABLE_NAME_FORMAT.format(random.randrange(TABLE_NAME_RANGE))
-
- main(PROJECT, BIGTABLE_INSTANCE, table_name)
+ main(PROJECT, BIGTABLE_INSTANCE, TABLE_ID)
out, _ = capsys.readouterr()
- assert "Creating the {} table.".format(table_name) in out
+ assert "Creating the {} table.".format(TABLE_ID) in out
assert "Writing some greetings to the table." in out
assert "Getting a single greeting by row key." in out
assert "Hello World!" in out
assert "Scanning for all greetings" in out
assert "Hello Cloud Bigtable!" in out
- assert "Deleting the {} table.".format(table_name) in out
+ assert "Deleting the {} table.".format(TABLE_ID) in out
diff --git a/samples/hello/noxfile.py b/samples/hello/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/hello/noxfile.py
+++ b/samples/hello/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/hello/requirements-test.txt b/samples/hello/requirements-test.txt
index 40543aaba..e079f8a60 100644
--- a/samples/hello/requirements-test.txt
+++ b/samples/hello/requirements-test.txt
@@ -1 +1 @@
-pytest==8.3.3
+pytest
diff --git a/samples/hello_happybase/__init__.py b/samples/hello_happybase/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/hello_happybase/main.py b/samples/hello_happybase/main.py
index 7999fd006..50820febd 100644
--- a/samples/hello_happybase/main.py
+++ b/samples/hello_happybase/main.py
@@ -25,6 +25,7 @@
"""
import argparse
+from ..utils import wait_for_table
# [START bigtable_hw_imports_happybase]
from google.cloud import bigtable
@@ -51,6 +52,8 @@ def main(project_id, instance_id, table_name):
)
# [END bigtable_hw_create_table_happybase]
+ wait_for_table(instance.table(table_name))
+
# [START bigtable_hw_write_rows_happybase]
print("Writing some greetings to the table.")
table = connection.table(table_name)
@@ -90,12 +93,11 @@ def main(project_id, instance_id, table_name):
print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))
# [END bigtable_hw_scan_all_happybase]
+ finally:
# [START bigtable_hw_delete_table_happybase]
print("Deleting the {} table.".format(table_name))
connection.delete_table(table_name)
# [END bigtable_hw_delete_table_happybase]
-
- finally:
connection.close()
diff --git a/samples/hello_happybase/main_test.py b/samples/hello_happybase/main_test.py
index 6a63750da..252f4ccaf 100644
--- a/samples/hello_happybase/main_test.py
+++ b/samples/hello_happybase/main_test.py
@@ -13,25 +13,32 @@
# limitations under the License.
import os
-import random
+import uuid
-from main import main
+from .main import main
+from google.cloud import bigtable
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_NAME_FORMAT = "hello-world-hb-test-{}"
-TABLE_NAME_RANGE = 10000
+TABLE_ID = f"hello-world-hb-test-{str(uuid.uuid4())[:16]}"
def test_main(capsys):
- table_name = TABLE_NAME_FORMAT.format(random.randrange(TABLE_NAME_RANGE))
- main(PROJECT, BIGTABLE_INSTANCE, table_name)
+ try:
+ main(PROJECT, BIGTABLE_INSTANCE, TABLE_ID)
- out, _ = capsys.readouterr()
- assert "Creating the {} table.".format(table_name) in out
- assert "Writing some greetings to the table." in out
- assert "Getting a single greeting by row key." in out
- assert "Hello World!" in out
- assert "Scanning for all greetings" in out
- assert "Hello Cloud Bigtable!" in out
- assert "Deleting the {} table.".format(table_name) in out
+ out, _ = capsys.readouterr()
+ assert "Creating the {} table.".format(TABLE_ID) in out
+ assert "Writing some greetings to the table." in out
+ assert "Getting a single greeting by row key." in out
+ assert "Hello World!" in out
+ assert "Scanning for all greetings" in out
+ assert "Hello Cloud Bigtable!" in out
+ assert "Deleting the {} table.".format(TABLE_ID) in out
+ finally:
+ # delete table
+ client = bigtable.Client(PROJECT, admin=True)
+ instance = client.instance(BIGTABLE_INSTANCE)
+ table = instance.table(TABLE_ID)
+ if table.exists():
+ table.delete()
diff --git a/samples/hello_happybase/noxfile.py b/samples/hello_happybase/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/hello_happybase/noxfile.py
+++ b/samples/hello_happybase/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/hello_happybase/requirements-test.txt b/samples/hello_happybase/requirements-test.txt
index 40543aaba..e079f8a60 100644
--- a/samples/hello_happybase/requirements-test.txt
+++ b/samples/hello_happybase/requirements-test.txt
@@ -1 +1 @@
-pytest==8.3.3
+pytest
diff --git a/samples/instanceadmin/noxfile.py b/samples/instanceadmin/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/instanceadmin/noxfile.py
+++ b/samples/instanceadmin/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/instanceadmin/requirements-test.txt b/samples/instanceadmin/requirements-test.txt
index 40543aaba..e079f8a60 100644
--- a/samples/instanceadmin/requirements-test.txt
+++ b/samples/instanceadmin/requirements-test.txt
@@ -1 +1 @@
-pytest==8.3.3
+pytest
diff --git a/samples/metricscaler/noxfile.py b/samples/metricscaler/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/metricscaler/noxfile.py
+++ b/samples/metricscaler/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/metricscaler/requirements-test.txt b/samples/metricscaler/requirements-test.txt
index ad81af821..13d734378 100644
--- a/samples/metricscaler/requirements-test.txt
+++ b/samples/metricscaler/requirements-test.txt
@@ -1,3 +1,3 @@
-pytest==8.3.3
+pytest
mock==5.1.0
google-cloud-testutils
diff --git a/samples/quickstart/__init__.py b/samples/quickstart/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/quickstart/main_async_test.py b/samples/quickstart/main_async_test.py
index 841cfc180..0749cbd31 100644
--- a/samples/quickstart/main_async_test.py
+++ b/samples/quickstart/main_async_test.py
@@ -13,46 +13,26 @@
# limitations under the License.
import os
+import uuid
from typing import AsyncGenerator
from google.cloud.bigtable.data import BigtableDataClientAsync, SetCell
import pytest
import pytest_asyncio
-from main_async import main
-
+from .main_async import main
+from ..utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_FORMAT = "quickstart-test-{}"
+TABLE_ID = f"quickstart-async-test-{str(uuid.uuid4())[:16]}"
@pytest_asyncio.fixture
async def table_id() -> AsyncGenerator[str, None]:
- table_id = _create_table()
- await _populate_table(table_id)
-
- yield table_id
-
- _delete_table(table_id)
-
-
-def _create_table():
- from google.cloud import bigtable
- import uuid
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
-
- table_id = TABLE_ID_FORMAT.format(uuid.uuid4().hex[:8])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
-
- table.create(column_families={"cf1": None})
-
- client.close()
- return table_id
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"cf1": None}):
+ await _populate_table(TABLE_ID)
+ yield TABLE_ID
async def _populate_table(table_id: str):
@@ -61,16 +41,6 @@ async def _populate_table(table_id: str):
await table.mutate_row("r1", SetCell("cf1", "c1", "test-value"))
-def _delete_table(table_id: str):
- from google.cloud import bigtable
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table = instance.table(table_id)
- table.delete()
- client.close()
-
-
@pytest.mark.asyncio
async def test_main(capsys, table_id):
await main(PROJECT, BIGTABLE_INSTANCE, table_id)
diff --git a/samples/quickstart/main_test.py b/samples/quickstart/main_test.py
index 46d578b6b..f58161f23 100644
--- a/samples/quickstart/main_test.py
+++ b/samples/quickstart/main_test.py
@@ -14,35 +14,28 @@
import os
import uuid
-
-from google.cloud import bigtable
import pytest
-from main import main
+from .main import main
+
+from ..utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_FORMAT = "quickstart-test-{}"
+TABLE_ID = f"quickstart-test-{str(uuid.uuid4())[:16]}"
@pytest.fixture()
def table():
- table_id = TABLE_ID_FORMAT.format(uuid.uuid4().hex[:8])
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table = instance.table(table_id)
column_family_id = "cf1"
column_families = {column_family_id: None}
- table.create(column_families=column_families)
-
- row = table.direct_row("r1")
- row.set_cell(column_family_id, "c1", "test-value")
- row.commit()
-
- yield table_id
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, column_families) as table:
+ row = table.direct_row("r1")
+ row.set_cell(column_family_id, "c1", "test-value")
+ row.commit()
- table.delete()
+ yield TABLE_ID
def test_main(capsys, table):
diff --git a/samples/quickstart/noxfile.py b/samples/quickstart/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/quickstart/noxfile.py
+++ b/samples/quickstart/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/quickstart/requirements-test.txt b/samples/quickstart/requirements-test.txt
index 0f831a1bf..ee4ba0186 100644
--- a/samples/quickstart/requirements-test.txt
+++ b/samples/quickstart/requirements-test.txt
@@ -1,2 +1,2 @@
-pytest==8.3.3
+pytest
pytest-asyncio
diff --git a/samples/quickstart_happybase/__init__.py b/samples/quickstart_happybase/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/quickstart_happybase/main_test.py b/samples/quickstart_happybase/main_test.py
index dc62ebede..343ec800a 100644
--- a/samples/quickstart_happybase/main_test.py
+++ b/samples/quickstart_happybase/main_test.py
@@ -14,35 +14,26 @@
import os
import uuid
-
-from google.cloud import bigtable
import pytest
-from main import main
-
+from .main import main
+from ..utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_FORMAT = "quickstart-hb-test-{}"
+TABLE_ID = f"quickstart-hb-test-{str(uuid.uuid4())[:16]}"
@pytest.fixture()
def table():
- table_id = TABLE_ID_FORMAT.format(uuid.uuid4().hex[:8])
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table = instance.table(table_id)
column_family_id = "cf1"
column_families = {column_family_id: None}
- table.create(column_families=column_families)
-
- row = table.direct_row("r1")
- row.set_cell(column_family_id, "c1", "test-value")
- row.commit()
-
- yield table_id
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, column_families) as table:
+ row = table.direct_row("r1")
+ row.set_cell(column_family_id, "c1", "test-value")
+ row.commit()
- table.delete()
+ yield TABLE_ID
def test_main(capsys, table):
diff --git a/samples/quickstart_happybase/noxfile.py b/samples/quickstart_happybase/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/quickstart_happybase/noxfile.py
+++ b/samples/quickstart_happybase/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/quickstart_happybase/requirements-test.txt b/samples/quickstart_happybase/requirements-test.txt
index 40543aaba..e079f8a60 100644
--- a/samples/quickstart_happybase/requirements-test.txt
+++ b/samples/quickstart_happybase/requirements-test.txt
@@ -1 +1 @@
-pytest==8.3.3
+pytest
diff --git a/samples/snippets/__init__.py b/samples/snippets/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/snippets/data_client/__init__.py b/samples/snippets/data_client/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/snippets/data_client/data_client_snippets_async_test.py b/samples/snippets/data_client/data_client_snippets_async_test.py
index 2e0fb9b81..8dfff50d1 100644
--- a/samples/snippets/data_client/data_client_snippets_async_test.py
+++ b/samples/snippets/data_client/data_client_snippets_async_test.py
@@ -12,36 +12,22 @@
# limitations under the License.
import pytest
import pytest_asyncio
-import uuid
import os
+import uuid
-import data_client_snippets_async as data_snippets
+from . import data_client_snippets_async as data_snippets
+from ...utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_STATIC = os.getenv(
- "BIGTABLE_TABLE", None
-) # if not set, a temproary table will be generated
+TABLE_ID = f"data-client-{str(uuid.uuid4())[:16]}"
@pytest.fixture(scope="session")
def table_id():
- from google.cloud import bigtable
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table_id = TABLE_ID_STATIC or f"data-client-{str(uuid.uuid4())[:16]}"
-
- admin_table = instance.table(table_id)
- if not admin_table.exists():
- admin_table.create(column_families={"family": None, "stats_summary": None})
-
- yield table_id
-
- if not table_id == TABLE_ID_STATIC:
- # clean up table when finished
- admin_table.delete()
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"family": None, "stats_summary": None}):
+ yield TABLE_ID
@pytest_asyncio.fixture
diff --git a/samples/snippets/data_client/noxfile.py b/samples/snippets/data_client/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/snippets/data_client/noxfile.py
+++ b/samples/snippets/data_client/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/snippets/data_client/requirements-test.txt b/samples/snippets/data_client/requirements-test.txt
index 0f831a1bf..ee4ba0186 100644
--- a/samples/snippets/data_client/requirements-test.txt
+++ b/samples/snippets/data_client/requirements-test.txt
@@ -1,2 +1,2 @@
-pytest==8.3.3
+pytest
pytest-asyncio
diff --git a/samples/snippets/deletes/__init__.py b/samples/snippets/deletes/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/snippets/deletes/deletes_async_test.py b/samples/snippets/deletes/deletes_async_test.py
index b708bd52e..4fb4898e5 100644
--- a/samples/snippets/deletes/deletes_async_test.py
+++ b/samples/snippets/deletes/deletes_async_test.py
@@ -15,52 +15,34 @@
import datetime
import os
+import uuid
from typing import AsyncGenerator
from google.cloud._helpers import _microseconds_from_datetime
import pytest
import pytest_asyncio
-import deletes_snippets_async
+from . import deletes_snippets_async
+from ...utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
+TABLE_ID = f"mobile-time-series-deletes-async-{str(uuid.uuid4())[:16]}"
-@pytest_asyncio.fixture
-async def table_id() -> AsyncGenerator[str, None]:
- table_id = _create_table()
- await _populate_table(table_id)
- yield table_id
- _delete_table(table_id)
-
-
-def _create_table():
- from google.cloud import bigtable
- import uuid
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
+@pytest.fixture(scope="module")
+def event_loop():
+ import asyncio
+ loop = asyncio.get_event_loop_policy().new_event_loop()
+ yield loop
+ loop.close()
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
- table.create(column_families={"stats_summary": None, "cell_plan": None})
- client.close()
- return table_id
-
-
-def _delete_table(table_id: str):
- from google.cloud import bigtable
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table = instance.table(table_id)
- table.delete()
- client.close()
+@pytest_asyncio.fixture(scope="module", autouse=True)
+async def table_id() -> AsyncGenerator[str, None]:
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None, "cell_plan": None}, verbose=False):
+ await _populate_table(TABLE_ID)
+ yield TABLE_ID
async def _populate_table(table_id):
diff --git a/samples/snippets/deletes/deletes_test.py b/samples/snippets/deletes/deletes_test.py
index bebaabafb..3284c37da 100644
--- a/samples/snippets/deletes/deletes_test.py
+++ b/samples/snippets/deletes/deletes_test.py
@@ -18,81 +18,72 @@
import time
import uuid
-from google.cloud import bigtable
import pytest
-import deletes_snippets
+from . import deletes_snippets
+from ...utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
+TABLE_ID = f"mobile-time-series-deletes-{str(uuid.uuid4())[:16]}"
-@pytest.fixture(scope="module", autouse=True)
+@pytest.fixture(scope="module")
def table_id():
from google.cloud.bigtable.row_set import RowSet
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
-
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
-
- table.create(column_families={"stats_summary": None, "cell_plan": None})
-
- timestamp = datetime.datetime(2019, 5, 1)
- timestamp_minus_hr = datetime.datetime(2019, 5, 1) - datetime.timedelta(hours=1)
-
- row_keys = [
- "phone#4c410523#20190501",
- "phone#4c410523#20190502",
- "phone#4c410523#20190505",
- "phone#5c10102#20190501",
- "phone#5c10102#20190502",
- ]
-
- rows = [table.direct_row(row_key) for row_key in row_keys]
-
- rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
- rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
- rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
- rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
- rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
- rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
- rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
- rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
- rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
- rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
- rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
- rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
- rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
- rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
-
- table.mutate_rows(rows)
-
- # Ensure mutations have propagated.
- row_set = RowSet()
-
- for row_key in row_keys:
- row_set.add_row_key(row_key)
-
- fetched = list(table.read_rows(row_set=row_set))
-
- while len(fetched) < len(rows):
- time.sleep(5)
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None, "cell_plan": None}, verbose=False) as table:
+ timestamp = datetime.datetime(2019, 5, 1)
+ timestamp_minus_hr = datetime.datetime(2019, 5, 1) - datetime.timedelta(hours=1)
+
+ row_keys = [
+ "phone#4c410523#20190501",
+ "phone#4c410523#20190502",
+ "phone#4c410523#20190505",
+ "phone#5c10102#20190501",
+ "phone#5c10102#20190502",
+ ]
+
+ rows = [table.direct_row(row_key) for row_key in row_keys]
+
+ rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
+ rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
+ rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
+ rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+ rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
+ rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+
+ table.mutate_rows(rows)
+
+ # Ensure mutations have propagated.
+ row_set = RowSet()
+
+ for row_key in row_keys:
+ row_set.add_row_key(row_key)
+
fetched = list(table.read_rows(row_set=row_set))
- yield table_id
+ while len(fetched) < len(rows):
+ time.sleep(5)
+ fetched = list(table.read_rows(row_set=row_set))
+
+ yield TABLE_ID
def assert_output_match(capsys, expected):
@@ -135,6 +126,8 @@ def test_delete_column_family(capsys, table_id):
assert_output_match(capsys, "")
-def test_delete_table(capsys, table_id):
- deletes_snippets.delete_table(PROJECT, BIGTABLE_INSTANCE, table_id)
- assert_output_match(capsys, "")
+def test_delete_table(capsys):
+ delete_table_id = f"to-delete-table-{str(uuid.uuid4())[:16]}"
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, delete_table_id, verbose=False):
+ deletes_snippets.delete_table(PROJECT, BIGTABLE_INSTANCE, delete_table_id)
+ assert_output_match(capsys, "")
diff --git a/samples/snippets/deletes/noxfile.py b/samples/snippets/deletes/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/snippets/deletes/noxfile.py
+++ b/samples/snippets/deletes/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/snippets/deletes/requirements-test.txt b/samples/snippets/deletes/requirements-test.txt
index 0f831a1bf..ee4ba0186 100644
--- a/samples/snippets/deletes/requirements-test.txt
+++ b/samples/snippets/deletes/requirements-test.txt
@@ -1,2 +1,2 @@
-pytest==8.3.3
+pytest
pytest-asyncio
diff --git a/samples/snippets/filters/filter_snippets_async_test.py b/samples/snippets/filters/filter_snippets_async_test.py
index 76751feaf..a3f83a6f2 100644
--- a/samples/snippets/filters/filter_snippets_async_test.py
+++ b/samples/snippets/filters/filter_snippets_async_test.py
@@ -14,6 +14,7 @@
import datetime
import os
+import uuid
import inspect
from typing import AsyncGenerator
@@ -23,46 +24,29 @@
from .snapshots.snap_filters_test import snapshots
from . import filter_snippets_async
+from ...utils import create_table_cm
from google.cloud._helpers import (
_microseconds_from_datetime,
)
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
+TABLE_ID = f"mobile-time-series-filters-async-{str(uuid.uuid4())[:16]}"
-@pytest_asyncio.fixture
-async def table_id() -> AsyncGenerator[str, None]:
- table_id = _create_table()
- await _populate_table(table_id)
- yield table_id
- _delete_table(table_id)
-
-
-def _create_table():
- from google.cloud import bigtable
- import uuid
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
+@pytest.fixture(scope="module")
+def event_loop():
+ import asyncio
+ loop = asyncio.get_event_loop_policy().new_event_loop()
+ yield loop
+ loop.close()
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
- table.create(column_families={"stats_summary": None, "cell_plan": None})
- return table_id
-
-
-def _delete_table(table_id: str):
- from google.cloud import bigtable
-
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
- table = instance.table(table_id)
- table.delete()
+@pytest_asyncio.fixture(scope="module", autouse=True)
+async def table_id() -> AsyncGenerator[str, None]:
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None, "cell_plan": None}):
+ await _populate_table(TABLE_ID)
+ yield TABLE_ID
async def _populate_table(table_id):
diff --git a/samples/snippets/filters/filters_test.py b/samples/snippets/filters/filters_test.py
index a84932039..fe99886bd 100644
--- a/samples/snippets/filters/filters_test.py
+++ b/samples/snippets/filters/filters_test.py
@@ -18,84 +18,75 @@
import time
import uuid
-from google.cloud import bigtable
import pytest
from . import filter_snippets
from .snapshots.snap_filters_test import snapshots
+from ...utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
+TABLE_ID = f"mobile-time-series-filters-{str(uuid.uuid4())[:16]}"
@pytest.fixture(scope="module", autouse=True)
def table_id():
from google.cloud.bigtable.row_set import RowSet
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
-
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
-
- table.create(column_families={"stats_summary": None, "cell_plan": None})
-
- timestamp = datetime.datetime(2019, 5, 1)
- timestamp_minus_hr = datetime.datetime(2019, 5, 1) - datetime.timedelta(hours=1)
-
- row_keys = [
- "phone#4c410523#20190501",
- "phone#4c410523#20190502",
- "phone#4c410523#20190505",
- "phone#5c10102#20190501",
- "phone#5c10102#20190502",
- ]
-
- rows = [table.direct_row(row_key) for row_key in row_keys]
-
- rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
- rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
- rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
- rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
- rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
- rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
- rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
- rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
- rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
- rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
- rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
- rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
- rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
- rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
-
- table.mutate_rows(rows)
-
- # Ensure mutations have propagated.
- row_set = RowSet()
-
- for row_key in row_keys:
- row_set.add_row_key(row_key)
-
- fetched = list(table.read_rows(row_set=row_set))
-
- while len(fetched) < len(rows):
- time.sleep(5)
+ table_id = TABLE_ID
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, table_id, {"stats_summary": None, "cell_plan": None}) as table:
+
+ timestamp = datetime.datetime(2019, 5, 1)
+ timestamp_minus_hr = datetime.datetime(2019, 5, 1) - datetime.timedelta(hours=1)
+
+ row_keys = [
+ "phone#4c410523#20190501",
+ "phone#4c410523#20190502",
+ "phone#4c410523#20190505",
+ "phone#5c10102#20190501",
+ "phone#5c10102#20190502",
+ ]
+
+ rows = [table.direct_row(row_key) for row_key in row_keys]
+
+ rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
+ rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
+ rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
+ rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+ rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
+ rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+
+ table.mutate_rows(rows)
+
+ # Ensure mutations have propagated.
+ row_set = RowSet()
+
+ for row_key in row_keys:
+ row_set.add_row_key(row_key)
+
fetched = list(table.read_rows(row_set=row_set))
- yield table_id
+ while len(fetched) < len(rows):
+ time.sleep(5)
+ fetched = list(table.read_rows(row_set=row_set))
- table.delete()
+ yield table_id
def test_filter_limit_row_sample(capsys, table_id):
diff --git a/samples/snippets/filters/noxfile.py b/samples/snippets/filters/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/snippets/filters/noxfile.py
+++ b/samples/snippets/filters/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/snippets/filters/requirements-test.txt b/samples/snippets/filters/requirements-test.txt
index 0f831a1bf..ee4ba0186 100644
--- a/samples/snippets/filters/requirements-test.txt
+++ b/samples/snippets/filters/requirements-test.txt
@@ -1,2 +1,2 @@
-pytest==8.3.3
+pytest
pytest-asyncio
diff --git a/samples/snippets/reads/noxfile.py b/samples/snippets/reads/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/snippets/reads/noxfile.py
+++ b/samples/snippets/reads/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/snippets/reads/reads_test.py b/samples/snippets/reads/reads_test.py
index da826d6fb..0078ce598 100644
--- a/samples/snippets/reads/reads_test.py
+++ b/samples/snippets/reads/reads_test.py
@@ -13,65 +13,52 @@
import datetime
import os
-import uuid
import inspect
+import uuid
-from google.cloud import bigtable
import pytest
from .snapshots.snap_reads_test import snapshots
from . import read_snippets
+from ...utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
+TABLE_ID = f"mobile-time-series-reads-{str(uuid.uuid4())[:16]}"
@pytest.fixture(scope="module", autouse=True)
def table_id():
- client = bigtable.Client(project=PROJECT, admin=True)
- instance = client.instance(BIGTABLE_INSTANCE)
-
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = instance.table(table_id)
- if table.exists():
- table.delete()
-
- table.create(column_families={"stats_summary": None})
-
- # table = instance.table(table_id)
-
- timestamp = datetime.datetime(2019, 5, 1)
- rows = [
- table.direct_row("phone#4c410523#20190501"),
- table.direct_row("phone#4c410523#20190502"),
- table.direct_row("phone#4c410523#20190505"),
- table.direct_row("phone#5c10102#20190501"),
- table.direct_row("phone#5c10102#20190502"),
- ]
-
- rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
- rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
- rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
- rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
- rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
- rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
- rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
- rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
- rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
-
- table.mutate_rows(rows)
-
- yield table_id
-
- table.delete()
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None}) as table:
+ timestamp = datetime.datetime(2019, 5, 1)
+ rows = [
+ table.direct_row("phone#4c410523#20190501"),
+ table.direct_row("phone#4c410523#20190502"),
+ table.direct_row("phone#4c410523#20190505"),
+ table.direct_row("phone#5c10102#20190501"),
+ table.direct_row("phone#5c10102#20190502"),
+ ]
+
+ rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
+ rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
+ rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
+ rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
+ rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
+ rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+
+ table.mutate_rows(rows)
+
+ yield TABLE_ID
def test_read_row(capsys, table_id):
diff --git a/samples/snippets/reads/requirements-test.txt b/samples/snippets/reads/requirements-test.txt
index 40543aaba..e079f8a60 100644
--- a/samples/snippets/reads/requirements-test.txt
+++ b/samples/snippets/reads/requirements-test.txt
@@ -1 +1 @@
-pytest==8.3.3
+pytest
diff --git a/samples/snippets/writes/noxfile.py b/samples/snippets/writes/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/snippets/writes/noxfile.py
+++ b/samples/snippets/writes/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/snippets/writes/requirements-test.txt b/samples/snippets/writes/requirements-test.txt
index ba30e034f..5e15eb26f 100644
--- a/samples/snippets/writes/requirements-test.txt
+++ b/samples/snippets/writes/requirements-test.txt
@@ -1,2 +1,2 @@
backoff==2.2.1
-pytest==8.3.3
+pytest
diff --git a/samples/snippets/writes/writes_test.py b/samples/snippets/writes/writes_test.py
index 77ae883d6..2c7a3d62b 100644
--- a/samples/snippets/writes/writes_test.py
+++ b/samples/snippets/writes/writes_test.py
@@ -13,48 +13,27 @@
# limitations under the License.
import os
-import uuid
import backoff
from google.api_core.exceptions import DeadlineExceeded
-from google.cloud import bigtable
import pytest
+import uuid
from .write_batch import write_batch
from .write_conditionally import write_conditional
from .write_increment import write_increment
from .write_simple import write_simple
-
+from ...utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_PREFIX = "mobile-time-series-{}"
-
-
-@pytest.fixture
-def bigtable_client():
- return bigtable.Client(project=PROJECT, admin=True)
+TABLE_ID = f"mobile-time-series-writes-{str(uuid.uuid4())[:16]}"
@pytest.fixture
-def bigtable_instance(bigtable_client):
- return bigtable_client.instance(BIGTABLE_INSTANCE)
-
-
-@pytest.fixture
-def table_id(bigtable_instance):
- table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
- table = bigtable_instance.table(table_id)
- if table.exists():
- table.delete()
-
- column_family_id = "stats_summary"
- column_families = {column_family_id: None}
- table.create(column_families=column_families)
-
- yield table_id
-
- table.delete()
+def table_id():
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None}):
+ yield TABLE_ID
def test_writes(capsys, table_id):
diff --git a/samples/tableadmin/__init__.py b/samples/tableadmin/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/tableadmin/noxfile.py b/samples/tableadmin/noxfile.py
index 483b55901..a169b5b5b 100644
--- a/samples/tableadmin/noxfile.py
+++ b/samples/tableadmin/noxfile.py
@@ -89,7 +89,7 @@ def get_pytest_env_vars() -> Dict[str, str]:
# DO NOT EDIT - automatically generated.
# All versions used to test samples.
-ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
# Any default versions that should be ignored.
IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
diff --git a/samples/tableadmin/requirements-test.txt b/samples/tableadmin/requirements-test.txt
index 684dba326..a4c9e9c0b 100644
--- a/samples/tableadmin/requirements-test.txt
+++ b/samples/tableadmin/requirements-test.txt
@@ -1,2 +1,2 @@
-pytest==8.3.3
+pytest
google-cloud-testutils==1.4.0
diff --git a/samples/tableadmin/tableadmin.py b/samples/tableadmin/tableadmin.py
index 7c28601fb..ad00e5788 100644
--- a/samples/tableadmin/tableadmin.py
+++ b/samples/tableadmin/tableadmin.py
@@ -35,36 +35,7 @@
from google.cloud import bigtable
from google.cloud.bigtable import column_family
-
-
-def create_table(project_id, instance_id, table_id):
- """Create a Bigtable table
-
- :type project_id: str
- :param project_id: Project id of the client.
-
- :type instance_id: str
- :param instance_id: Instance of the client.
-
- :type table_id: str
- :param table_id: Table id to create table.
- """
-
- client = bigtable.Client(project=project_id, admin=True)
- instance = client.instance(instance_id)
- table = instance.table(table_id)
-
- # Check whether table exists in an instance.
- # Create table if it does not exists.
- print("Checking if table {} exists...".format(table_id))
- if table.exists():
- print("Table {} already exists.".format(table_id))
- else:
- print("Creating the {} table.".format(table_id))
- table.create()
- print("Created table {}.".format(table_id))
-
- return client, instance, table
+from ..utils import create_table_cm
def run_table_operations(project_id, instance_id, table_id):
@@ -80,154 +51,155 @@ def run_table_operations(project_id, instance_id, table_id):
:param table_id: Table id to create table.
"""
- client, instance, table = create_table(project_id, instance_id, table_id)
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ with create_table_cm(project_id, instance_id, table_id, verbose=False) as table:
+ # [START bigtable_list_tables]
+ tables = instance.list_tables()
+ print("Listing tables in current project...")
+ if tables != []:
+ for tbl in tables:
+ print(tbl.table_id)
+ else:
+ print("No table exists in current project...")
+ # [END bigtable_list_tables]
+
+ # [START bigtable_create_family_gc_max_age]
+ print("Creating column family cf1 with with MaxAge GC Rule...")
+ # Create a column family with GC policy : maximum age
+ # where age = current time minus cell timestamp
+
+ # Define the GC rule to retain data with max age of 5 days
+ max_age_rule = column_family.MaxAgeGCRule(datetime.timedelta(days=5))
+
+ column_family1 = table.column_family("cf1", max_age_rule)
+ column_family1.create()
+ print("Created column family cf1 with MaxAge GC Rule.")
+ # [END bigtable_create_family_gc_max_age]
+
+ # [START bigtable_create_family_gc_max_versions]
+ print("Creating column family cf2 with max versions GC rule...")
+ # Create a column family with GC policy : most recent N versions
+ # where 1 = most recent version
+
+ # Define the GC policy to retain only the most recent 2 versions
+ max_versions_rule = column_family.MaxVersionsGCRule(2)
+
+ column_family2 = table.column_family("cf2", max_versions_rule)
+ column_family2.create()
+ print("Created column family cf2 with Max Versions GC Rule.")
+ # [END bigtable_create_family_gc_max_versions]
+
+ # [START bigtable_create_family_gc_union]
+ print("Creating column family cf3 with union GC rule...")
+ # Create a column family with GC policy to drop data that matches
+ # at least one condition.
+ # Define a GC rule to drop cells older than 5 days or not the
+ # most recent version
+ union_rule = column_family.GCRuleUnion(
+ [
+ column_family.MaxAgeGCRule(datetime.timedelta(days=5)),
+ column_family.MaxVersionsGCRule(2),
+ ]
+ )
- # [START bigtable_list_tables]
- tables = instance.list_tables()
- print("Listing tables in current project...")
- if tables != []:
- for tbl in tables:
- print(tbl.table_id)
- else:
- print("No table exists in current project...")
- # [END bigtable_list_tables]
-
- # [START bigtable_create_family_gc_max_age]
- print("Creating column family cf1 with with MaxAge GC Rule...")
- # Create a column family with GC policy : maximum age
- # where age = current time minus cell timestamp
-
- # Define the GC rule to retain data with max age of 5 days
- max_age_rule = column_family.MaxAgeGCRule(datetime.timedelta(days=5))
-
- column_family1 = table.column_family("cf1", max_age_rule)
- column_family1.create()
- print("Created column family cf1 with MaxAge GC Rule.")
- # [END bigtable_create_family_gc_max_age]
-
- # [START bigtable_create_family_gc_max_versions]
- print("Creating column family cf2 with max versions GC rule...")
- # Create a column family with GC policy : most recent N versions
- # where 1 = most recent version
-
- # Define the GC policy to retain only the most recent 2 versions
- max_versions_rule = column_family.MaxVersionsGCRule(2)
-
- column_family2 = table.column_family("cf2", max_versions_rule)
- column_family2.create()
- print("Created column family cf2 with Max Versions GC Rule.")
- # [END bigtable_create_family_gc_max_versions]
-
- # [START bigtable_create_family_gc_union]
- print("Creating column family cf3 with union GC rule...")
- # Create a column family with GC policy to drop data that matches
- # at least one condition.
- # Define a GC rule to drop cells older than 5 days or not the
- # most recent version
- union_rule = column_family.GCRuleUnion(
- [
- column_family.MaxAgeGCRule(datetime.timedelta(days=5)),
- column_family.MaxVersionsGCRule(2),
- ]
- )
+ column_family3 = table.column_family("cf3", union_rule)
+ column_family3.create()
+ print("Created column family cf3 with Union GC rule")
+ # [END bigtable_create_family_gc_union]
+
+ # [START bigtable_create_family_gc_intersection]
+ print("Creating column family cf4 with Intersection GC rule...")
+ # Create a column family with GC policy to drop data that matches
+ # all conditions
+ # GC rule: Drop cells older than 5 days AND older than the most
+ # recent 2 versions
+ intersection_rule = column_family.GCRuleIntersection(
+ [
+ column_family.MaxAgeGCRule(datetime.timedelta(days=5)),
+ column_family.MaxVersionsGCRule(2),
+ ]
+ )
- column_family3 = table.column_family("cf3", union_rule)
- column_family3.create()
- print("Created column family cf3 with Union GC rule")
- # [END bigtable_create_family_gc_union]
-
- # [START bigtable_create_family_gc_intersection]
- print("Creating column family cf4 with Intersection GC rule...")
- # Create a column family with GC policy to drop data that matches
- # all conditions
- # GC rule: Drop cells older than 5 days AND older than the most
- # recent 2 versions
- intersection_rule = column_family.GCRuleIntersection(
- [
- column_family.MaxAgeGCRule(datetime.timedelta(days=5)),
- column_family.MaxVersionsGCRule(2),
- ]
- )
+ column_family4 = table.column_family("cf4", intersection_rule)
+ column_family4.create()
+ print("Created column family cf4 with Intersection GC rule.")
+ # [END bigtable_create_family_gc_intersection]
+
+ # [START bigtable_create_family_gc_nested]
+ print("Creating column family cf5 with a Nested GC rule...")
+ # Create a column family with nested GC policies.
+ # Create a nested GC rule:
+ # Drop cells that are either older than the 10 recent versions
+ # OR
+ # Drop cells that are older than a month AND older than the
+ # 2 recent versions
+ rule1 = column_family.MaxVersionsGCRule(10)
+ rule2 = column_family.GCRuleIntersection(
+ [
+ column_family.MaxAgeGCRule(datetime.timedelta(days=30)),
+ column_family.MaxVersionsGCRule(2),
+ ]
+ )
- column_family4 = table.column_family("cf4", intersection_rule)
- column_family4.create()
- print("Created column family cf4 with Intersection GC rule.")
- # [END bigtable_create_family_gc_intersection]
-
- # [START bigtable_create_family_gc_nested]
- print("Creating column family cf5 with a Nested GC rule...")
- # Create a column family with nested GC policies.
- # Create a nested GC rule:
- # Drop cells that are either older than the 10 recent versions
- # OR
- # Drop cells that are older than a month AND older than the
- # 2 recent versions
- rule1 = column_family.MaxVersionsGCRule(10)
- rule2 = column_family.GCRuleIntersection(
- [
- column_family.MaxAgeGCRule(datetime.timedelta(days=30)),
- column_family.MaxVersionsGCRule(2),
- ]
- )
+ nested_rule = column_family.GCRuleUnion([rule1, rule2])
+
+ column_family5 = table.column_family("cf5", nested_rule)
+ column_family5.create()
+ print("Created column family cf5 with a Nested GC rule.")
+ # [END bigtable_create_family_gc_nested]
+
+ # [START bigtable_list_column_families]
+ print("Printing Column Family and GC Rule for all column families...")
+ column_families = table.list_column_families()
+ for column_family_name, gc_rule in sorted(column_families.items()):
+ print("Column Family:", column_family_name)
+ print("GC Rule:")
+ print(gc_rule.to_pb())
+ # Sample output:
+ # Column Family: cf4
+ # GC Rule:
+ # gc_rule {
+ # intersection {
+ # rules {
+ # max_age {
+ # seconds: 432000
+ # }
+ # }
+ # rules {
+ # max_num_versions: 2
+ # }
+ # }
+ # }
+ # [END bigtable_list_column_families]
+
+ print("Print column family cf1 GC rule before update...")
+ print("Column Family: cf1")
+ print(column_family1.to_pb())
+
+ # [START bigtable_update_gc_rule]
+ print("Updating column family cf1 GC rule...")
+ # Update the column family cf1 to update the GC rule
+ column_family1 = table.column_family("cf1", column_family.MaxVersionsGCRule(1))
+ column_family1.update()
+ print("Updated column family cf1 GC rule\n")
+ # [END bigtable_update_gc_rule]
+
+ print("Print column family cf1 GC rule after update...")
+ print("Column Family: cf1")
+ print(column_family1.to_pb())
+
+ # [START bigtable_delete_family]
+ print("Delete a column family cf2...")
+ # Delete a column family
+ column_family2.delete()
+ print("Column family cf2 deleted successfully.")
+ # [END bigtable_delete_family]
- nested_rule = column_family.GCRuleUnion([rule1, rule2])
-
- column_family5 = table.column_family("cf5", nested_rule)
- column_family5.create()
- print("Created column family cf5 with a Nested GC rule.")
- # [END bigtable_create_family_gc_nested]
-
- # [START bigtable_list_column_families]
- print("Printing Column Family and GC Rule for all column families...")
- column_families = table.list_column_families()
- for column_family_name, gc_rule in sorted(column_families.items()):
- print("Column Family:", column_family_name)
- print("GC Rule:")
- print(gc_rule.to_pb())
- # Sample output:
- # Column Family: cf4
- # GC Rule:
- # gc_rule {
- # intersection {
- # rules {
- # max_age {
- # seconds: 432000
- # }
- # }
- # rules {
- # max_num_versions: 2
- # }
- # }
- # }
- # [END bigtable_list_column_families]
-
- print("Print column family cf1 GC rule before update...")
- print("Column Family: cf1")
- print(column_family1.to_pb())
-
- # [START bigtable_update_gc_rule]
- print("Updating column family cf1 GC rule...")
- # Update the column family cf1 to update the GC rule
- column_family1 = table.column_family("cf1", column_family.MaxVersionsGCRule(1))
- column_family1.update()
- print("Updated column family cf1 GC rule\n")
- # [END bigtable_update_gc_rule]
-
- print("Print column family cf1 GC rule after update...")
- print("Column Family: cf1")
- print(column_family1.to_pb())
-
- # [START bigtable_delete_family]
- print("Delete a column family cf2...")
- # Delete a column family
- column_family2.delete()
- print("Column family cf2 deleted successfully.")
- # [END bigtable_delete_family]
-
- print(
- 'execute command "python tableadmin.py delete [project_id] \
- [instance_id] --table [tableName]" to delete the table.'
- )
+ print(
+ 'execute command "python tableadmin.py delete [project_id] \
+ [instance_id] --table [tableName]" to delete the table.'
+ )
def delete_table(project_id, instance_id, table_id):
diff --git a/samples/tableadmin/tableadmin_test.py b/samples/tableadmin/tableadmin_test.py
index 3063eee9f..0ffdc75c9 100755
--- a/samples/tableadmin/tableadmin_test.py
+++ b/samples/tableadmin/tableadmin_test.py
@@ -14,29 +14,25 @@
# limitations under the License.
import os
-import uuid
-
-from google.api_core import exceptions
from test_utils.retry import RetryErrors
+from google.api_core import exceptions
+import uuid
-from tableadmin import create_table
-from tableadmin import delete_table
-from tableadmin import run_table_operations
+from .tableadmin import delete_table
+from .tableadmin import run_table_operations
+from ..utils import create_table_cm
PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
-TABLE_ID_FORMAT = "tableadmin-test-{}"
+TABLE_ID = f"tableadmin-test-{str(uuid.uuid4())[:16]}"
retry_429_503 = RetryErrors(exceptions.TooManyRequests, exceptions.ServiceUnavailable)
def test_run_table_operations(capsys):
- table_id = TABLE_ID_FORMAT.format(uuid.uuid4().hex[:8])
-
- retry_429_503(run_table_operations)(PROJECT, BIGTABLE_INSTANCE, table_id)
+ retry_429_503(run_table_operations)(PROJECT, BIGTABLE_INSTANCE, TABLE_ID)
out, _ = capsys.readouterr()
- assert "Creating the " + table_id + " table." in out
assert "Listing tables in current project." in out
assert "Creating column family cf1 with with MaxAge GC Rule" in out
assert "Created column family cf1 with MaxAge GC Rule." in out
@@ -53,14 +49,11 @@ def test_run_table_operations(capsys):
assert "Delete a column family cf2..." in out
assert "Column family cf2 deleted successfully." in out
- retry_429_503(delete_table)(PROJECT, BIGTABLE_INSTANCE, table_id)
-
def test_delete_table(capsys):
- table_id = TABLE_ID_FORMAT.format(uuid.uuid4().hex[:8])
- retry_429_503(create_table)(PROJECT, BIGTABLE_INSTANCE, table_id)
-
- retry_429_503(delete_table)(PROJECT, BIGTABLE_INSTANCE, table_id)
+ table_id = f"table-admin-to-delete-{str(uuid.uuid4())[:16]}"
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, table_id, verbose=False):
+ delete_table(PROJECT, BIGTABLE_INSTANCE, table_id)
out, _ = capsys.readouterr()
assert "Table " + table_id + " exists." in out
diff --git a/samples/utils.py b/samples/utils.py
new file mode 100644
index 000000000..eb0ca68f9
--- /dev/null
+++ b/samples/utils.py
@@ -0,0 +1,87 @@
+# Copyright 2024, 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.
+"""
+Provides helper logic used across samples
+"""
+
+
+from google.cloud import bigtable
+from google.api_core import exceptions
+from google.api_core.retry import Retry
+from google.api_core.retry import if_exception_type
+
+delete_retry = Retry(if_exception_type(exceptions.TooManyRequests, exceptions.ServiceUnavailable))
+
+class create_table_cm:
+ """
+ Create a new table using a context manager, to ensure that table.delete() is called to clean up
+ the table, even if an exception is thrown
+ """
+ def __init__(self, *args, verbose=True, **kwargs):
+ self._args = args
+ self._kwargs = kwargs
+ self._verbose = verbose
+
+ def __enter__(self):
+ self._table = create_table(*self._args, **self._kwargs)
+ if self._verbose:
+ print(f"created table: {self._table.table_id}")
+ return self._table
+
+ def __exit__(self, *args):
+ if self._table.exists():
+ if self._verbose:
+ print(f"deleting table: {self._table.table_id}")
+ delete_retry(self._table.delete())
+ else:
+ if self._verbose:
+ print(f"table {self._table.table_id} not found")
+
+
+def create_table(project, instance_id, table_id, column_families={}):
+ """
+ Creates a new table, and blocks until it reaches a ready state
+ """
+ client = bigtable.Client(project=project, admin=True)
+ instance = client.instance(instance_id)
+
+ table = instance.table(table_id)
+ if table.exists():
+ table.delete()
+
+ kwargs = {}
+ if column_families:
+ kwargs["column_families"] = column_families
+ table.create(**kwargs)
+
+ wait_for_table(table)
+
+ return table
+
+@Retry(
+ on_error=if_exception_type(
+ exceptions.PreconditionFailed,
+ exceptions.FailedPrecondition,
+ exceptions.NotFound,
+ ),
+ timeout=120,
+)
+def wait_for_table(table):
+ """
+ raises an exception if the table does not exist or is not ready to use
+
+ Because this method is wrapped with an api_core.Retry decorator, it will
+ retry with backoff if the table is not ready
+ """
+ if not table.exists():
+ raise exceptions.NotFound
\ No newline at end of file
diff --git a/test_proxy/README.md b/test_proxy/README.md
index 08741fd5d..5c87c729a 100644
--- a/test_proxy/README.md
+++ b/test_proxy/README.md
@@ -8,7 +8,7 @@ You can run the conformance tests in a single line by calling `nox -s conformanc
```
-cd python-bigtable/test_proxy
+cd python-bigtable
nox -s conformance
```
@@ -30,10 +30,11 @@ cd python-bigtable/test_proxy
python test_proxy.py --port 8080
```
-You can run the test proxy against the previous `v2` client by running it with the `--legacy-client` flag:
+By default, the test_proxy targets the async client. You can change this by passing in the `--client_type` flag.
+Valid options are `async`, `sync`, and `legacy`.
```
-python test_proxy.py --legacy-client
+python test_proxy.py --client_type=legacy
```
### Run the test cases
diff --git a/test_proxy/handlers/client_handler_data.py b/test_proxy/handlers/client_handler_data_async.py
similarity index 89%
rename from test_proxy/handlers/client_handler_data.py
rename to test_proxy/handlers/client_handler_data_async.py
index 43ff5d634..49539c1aa 100644
--- a/test_proxy/handlers/client_handler_data.py
+++ b/test_proxy/handlers/client_handler_data_async.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -18,8 +18,15 @@
from google.cloud.environment_vars import BIGTABLE_EMULATOR
from google.cloud.bigtable.data import BigtableDataClientAsync
+from google.cloud.bigtable.data._cross_sync import CrossSync
+if not CrossSync.is_async:
+ from client_handler_data_async import error_safe
+__CROSS_SYNC_OUTPUT__ = "test_proxy.handlers.client_handler_data_sync_autogen"
+
+
+@CrossSync.drop
def error_safe(func):
"""
Catch and pass errors back to the grpc_server_process
@@ -37,6 +44,7 @@ async def wrapper(self, *args, **kwargs):
return wrapper
+@CrossSync.drop
def encode_exception(exc):
"""
Encode an exception or chain of exceptions to pass back to grpc_handler
@@ -68,7 +76,8 @@ def encode_exception(exc):
return result
-class TestProxyClientHandler:
+@CrossSync.convert_class("TestProxyClientHandler")
+class TestProxyClientHandlerAsync:
"""
Implements the same methods as the grpc server, but handles the client
library side of the request.
@@ -90,7 +99,7 @@ def __init__(
self.closed = False
# use emulator
os.environ[BIGTABLE_EMULATOR] = data_target
- self.client = BigtableDataClientAsync(project=project_id)
+ self.client = CrossSync.DataClient(project=project_id)
self.instance_id = instance_id
self.app_profile_id = app_profile_id
self.per_operation_timeout = per_operation_timeout
@@ -105,7 +114,7 @@ async def ReadRows(self, request, **kwargs):
app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
table = self.client.get_table(self.instance_id, table_id, app_profile_id)
kwargs["operation_timeout"] = kwargs.get("operation_timeout", self.per_operation_timeout) or 20
- result_list = await table.read_rows(request, **kwargs)
+ result_list = CrossSync.rm_aio(await table.read_rows(request, **kwargs))
# pack results back into protobuf-parsable format
serialized_response = [row._to_dict() for row in result_list]
return serialized_response
@@ -116,7 +125,7 @@ async def ReadRow(self, row_key, **kwargs):
app_profile_id = self.app_profile_id or kwargs.get("app_profile_id", None)
table = self.client.get_table(self.instance_id, table_id, app_profile_id)
kwargs["operation_timeout"] = kwargs.get("operation_timeout", self.per_operation_timeout) or 20
- result_row = await table.read_row(row_key, **kwargs)
+ result_row = CrossSync.rm_aio(await table.read_row(row_key, **kwargs))
# pack results back into protobuf-parsable format
if result_row:
return result_row._to_dict()
@@ -132,7 +141,7 @@ async def MutateRow(self, request, **kwargs):
kwargs["operation_timeout"] = kwargs.get("operation_timeout", self.per_operation_timeout) or 20
row_key = request["row_key"]
mutations = [Mutation._from_dict(d) for d in request["mutations"]]
- await table.mutate_row(row_key, mutations, **kwargs)
+ CrossSync.rm_aio(await table.mutate_row(row_key, mutations, **kwargs))
return "OK"
@error_safe
@@ -143,7 +152,7 @@ async def BulkMutateRows(self, request, **kwargs):
table = self.client.get_table(self.instance_id, table_id, app_profile_id)
kwargs["operation_timeout"] = kwargs.get("operation_timeout", self.per_operation_timeout) or 20
entry_list = [RowMutationEntry._from_dict(entry) for entry in request["entries"]]
- await table.bulk_mutate_rows(entry_list, **kwargs)
+ CrossSync.rm_aio(await table.bulk_mutate_rows(entry_list, **kwargs))
return "OK"
@error_safe
@@ -171,13 +180,13 @@ async def CheckAndMutateRow(self, request, **kwargs):
# invalid mutation type. Conformance test may be sending generic empty request
false_mutations.append(SetCell("", "", "", 0))
predicate_filter = request.get("predicate_filter", None)
- result = await table.check_and_mutate_row(
+ result = CrossSync.rm_aio(await table.check_and_mutate_row(
row_key,
predicate_filter,
true_case_mutations=true_mutations,
false_case_mutations=false_mutations,
**kwargs,
- )
+ ))
return result
@error_safe
@@ -197,7 +206,7 @@ async def ReadModifyWriteRow(self, request, **kwargs):
else:
new_rule = IncrementRule(rule_dict["family_name"], qualifier, rule_dict["increment_amount"])
rules.append(new_rule)
- result = await table.read_modify_write_row(row_key, rules, **kwargs)
+ result = CrossSync.rm_aio(await table.read_modify_write_row(row_key, rules, **kwargs))
# pack results back into protobuf-parsable format
if result:
return result._to_dict()
@@ -210,5 +219,5 @@ async def SampleRowKeys(self, request, **kwargs):
app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
table = self.client.get_table(self.instance_id, table_id, app_profile_id)
kwargs["operation_timeout"] = kwargs.get("operation_timeout", self.per_operation_timeout) or 20
- result = await table.sample_row_keys(**kwargs)
+ result = CrossSync.rm_aio(await table.sample_row_keys(**kwargs))
return result
diff --git a/test_proxy/handlers/client_handler_data_sync_autogen.py b/test_proxy/handlers/client_handler_data_sync_autogen.py
new file mode 100644
index 000000000..eabae0ffa
--- /dev/null
+++ b/test_proxy/handlers/client_handler_data_sync_autogen.py
@@ -0,0 +1,185 @@
+# Copyright 2024 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.
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+"""
+This module contains the client handler process for proxy_server.py.
+"""
+import os
+from google.cloud.environment_vars import BIGTABLE_EMULATOR
+from google.cloud.bigtable.data._cross_sync import CrossSync
+from client_handler_data_async import error_safe
+
+
+class TestProxyClientHandler:
+ """
+ Implements the same methods as the grpc server, but handles the client
+ library side of the request.
+
+ Requests received in TestProxyGrpcServer are converted to a dictionary,
+ and supplied to the TestProxyClientHandler methods as kwargs.
+ The client response is then returned back to the TestProxyGrpcServer
+ """
+
+ def __init__(
+ self,
+ data_target=None,
+ project_id=None,
+ instance_id=None,
+ app_profile_id=None,
+ per_operation_timeout=None,
+ **kwargs
+ ):
+ self.closed = False
+ os.environ[BIGTABLE_EMULATOR] = data_target
+ self.client = CrossSync._Sync_Impl.DataClient(project=project_id)
+ self.instance_id = instance_id
+ self.app_profile_id = app_profile_id
+ self.per_operation_timeout = per_operation_timeout
+
+ def close(self):
+ self.closed = True
+
+ @error_safe
+ async def ReadRows(self, request, **kwargs):
+ table_id = request.pop("table_name").split("/")[-1]
+ app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ result_list = table.read_rows(request, **kwargs)
+ serialized_response = [row._to_dict() for row in result_list]
+ return serialized_response
+
+ @error_safe
+ async def ReadRow(self, row_key, **kwargs):
+ table_id = kwargs.pop("table_name").split("/")[-1]
+ app_profile_id = self.app_profile_id or kwargs.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ result_row = table.read_row(row_key, **kwargs)
+ if result_row:
+ return result_row._to_dict()
+ else:
+ return "None"
+
+ @error_safe
+ async def MutateRow(self, request, **kwargs):
+ from google.cloud.bigtable.data.mutations import Mutation
+
+ table_id = request["table_name"].split("/")[-1]
+ app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ row_key = request["row_key"]
+ mutations = [Mutation._from_dict(d) for d in request["mutations"]]
+ table.mutate_row(row_key, mutations, **kwargs)
+ return "OK"
+
+ @error_safe
+ async def BulkMutateRows(self, request, **kwargs):
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ table_id = request["table_name"].split("/")[-1]
+ app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ entry_list = [
+ RowMutationEntry._from_dict(entry) for entry in request["entries"]
+ ]
+ table.bulk_mutate_rows(entry_list, **kwargs)
+ return "OK"
+
+ @error_safe
+ async def CheckAndMutateRow(self, request, **kwargs):
+ from google.cloud.bigtable.data.mutations import Mutation, SetCell
+
+ table_id = request["table_name"].split("/")[-1]
+ app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ row_key = request["row_key"]
+ true_mutations = []
+ for mut_dict in request.get("true_mutations", []):
+ try:
+ true_mutations.append(Mutation._from_dict(mut_dict))
+ except ValueError:
+ mutation = SetCell("", "", "", 0)
+ true_mutations.append(mutation)
+ false_mutations = []
+ for mut_dict in request.get("false_mutations", []):
+ try:
+ false_mutations.append(Mutation._from_dict(mut_dict))
+ except ValueError:
+ false_mutations.append(SetCell("", "", "", 0))
+ predicate_filter = request.get("predicate_filter", None)
+ result = table.check_and_mutate_row(
+ row_key,
+ predicate_filter,
+ true_case_mutations=true_mutations,
+ false_case_mutations=false_mutations,
+ **kwargs
+ )
+ return result
+
+ @error_safe
+ async def ReadModifyWriteRow(self, request, **kwargs):
+ from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+ from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+
+ table_id = request["table_name"].split("/")[-1]
+ app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ row_key = request["row_key"]
+ rules = []
+ for rule_dict in request.get("rules", []):
+ qualifier = rule_dict["column_qualifier"]
+ if "append_value" in rule_dict:
+ new_rule = AppendValueRule(
+ rule_dict["family_name"], qualifier, rule_dict["append_value"]
+ )
+ else:
+ new_rule = IncrementRule(
+ rule_dict["family_name"], qualifier, rule_dict["increment_amount"]
+ )
+ rules.append(new_rule)
+ result = table.read_modify_write_row(row_key, rules, **kwargs)
+ if result:
+ return result._to_dict()
+ else:
+ return "None"
+
+ @error_safe
+ async def SampleRowKeys(self, request, **kwargs):
+ table_id = request["table_name"].split("/")[-1]
+ app_profile_id = self.app_profile_id or request.get("app_profile_id", None)
+ table = self.client.get_table(self.instance_id, table_id, app_profile_id)
+ kwargs["operation_timeout"] = (
+ kwargs.get("operation_timeout", self.per_operation_timeout) or 20
+ )
+ result = table.sample_row_keys(**kwargs)
+ return result
diff --git a/test_proxy/handlers/client_handler_legacy.py b/test_proxy/handlers/client_handler_legacy.py
index 400f618b5..63fe357b0 100644
--- a/test_proxy/handlers/client_handler_legacy.py
+++ b/test_proxy/handlers/client_handler_legacy.py
@@ -19,13 +19,13 @@
from google.cloud.environment_vars import BIGTABLE_EMULATOR
from google.cloud.bigtable.client import Client
-import client_handler_data as client_handler
+import client_handler_data_async as client_handler
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
-class LegacyTestProxyClientHandler(client_handler.TestProxyClientHandler):
+class LegacyTestProxyClientHandler(client_handler.TestProxyClientHandlerAsync):
def __init__(
self,
diff --git a/test_proxy/noxfile.py b/test_proxy/noxfile.py
deleted file mode 100644
index bebf247b7..000000000
--- a/test_proxy/noxfile.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# Copyright 2023 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.
-
-from __future__ import absolute_import
-import os
-import pathlib
-import re
-from colorlog.escape_codes import parse_colors
-
-import nox
-
-
-DEFAULT_PYTHON_VERSION = "3.10"
-
-PROXY_SERVER_PORT=os.environ.get("PROXY_SERVER_PORT", "50055")
-PROXY_CLIENT_VERSION=os.environ.get("PROXY_CLIENT_VERSION", None)
-
-CURRENT_DIRECTORY = pathlib.Path(__file__).parent.absolute()
-REPO_ROOT_DIRECTORY = CURRENT_DIRECTORY.parent
-
-nox.options.sessions = ["run_proxy", "conformance_tests"]
-
-TEST_REPO_URL = "https://github.com/googleapis/cloud-bigtable-clients-test.git"
-CLONE_REPO_DIR = "cloud-bigtable-clients-test"
-
-# Error if a python version is missing
-nox.options.error_on_missing_interpreters = True
-
-
-def default(session):
- """
- if nox is run directly, run the test_proxy session
- """
- test_proxy(session)
-
-
-@nox.session(python=DEFAULT_PYTHON_VERSION)
-def conformance_tests(session):
- """
- download and run the conformance test suite against the test proxy
- """
- import subprocess
- import time
- # download the conformance test suite
- clone_dir = os.path.join(CURRENT_DIRECTORY, CLONE_REPO_DIR)
- if not os.path.exists(clone_dir):
- print("downloading copy of test repo")
- session.run("git", "clone", TEST_REPO_URL, CLONE_REPO_DIR)
- # start tests
- with session.chdir(f"{clone_dir}/tests"):
- session.run("go", "test", "-v", f"-proxy_addr=:{PROXY_SERVER_PORT}")
-
-@nox.session(python=DEFAULT_PYTHON_VERSION)
-def test_proxy(session):
- """Start up the test proxy"""
- # Install all dependencies, then install this package into the
- # virtualenv's dist-packages.
- # session.install(
- # "grpcio",
- # )
- if PROXY_CLIENT_VERSION is not None:
- # install released version of the library
- session.install(f"python-bigtable=={PROXY_CLIENT_VERSION}")
- else:
- # install the library from the source
- session.install("-e", str(REPO_ROOT_DIRECTORY))
- session.install("-e", str(REPO_ROOT_DIRECTORY / "python-api-core"))
-
- session.run("python", "test_proxy.py", "--port", PROXY_SERVER_PORT, *session.posargs,)
diff --git a/test_proxy/run_tests.sh b/test_proxy/run_tests.sh
index 15b146b03..b6f1291a6 100755
--- a/test_proxy/run_tests.sh
+++ b/test_proxy/run_tests.sh
@@ -27,7 +27,7 @@ fi
SCRIPT_DIR=$(realpath $(dirname "$0"))
cd $SCRIPT_DIR
-export PROXY_SERVER_PORT=50055
+export PROXY_SERVER_PORT=$(shuf -i 50000-60000 -n 1)
# download test suite
if [ ! -d "cloud-bigtable-clients-test" ]; then
@@ -35,13 +35,27 @@ if [ ! -d "cloud-bigtable-clients-test" ]; then
fi
# start proxy
-python test_proxy.py --port $PROXY_SERVER_PORT &
+echo "starting with client type: $CLIENT_TYPE"
+python test_proxy.py --port $PROXY_SERVER_PORT --client_type $CLIENT_TYPE &
PROXY_PID=$!
function finish {
kill $PROXY_PID
}
trap finish EXIT
+if [[ $CLIENT_TYPE == "legacy" ]]; then
+ echo "Using legacy client"
+ # legacy client does not expose mutate_row. Disable those tests
+ TEST_ARGS="-skip TestMutateRow_"
+fi
+
+if [[ $CLIENT_TYPE != "async" ]]; then
+ echo "Using legacy client"
+ # sync and legacy client do not support concurrent streams
+ TEST_ARGS="$TEST_ARGS -skip _Generic_MultiStream "
+fi
+
# run tests
pushd cloud-bigtable-clients-test/tests
-go test -v -proxy_addr=:$PROXY_SERVER_PORT
+echo "Running with $TEST_ARGS"
+go test -v -proxy_addr=:$PROXY_SERVER_PORT $TEST_ARGS
diff --git a/test_proxy/test_proxy.py b/test_proxy/test_proxy.py
index a0cf2f1f0..793500768 100644
--- a/test_proxy/test_proxy.py
+++ b/test_proxy/test_proxy.py
@@ -55,7 +55,7 @@ def grpc_server_process(request_q, queue_pool, port=50055):
server.wait_for_termination()
-async def client_handler_process_async(request_q, queue_pool, use_legacy_client=False):
+async def client_handler_process_async(request_q, queue_pool, client_type="async"):
"""
Defines a process that recives Bigtable requests from a grpc_server_process,
and runs the request using a client library instance
@@ -64,8 +64,7 @@ async def client_handler_process_async(request_q, queue_pool, use_legacy_client=
import re
import asyncio
import warnings
- import client_handler_data
- import client_handler_legacy
+ import client_handler_data_async
warnings.filterwarnings("ignore", category=RuntimeWarning, message=".*Bigtable emulator.*")
def camel_to_snake(str):
@@ -98,9 +97,7 @@ def format_dict(input_obj):
return input_obj
# Listen to requests from grpc server process
- print_msg = "client_handler_process started"
- if use_legacy_client:
- print_msg += ", using legacy client"
+ print_msg = f"client_handler_process started with client_type={client_type}"
print(print_msg)
client_map = {}
background_tasks = set()
@@ -114,10 +111,14 @@ def format_dict(input_obj):
client = client_map.get(client_id, None)
# handle special cases for client creation and deletion
if fn_name == "CreateClient":
- if use_legacy_client:
+ if client_type == "legacy":
+ import client_handler_legacy
client = client_handler_legacy.LegacyTestProxyClientHandler(**json_data)
+ elif client_type == "sync":
+ import client_handler_data_sync_autogen
+ client = client_handler_data_sync_autogen.TestProxyClientHandler(**json_data)
else:
- client = client_handler_data.TestProxyClientHandler(**json_data)
+ client = client_handler_data_async.TestProxyClientHandlerAsync(**json_data)
client_map[client_id] = client
out_q.put(True)
elif client is None:
@@ -142,21 +143,21 @@ async def _run_fn(out_q, fn, **kwargs):
await asyncio.sleep(0.01)
-def client_handler_process(request_q, queue_pool, legacy_client=False):
+def client_handler_process(request_q, queue_pool, client_type="async"):
"""
Sync entrypoint for client_handler_process_async
"""
import asyncio
- asyncio.run(client_handler_process_async(request_q, queue_pool, legacy_client))
+ asyncio.run(client_handler_process_async(request_q, queue_pool, client_type))
p = argparse.ArgumentParser()
p.add_argument("--port", dest='port', default="50055")
-p.add_argument('--legacy-client', dest='use_legacy', action='store_true', default=False)
+p.add_argument("--client_type", dest='client_type', default="async", choices=["async", "sync", "legacy"])
if __name__ == "__main__":
port = p.parse_args().port
- use_legacy_client = p.parse_args().use_legacy
+ client_type = p.parse_args().client_type
# start and run both processes
# larger pools support more concurrent requests
@@ -176,7 +177,7 @@ def client_handler_process(request_q, queue_pool, legacy_client=False):
),
)
proxy.start()
- client_handler_process(request_q, response_queue_pool, use_legacy_client)
+ client_handler_process(request_q, response_queue_pool, client_type)
proxy.join()
else:
# run proxy in forground and client in background
diff --git a/testing/constraints-3.13.txt b/testing/constraints-3.13.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/system/cross_sync/test_cases/async_to_sync.yaml b/tests/system/cross_sync/test_cases/async_to_sync.yaml
new file mode 100644
index 000000000..99d39cbc5
--- /dev/null
+++ b/tests/system/cross_sync/test_cases/async_to_sync.yaml
@@ -0,0 +1,76 @@
+tests:
+ - description: "async for loop fn"
+ before: |
+ async def func_name():
+ async for i in range(10):
+ await routine()
+ return 42
+ transformers: [AsyncToSync]
+ after: |
+ def func_name():
+ for i in range(10):
+ routine()
+ return 42
+
+ - description: "async with statement"
+ before: |
+ async def func_name():
+ async with context_manager() as cm:
+ await do_something(cm)
+ transformers: [AsyncToSync]
+ after: |
+ def func_name():
+ with context_manager() as cm:
+ do_something(cm)
+
+ - description: "async function definition"
+ before: |
+ async def async_function(param1, param2):
+ result = await some_coroutine()
+ return result
+ transformers: [AsyncToSync]
+ after: |
+ def async_function(param1, param2):
+ result = some_coroutine()
+ return result
+
+ - description: "list comprehension with async for"
+ before: |
+ async def func_name():
+ result = [x async for x in aiter() if await predicate(x)]
+ transformers: [AsyncToSync]
+ after: |
+ def func_name():
+ result = [x for x in aiter() if predicate(x)]
+
+ - description: "multiple async features in one function"
+ before: |
+ async def complex_function():
+ async with resource_manager() as res:
+ async for item in res.items():
+ if await check(item):
+ yield await process(item)
+ transformers: [AsyncToSync]
+ after: |
+ def complex_function():
+ with resource_manager() as res:
+ for item in res.items():
+ if check(item):
+ yield process(item)
+
+ - description: "nested async constructs"
+ before: |
+ async def nested_async():
+ async with outer_context():
+ async for x in outer_iter():
+ async with inner_context(x):
+ async for y in inner_iter(x):
+ await process(x, y)
+ transformers: [AsyncToSync]
+ after: |
+ def nested_async():
+ with outer_context():
+ for x in outer_iter():
+ with inner_context(x):
+ for y in inner_iter(x):
+ process(x, y)
diff --git a/tests/system/cross_sync/test_cases/cross_sync_files.yaml b/tests/system/cross_sync/test_cases/cross_sync_files.yaml
new file mode 100644
index 000000000..5666325ce
--- /dev/null
+++ b/tests/system/cross_sync/test_cases/cross_sync_files.yaml
@@ -0,0 +1,469 @@
+tests:
+ - description: "No output annotation"
+ before: |
+ class MyAsyncClass:
+ async def my_method(self):
+ pass
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: null
+
+ - description: "CrossSync.convert_class with default sync_name"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class
+ class MyClass:
+ async def my_method(self):
+ pass
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+
+ async def my_method(self):
+ pass
+
+ - description: "CrossSync.convert_class with custom sync_name"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(sync_name="MyClass")
+ class MyAsyncClass:
+ async def my_method(self):
+ pass
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+
+ async def my_method(self):
+ pass
+
+ - description: "CrossSync.convert_class with replace_symbols"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(
+ sync_name="MyClass",
+ replace_symbols={"AsyncBase": "SyncBase", "ParentA": "ParentB"}
+ )
+ class MyAsyncClass(ParentA):
+ def __init__(self, base: AsyncBase):
+ self.base = base
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass(ParentB):
+
+ def __init__(self, base: SyncBase):
+ self.base = base
+
+ - description: "CrossSync.convert_class with docstring formatting"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(
+ sync_name="MyClass",
+ docstring_format_vars={"type": ("async", "sync")}
+ )
+ class MyAsyncClass:
+ """This is a {type} class."""
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+ """This is a sync class."""
+
+ - description: "CrossSync.convert_class with multiple decorators and methods"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(sync_name="MyClass")
+ @some_other_decorator
+ class MyAsyncClass:
+ @CrossSync.convert(rm_aio=False)
+ async def my_method(self):
+ async with self.base.connection():
+ return await self.base.my_method()
+
+ @CrossSync.drop
+ async def async_only_method(self):
+ await self.async_operation()
+
+ def sync_method(self):
+ return "This method stays the same"
+
+ @CrossSync.pytest_fixture
+ def fixture(self):
+ pass
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ @some_other_decorator
+ class MyClass:
+
+ def my_method(self):
+ async with self.base.connection():
+ return await self.base.my_method()
+
+ def sync_method(self):
+ return "This method stays the same"
+
+ @pytest.fixture()
+ def fixture(self):
+ pass
+
+ - description: "CrossSync.convert_class with nested classes drop"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(sync_name="MyClass")
+ class MyAsyncClass:
+ @CrossSync.drop
+ class NestedAsyncClass:
+ async def nested_method(self, base: AsyncBase):
+ pass
+
+ @CrossSync.convert
+ async def use_nested(self):
+ nested = self.NestedAsyncClass()
+ CrossSync.rm_aio(await nested.nested_method())
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+
+ def use_nested(self):
+ nested = self.NestedAsyncClass()
+ nested.nested_method()
+
+ - description: "CrossSync.convert_class with nested classes explicit"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(sync_name="MyClass", replace_symbols={"AsyncBase": "SyncBase"})
+ class MyAsyncClass:
+ @CrossSync.convert_class
+ class NestedClass:
+ async def nested_method(self, base: AsyncBase):
+ pass
+
+ @CrossSync.convert
+ async def use_nested(self):
+ nested = self.NestedAsyncClass()
+ CrossSync.rm_aio(await nested.nested_method())
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+
+ class NestedClass:
+
+ async def nested_method(self, base: SyncBase):
+ pass
+
+ def use_nested(self):
+ nested = self.NestedAsyncClass()
+ nested.nested_method()
+
+ - description: "CrossSync.convert_class with nested classes implicit"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(sync_name="MyClass", replace_symbols={"AsyncBase": "SyncBase"})
+ class MyAsyncClass:
+
+ class NestedClass:
+ async def nested_method(self, base: AsyncBase):
+ pass
+
+ @CrossSync.convert
+ async def use_nested(self):
+ nested = self.NestedAsyncClass()
+ CrossSync.rm_aio(await nested.nested_method())
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+
+ class NestedClass:
+
+ async def nested_method(self, base: SyncBase):
+ pass
+
+ def use_nested(self):
+ nested = self.NestedAsyncClass()
+ nested.nested_method()
+
+ - description: "CrossSync.convert_class with add_mapping"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(
+ sync_name="MyClass",
+ add_mapping_for_name="MyClass"
+ )
+ class MyAsyncClass:
+ async def my_method(self):
+ pass
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ @CrossSync._Sync_Impl.add_mapping_decorator("MyClass")
+ class MyClass:
+
+ async def my_method(self):
+ pass
+
+ - description: "CrossSync.convert_class with rm_aio"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(rm_aio=True)
+ class MyClass:
+ async def my_method(self):
+ async for item in self.items:
+ await self.process(item)
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ class MyClass:
+
+ def my_method(self):
+ for item in self.items:
+ self.process(item)
+
+ - description: "CrossSync.convert_class with CrossSync calls"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class(sync_name="MyClass")
+ class MyAsyncClass:
+ @CrossSync.convert
+ async def my_method(self):
+ async with CrossSync.rm_aio(CrossSync.Condition()) as c:
+ CrossSync.rm_aio(await CrossSync.yield_to_event_loop())
+
+ transformers:
+ - name: CrossSyncFileProcessor
+ after: |
+ class MyClass:
+
+ def my_method(self):
+ with CrossSync._Sync_Impl.Condition() as c:
+ CrossSync._Sync_Impl.yield_to_event_loop()
+
+ - description: "Convert async method with @CrossSync.convert"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert
+ async def my_method(self, arg):
+ pass
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ def my_method(self, arg):
+ pass
+
+ - description: "Convert async method with custom sync name"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert(sync_name="sync_method")
+ async def async_method(self, arg):
+ return await self.helper(arg)
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ def sync_method(self, arg):
+ return self.helper(arg)
+
+ - description: "Convert async method with rm_aio=True"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert(rm_aio=True)
+ async def async_method(self):
+ async with self.lock:
+ async for item in self.items:
+ await self.process(item)
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ def async_method(self):
+ with self.lock:
+ for item in self.items:
+ self.process(item)
+
+ - description: "Drop method from sync version"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ def keep_method(self):
+ pass
+
+ @CrossSync.drop
+ async def async_only_method(self):
+ await self.async_operation()
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ def keep_method(self):
+ pass
+
+ - description: "Drop class from sync version"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.drop
+ class DropMe:
+ pass
+ class Keeper:
+ pass
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ class Keeper:
+ pass
+
+ - description: "Convert.pytest"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.pytest
+ async def test_async_function():
+ result = await async_operation()
+ assert result == expected_value
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ def test_async_function():
+ result = async_operation()
+ assert result == expected_value
+
+ - description: "CrossSync.pytest with rm_aio=False"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.pytest(rm_aio=False)
+ async def test_partial_async():
+ async with context_manager():
+ result = await async_function()
+ assert result == expected_value
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ def test_partial_async():
+ async with context_manager():
+ result = await async_function()
+ assert result == expected_value
+
+ - description: "Convert async pytest fixture"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.pytest_fixture
+ @CrossSync.convert(rm_aio=True)
+ async def my_fixture():
+ resource = await setup_resource()
+ yield resource
+ await cleanup_resource(resource)
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ @pytest.fixture()
+ def my_fixture():
+ resource = setup_resource()
+ yield resource
+ cleanup_resource(resource)
+
+ - description: "Convert pytest fixture with custom parameters"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.pytest_fixture(scope="module", autouse=True)
+ def my_fixture():
+ resource = setup_resource()
+ yield resource
+ cleanup_resource(resource)
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ @pytest.fixture(scope="module", autouse=True)
+ def my_fixture():
+ resource = setup_resource()
+ yield resource
+ cleanup_resource(resource)
+
+ - description: "Convert method with multiple stacked decorators"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert(sync_name="sync_multi_decorated")
+ @CrossSync.pytest
+ @some_other_decorator
+ async def async_multi_decorated(self, arg):
+ result = await self.async_operation(arg)
+ return result
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ @some_other_decorator
+ def sync_multi_decorated(self, arg):
+ result = self.async_operation(arg)
+ return result
+
+ - description: "Convert method with multiple stacked decorators in class"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert_class
+ class MyClass:
+ @CrossSync.convert(sync_name="sync_multi_decorated")
+ @CrossSync.pytest
+ @some_other_decorator
+ async def async_multi_decorated(self, arg):
+ result = await self.async_operation(arg)
+ return result
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ class MyClass:
+
+ @some_other_decorator
+ def sync_multi_decorated(self, arg):
+ result = self.async_operation(arg)
+ return result
+
+ - description: "Convert method with stacked decorators including rm_aio"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ @CrossSync.convert(rm_aio=True)
+ @CrossSync.pytest_fixture(scope="function")
+ @another_decorator
+ async def async_fixture_with_context():
+ async with some_async_context():
+ resource = await setup_async_resource()
+ yield resource
+ await cleanup_async_resource(resource)
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ @pytest.fixture(scope="function")
+ @another_decorator
+ def async_fixture_with_context():
+ with some_async_context():
+ resource = setup_async_resource()
+ yield resource
+ cleanup_async_resource(resource)
+
+ - description: "Handle CrossSync.is_async conditional"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ if CrossSync.is_async:
+ import a
+ else:
+ import b
+
+ def my_method(self):
+ if CrossSync.is_async:
+ return "async version"
+ else:
+ return "sync version"
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ import b
+
+ def my_method(self):
+ return "sync version"
+
+ - description: "Replace CrossSync symbols"
+ before: |
+ __CROSS_SYNC_OUTPUT__ = "out.path"
+ CrossSync.sleep(1)
+ @CrossSync.convert_class
+ class MyClass:
+ event = CrossSync.Event()
+ def my_method(self):
+ return CrossSync.some_function()
+ transformers: [CrossSyncFileProcessor]
+ after: |
+ CrossSync._Sync_Impl.sleep(1)
+ class MyClass:
+ event = CrossSync._Sync_Impl.Event()
+ def my_method(self):
+ return CrossSync._Sync_Impl.some_function()
diff --git a/tests/system/cross_sync/test_cases/rm_aio.yaml b/tests/system/cross_sync/test_cases/rm_aio.yaml
new file mode 100644
index 000000000..89acda630
--- /dev/null
+++ b/tests/system/cross_sync/test_cases/rm_aio.yaml
@@ -0,0 +1,109 @@
+tests:
+ - description: "remove await"
+ before: |
+ CrossSync.rm_aio(await routine())
+ transformers: [RmAioFunctions]
+ after: |
+ routine()
+ - description: "async for loop fn"
+ before: |
+ async def func_name():
+ async for i in CrossSync.rm_aio(range(10)):
+ await routine()
+ return 42
+ transformers: [RmAioFunctions]
+ after: |
+ async def func_name():
+ for i in range(10):
+ await routine()
+ return 42
+
+ - description: "async with statement"
+ before: |
+ async def func_name():
+ async with CrossSync.rm_aio(context_manager()) as cm:
+ await do_something(cm)
+ transformers: [RmAioFunctions]
+ after: |
+ async def func_name():
+ with context_manager() as cm:
+ await do_something(cm)
+
+ - description: "list comprehension with async for"
+ before: |
+ async def func_name():
+ result = CrossSync.rm_aio([x async for x in aiter() if await predicate(x)])
+ transformers: [RmAioFunctions]
+ after: |
+ async def func_name():
+ result = [x for x in aiter() if predicate(x)]
+
+ - description: "multiple async features in one call"
+ before: |
+ CrossSync.rm_aio([x async for x in aiter() if await predicate(x)] + await routine())
+ transformers: [RmAioFunctions]
+ after: |
+ [x for x in aiter() if predicate(x)] + routine()
+
+ - description: "do nothing with no CrossSync.rm_aio"
+ before: |
+ async def nested_async():
+ async with outer_context():
+ async for x in outer_iter():
+ async with inner_context(x):
+ async for y in inner_iter(x):
+ await process(x, y)
+ transformers: [RmAioFunctions]
+ after: |
+ async def nested_async():
+ async with outer_context():
+ async for x in outer_iter():
+ async with inner_context(x):
+ async for y in inner_iter(x):
+ await process(x, y)
+
+ - description: "nested async for loops with rm_aio"
+ before: |
+ async def nested_loops():
+ async for x in CrossSync.rm_aio(outer_iter()):
+ async for y in CrossSync.rm_aio(inner_iter(x)):
+ await process(x, y)
+ transformers: [RmAioFunctions]
+ after: |
+ async def nested_loops():
+ for x in outer_iter():
+ for y in inner_iter(x):
+ await process(x, y)
+
+ - description: "async generator function with rm_aio"
+ before: |
+ async def async_gen():
+ yield CrossSync.rm_aio(await async_value())
+ async for item in CrossSync.rm_aio(async_iterator()):
+ yield item
+ transformers: [RmAioFunctions]
+ after: |
+ async def async_gen():
+ yield async_value()
+ for item in async_iterator():
+ yield item
+
+ - description: "async with statement with multiple context managers"
+ before: |
+ async def multi_context():
+ async with CrossSync.rm_aio(cm1()), CrossSync.rm_aio(cm2()) as c2, CrossSync.rm_aio(cm3()) as c3:
+ await do_something(c2, c3)
+ transformers: [RmAioFunctions]
+ after: |
+ async def multi_context():
+ with cm1(), cm2() as c2, cm3() as c3:
+ await do_something(c2, c3)
+
+ - description: "async comprehension with multiple async for and if clauses"
+ before: |
+ async def complex_comprehension():
+ result = CrossSync.rm_aio([x async for x in aiter1() if await pred1(x) async for y in aiter2(x) if await pred2(y)])
+ transformers: [RmAioFunctions]
+ after: |
+ async def complex_comprehension():
+ result = [x for x in aiter1() if pred1(x) for y in aiter2(x) if pred2(y)]
diff --git a/tests/system/cross_sync/test_cases/strip_async_conditional_branches.yaml b/tests/system/cross_sync/test_cases/strip_async_conditional_branches.yaml
new file mode 100644
index 000000000..0c192fb37
--- /dev/null
+++ b/tests/system/cross_sync/test_cases/strip_async_conditional_branches.yaml
@@ -0,0 +1,74 @@
+tests:
+ - description: "top level conditional"
+ before: |
+ if CrossSync.is_async:
+ print("async")
+ else:
+ print("sync")
+ transformers: [StripAsyncConditionalBranches]
+ after: |
+ print("sync")
+ - description: "nested conditional"
+ before: |
+ if CrossSync.is_async:
+ print("async")
+ else:
+ print("hello")
+ if CrossSync.is_async:
+ print("async")
+ else:
+ print("world")
+ transformers: [StripAsyncConditionalBranches]
+ after: |
+ print("hello")
+ print("world")
+ - description: "conditional within class"
+ before: |
+ class MyClass:
+ def my_method(self):
+ if CrossSync.is_async:
+ return "async result"
+ else:
+ return "sync result"
+ transformers: [StripAsyncConditionalBranches]
+ after: |
+ class MyClass:
+
+ def my_method(self):
+ return "sync result"
+ - description: "multiple branches"
+ before: |
+ if CrossSync.is_async:
+ print("async branch 1")
+ elif some_condition:
+ print("other condition")
+ elif CrossSync.is_async:
+ print("async branch 2")
+ else:
+ print("sync branch")
+ transformers: [StripAsyncConditionalBranches]
+ after: |
+ if some_condition:
+ print("other condition")
+ else:
+ print("sync branch")
+ - description: "negated conditionals"
+ before: |
+ if not CrossSync.is_async:
+ print("sync code")
+ else:
+ print("async code")
+
+ transformers: [StripAsyncConditionalBranches]
+ after: |
+ print("sync code")
+ - description: "is check"
+ before: |
+ if CrossSync.is_async is True:
+ print("async code")
+ else:
+ print("sync code")
+
+ transformers: [StripAsyncConditionalBranches]
+ after: |
+ print("sync code")
diff --git a/tests/system/cross_sync/test_cases/symbol_replacer.yaml b/tests/system/cross_sync/test_cases/symbol_replacer.yaml
new file mode 100644
index 000000000..fa50045f8
--- /dev/null
+++ b/tests/system/cross_sync/test_cases/symbol_replacer.yaml
@@ -0,0 +1,82 @@
+tests:
+ - description: "Does not Replace function name"
+ before: |
+ def function():
+ pass
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"function": "new_function"}
+ after: |
+ def function():
+ pass
+
+ - description: "Does not replace async function name"
+ before: |
+ async def async_func():
+ await old_coroutine()
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"async_func": "new_async_func", "old_coroutine": "new_coroutine"}
+ after: |
+ async def async_func():
+ await new_coroutine()
+
+ - description: "Replace method call"
+ before: |
+ result = obj.old_method()
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"old_method": "new_method"}
+ after: |
+ result = obj.new_method()
+
+ - description: "Replace in docstring"
+ before: |
+ def func():
+ """This is a docstring mentioning old_name."""
+ pass
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"old_name": "new_name"}
+ after: |
+ def func():
+ """This is a docstring mentioning new_name."""
+ pass
+
+ - description: "Replace in type annotation"
+ before: |
+ def func(param: OldType) -> OldReturnType:
+ pass
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"OldType": "NewType", "OldReturnType": "NewReturnType"}
+ after: |
+ def func(param: NewType) -> NewReturnType:
+ pass
+
+ - description: "Replace in nested attribute"
+ before: |
+ result = obj.attr1.attr2.old_attr
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"old_attr": "new_attr"}
+ after: |
+ result = obj.attr1.attr2.new_attr
+
+ - description: "No replacement when symbol not found"
+ before: |
+ def unchanged_function():
+ pass
+ transformers:
+ - name: SymbolReplacer
+ args:
+ replacements: {"non_existent": "replacement"}
+ after: |
+ def unchanged_function():
+ pass
diff --git a/tests/system/cross_sync/test_cross_sync_e2e.py b/tests/system/cross_sync/test_cross_sync_e2e.py
new file mode 100644
index 000000000..86911b163
--- /dev/null
+++ b/tests/system/cross_sync/test_cross_sync_e2e.py
@@ -0,0 +1,65 @@
+import ast
+import sys
+import os
+import black
+import pytest
+import yaml
+
+# add cross_sync to path
+test_dir_name = os.path.dirname(__file__)
+cross_sync_path = os.path.join(test_dir_name, "..", "..", "..", ".cross_sync")
+sys.path.append(cross_sync_path)
+
+from transformers import ( # noqa: F401 E402
+ SymbolReplacer,
+ AsyncToSync,
+ RmAioFunctions,
+ StripAsyncConditionalBranches,
+ CrossSyncFileProcessor,
+)
+
+
+def loader():
+ dir_name = os.path.join(test_dir_name, "test_cases")
+ for file_name in os.listdir(dir_name):
+ if not file_name.endswith(".yaml"):
+ print(f"Skipping {file_name}")
+ continue
+ test_case_file = os.path.join(dir_name, file_name)
+ # load test cases
+ with open(test_case_file) as f:
+ print(f"Loading test cases from {test_case_file}")
+ test_cases = yaml.safe_load(f)
+ for test in test_cases["tests"]:
+ test["file_name"] = file_name
+ yield test
+
+
+@pytest.mark.parametrize(
+ "test_dict", loader(), ids=lambda x: f"{x['file_name']}: {x.get('description', '')}"
+)
+@pytest.mark.skipif(
+ sys.version_info < (3, 9), reason="ast.unparse requires python3.9 or higher"
+)
+def test_e2e_scenario(test_dict):
+ before_ast = ast.parse(test_dict["before"])
+ got_ast = before_ast
+ for transformer_info in test_dict["transformers"]:
+ # transformer can be passed as a string, or a dict with name and args
+ if isinstance(transformer_info, str):
+ transformer_class = globals()[transformer_info]
+ transformer_args = {}
+ else:
+ transformer_class = globals()[transformer_info["name"]]
+ transformer_args = transformer_info.get("args", {})
+ transformer = transformer_class(**transformer_args)
+ got_ast = transformer.visit(got_ast)
+ if got_ast is None:
+ final_str = ""
+ else:
+ final_str = black.format_str(ast.unparse(got_ast), mode=black.FileMode())
+ if test_dict.get("after") is None:
+ expected_str = ""
+ else:
+ expected_str = black.format_str(test_dict["after"], mode=black.FileMode())
+ assert final_str == expected_str, f"Expected:\n{expected_str}\nGot:\n{final_str}"
diff --git a/tests/system/data/__init__.py b/tests/system/data/__init__.py
index 89a37dc92..f2952b2cd 100644
--- a/tests/system/data/__init__.py
+++ b/tests/system/data/__init__.py
@@ -13,3 +13,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
+
+TEST_FAMILY = "test-family"
+TEST_FAMILY_2 = "test-family-2"
diff --git a/tests/system/data/setup_fixtures.py b/tests/system/data/setup_fixtures.py
index 77086b7f3..3b5a0af06 100644
--- a/tests/system/data/setup_fixtures.py
+++ b/tests/system/data/setup_fixtures.py
@@ -17,20 +17,10 @@
"""
import pytest
-import pytest_asyncio
import os
-import asyncio
import uuid
-@pytest.fixture(scope="session")
-def event_loop():
- loop = asyncio.get_event_loop()
- yield loop
- loop.stop()
- loop.close()
-
-
@pytest.fixture(scope="session")
def admin_client():
"""
@@ -150,22 +140,7 @@ def table_id(
print(f"Table {init_table_id} not found, skipping deletion")
-@pytest_asyncio.fixture(scope="session")
-async def client():
- from google.cloud.bigtable.data import BigtableDataClientAsync
-
- project = os.getenv("GOOGLE_CLOUD_PROJECT") or None
- async with BigtableDataClientAsync(project=project, pool_size=4) as client:
- yield client
-
-
@pytest.fixture(scope="session")
def project_id(client):
"""Returns the project ID from the client."""
yield client.project
-
-
-@pytest_asyncio.fixture(scope="session")
-async def table(client, table_id, instance_id):
- async with client.get_table(instance_id, table_id) as table:
- yield table
diff --git a/tests/system/data/test_execute_query_async.py b/tests/system/data/test_execute_query_async.py
deleted file mode 100644
index a680d2de0..000000000
--- a/tests/system/data/test_execute_query_async.py
+++ /dev/null
@@ -1,288 +0,0 @@
-# Copyright 2024 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 pytest
-
-import os
-from unittest import mock
-from .test_execute_query_utils import (
- ChannelMockAsync,
- response_with_metadata,
- response_with_result,
-)
-from google.api_core import exceptions as core_exceptions
-from google.cloud.bigtable.data import BigtableDataClientAsync
-import google.cloud.bigtable.data._async.client
-
-TABLE_NAME = "TABLE_NAME"
-INSTANCE_NAME = "INSTANCE_NAME"
-
-
-class TestAsyncExecuteQuery:
- @pytest.fixture()
- def async_channel_mock(self):
- with mock.patch.dict(os.environ, {"BIGTABLE_EMULATOR_HOST": "localhost"}):
- yield ChannelMockAsync()
-
- @pytest.fixture()
- def async_client(self, async_channel_mock):
- with mock.patch.dict(
- os.environ, {"BIGTABLE_EMULATOR_HOST": "localhost"}
- ), mock.patch.object(
- google.cloud.bigtable.data._async.client,
- "PooledChannel",
- return_value=async_channel_mock,
- ):
- yield BigtableDataClientAsync()
-
- @pytest.mark.asyncio
- async def test_execute_query(self, async_client, async_channel_mock):
- values = [
- response_with_metadata(),
- response_with_result("test"),
- response_with_result(8, resume_token=b"r1"),
- response_with_result("test2"),
- response_with_result(9, resume_token=b"r2"),
- response_with_result("test3"),
- response_with_result(None, resume_token=b"r3"),
- ]
- async_channel_mock.set_values(values)
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- results = [r async for r in result]
- assert results[0]["a"] == "test"
- assert results[0]["b"] == 8
- assert results[1]["a"] == "test2"
- assert results[1]["b"] == 9
- assert results[2]["a"] == "test3"
- assert results[2]["b"] is None
- assert len(async_channel_mock.execute_query_calls) == 1
-
- @pytest.mark.asyncio
- async def test_execute_query_with_params(self, async_client, async_channel_mock):
- values = [
- response_with_metadata(),
- response_with_result("test2"),
- response_with_result(9, resume_token=b"r2"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME} WHERE b=@b",
- INSTANCE_NAME,
- parameters={"b": 9},
- )
- results = [r async for r in result]
- assert len(results) == 1
- assert results[0]["a"] == "test2"
- assert results[0]["b"] == 9
- assert len(async_channel_mock.execute_query_calls) == 1
-
- @pytest.mark.asyncio
- async def test_execute_query_error_before_metadata(
- self, async_client, async_channel_mock
- ):
- from google.api_core.exceptions import DeadlineExceeded
-
- values = [
- DeadlineExceeded(""),
- response_with_metadata(),
- response_with_result("test"),
- response_with_result(8, resume_token=b"r1"),
- response_with_result("test2"),
- response_with_result(9, resume_token=b"r2"),
- response_with_result("test3"),
- response_with_result(None, resume_token=b"r3"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- results = [r async for r in result]
- assert len(results) == 3
- assert len(async_channel_mock.execute_query_calls) == 2
-
- @pytest.mark.asyncio
- async def test_execute_query_error_after_metadata(
- self, async_client, async_channel_mock
- ):
- from google.api_core.exceptions import DeadlineExceeded
-
- values = [
- response_with_metadata(),
- DeadlineExceeded(""),
- response_with_metadata(),
- response_with_result("test"),
- response_with_result(8, resume_token=b"r1"),
- response_with_result("test2"),
- response_with_result(9, resume_token=b"r2"),
- response_with_result("test3"),
- response_with_result(None, resume_token=b"r3"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- results = [r async for r in result]
- assert len(results) == 3
- assert len(async_channel_mock.execute_query_calls) == 2
- assert async_channel_mock.resume_tokens == []
-
- @pytest.mark.asyncio
- async def test_execute_query_with_retries(self, async_client, async_channel_mock):
- from google.api_core.exceptions import DeadlineExceeded
-
- values = [
- response_with_metadata(),
- response_with_result("test"),
- response_with_result(8, resume_token=b"r1"),
- DeadlineExceeded(""),
- response_with_result("test2"),
- response_with_result(9, resume_token=b"r2"),
- response_with_result("test3"),
- DeadlineExceeded(""),
- response_with_result("test3"),
- response_with_result(None, resume_token=b"r3"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- results = [r async for r in result]
- assert results[0]["a"] == "test"
- assert results[0]["b"] == 8
- assert results[1]["a"] == "test2"
- assert results[1]["b"] == 9
- assert results[2]["a"] == "test3"
- assert results[2]["b"] is None
- assert len(async_channel_mock.execute_query_calls) == 3
- assert async_channel_mock.resume_tokens == [b"r1", b"r2"]
-
- @pytest.mark.parametrize(
- "exception",
- [
- (core_exceptions.DeadlineExceeded("")),
- (core_exceptions.Aborted("")),
- (core_exceptions.ServiceUnavailable("")),
- ],
- )
- @pytest.mark.asyncio
- async def test_execute_query_retryable_error(
- self, async_client, async_channel_mock, exception
- ):
- values = [
- response_with_metadata(),
- response_with_result("test", resume_token=b"t1"),
- exception,
- response_with_result(8, resume_token=b"t2"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- results = [r async for r in result]
- assert len(results) == 1
- assert len(async_channel_mock.execute_query_calls) == 2
- assert async_channel_mock.resume_tokens == [b"t1"]
-
- @pytest.mark.asyncio
- async def test_execute_query_retry_partial_row(
- self, async_client, async_channel_mock
- ):
- values = [
- response_with_metadata(),
- response_with_result("test", resume_token=b"t1"),
- core_exceptions.DeadlineExceeded(""),
- response_with_result(8, resume_token=b"t2"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- results = [r async for r in result]
- assert results[0]["a"] == "test"
- assert results[0]["b"] == 8
- assert len(async_channel_mock.execute_query_calls) == 2
- assert async_channel_mock.resume_tokens == [b"t1"]
-
- @pytest.mark.parametrize(
- "ExceptionType",
- [
- (core_exceptions.InvalidArgument),
- (core_exceptions.FailedPrecondition),
- (core_exceptions.PermissionDenied),
- (core_exceptions.MethodNotImplemented),
- (core_exceptions.Cancelled),
- (core_exceptions.AlreadyExists),
- (core_exceptions.OutOfRange),
- (core_exceptions.DataLoss),
- (core_exceptions.Unauthenticated),
- (core_exceptions.NotFound),
- (core_exceptions.ResourceExhausted),
- (core_exceptions.Unknown),
- (core_exceptions.InternalServerError),
- ],
- )
- @pytest.mark.asyncio
- async def test_execute_query_non_retryable(
- self, async_client, async_channel_mock, ExceptionType
- ):
- values = [
- response_with_metadata(),
- response_with_result("test"),
- response_with_result(8, resume_token=b"r1"),
- ExceptionType(""),
- response_with_result("test2"),
- response_with_result(9, resume_token=b"r2"),
- response_with_result("test3"),
- response_with_result(None, resume_token=b"r3"),
- ]
- async_channel_mock.set_values(values)
-
- result = await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- r = await result.__anext__()
- assert r["a"] == "test"
- assert r["b"] == 8
-
- with pytest.raises(ExceptionType):
- r = await result.__anext__()
-
- assert len(async_channel_mock.execute_query_calls) == 1
- assert async_channel_mock.resume_tokens == []
-
- @pytest.mark.asyncio
- async def test_execute_query_metadata_received_multiple_times_detected(
- self, async_client, async_channel_mock
- ):
- values = [
- response_with_metadata(),
- response_with_metadata(),
- ]
- async_channel_mock.set_values(values)
-
- with pytest.raises(Exception, match="Invalid ExecuteQuery response received"):
- [
- r
- async for r in await async_client.execute_query(
- f"SELECT a, b FROM {TABLE_NAME}", INSTANCE_NAME
- )
- ]
diff --git a/tests/system/data/test_execute_query_utils.py b/tests/system/data/test_execute_query_utils.py
deleted file mode 100644
index 9e27b95f2..000000000
--- a/tests/system/data/test_execute_query_utils.py
+++ /dev/null
@@ -1,272 +0,0 @@
-# Copyright 2024 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.
-
-from unittest import mock
-
-import google.cloud.bigtable_v2.services.bigtable.transports.pooled_grpc_asyncio as pga
-from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
-from google.cloud.bigtable_v2.types.data import ProtoRows, Value as PBValue
-import grpc.aio
-
-
-try:
- # async mock for python3.7-10
- from asyncio import coroutine
-
- def async_mock(return_value=None):
- coro = mock.Mock(name="CoroutineResult")
- corofunc = mock.Mock(name="CoroutineFunction", side_effect=coroutine(coro))
- corofunc.coro = coro
- corofunc.coro.return_value = return_value
- return corofunc
-
-except ImportError:
- # async mock for python3.11 or later
- from unittest.mock import AsyncMock
-
- def async_mock(return_value=None):
- return AsyncMock(return_value=return_value)
-
-
-# ExecuteQueryResponse(
-# metadata={
-# "proto_schema": {
-# "columns": [
-# {"name": "test1", "type_": TYPE_INT},
-# {"name": "test2", "type_": TYPE_INT},
-# ]
-# }
-# }
-# ),
-# ExecuteQueryResponse(
-# results={"proto_rows_batch": {"batch_data": messages[0]}}
-# ),
-
-
-def response_with_metadata():
- schema = {"a": "string_type", "b": "int64_type"}
- return ExecuteQueryResponse(
- {
- "metadata": {
- "proto_schema": {
- "columns": [
- {"name": name, "type_": {_type: {}}}
- for name, _type in schema.items()
- ]
- }
- }
- }
- )
-
-
-def response_with_result(*args, resume_token=None):
- if resume_token is None:
- resume_token_dict = {}
- else:
- resume_token_dict = {"resume_token": resume_token}
-
- values = []
- for column_value in args:
- if column_value is None:
- pb_value = PBValue({})
- else:
- pb_value = PBValue(
- {
- "int_value"
- if isinstance(column_value, int)
- else "string_value": column_value
- }
- )
- values.append(pb_value)
- rows = ProtoRows(values=values)
-
- return ExecuteQueryResponse(
- {
- "results": {
- "proto_rows_batch": {
- "batch_data": ProtoRows.serialize(rows),
- },
- **resume_token_dict,
- }
- }
- )
-
-
-class ExecuteQueryStreamMock:
- def __init__(self, parent):
- self.parent = parent
- self.iter = iter(self.parent.values)
-
- def __call__(self, *args, **kwargs):
- request = args[0]
-
- self.parent.execute_query_calls.append(request)
- if request.resume_token:
- self.parent.resume_tokens.append(request.resume_token)
-
- def stream():
- for value in self.iter:
- if isinstance(value, Exception):
- raise value
- else:
- yield value
-
- return stream()
-
-
-class ChannelMock:
- def __init__(self):
- self.execute_query_calls = []
- self.values = []
- self.resume_tokens = []
-
- def set_values(self, values):
- self.values = values
-
- def unary_unary(self, *args, **kwargs):
- return mock.MagicMock()
-
- def unary_stream(self, *args, **kwargs):
- if args[0] == "/google.bigtable.v2.Bigtable/ExecuteQuery":
- return ExecuteQueryStreamMock(self)
- return mock.MagicMock()
-
-
-class ChannelMockAsync(pga.PooledChannel, mock.MagicMock):
- def __init__(self, *args, **kwargs):
- mock.MagicMock.__init__(self, *args, **kwargs)
- self.execute_query_calls = []
- self.values = []
- self.resume_tokens = []
- self._iter = []
-
- def get_async_get(self, *args, **kwargs):
- return self.async_gen
-
- def set_values(self, values):
- self.values = values
- self._iter = iter(self.values)
-
- def unary_unary(self, *args, **kwargs):
- return async_mock()
-
- def unary_stream(self, *args, **kwargs):
- if args[0] == "/google.bigtable.v2.Bigtable/ExecuteQuery":
-
- async def async_gen(*args, **kwargs):
- for value in self._iter:
- yield value
-
- iter = async_gen()
-
- class UnaryStreamCallMock(grpc.aio.UnaryStreamCall):
- def __aiter__(self):
- async def _impl(*args, **kwargs):
- try:
- while True:
- yield await self.read()
- except StopAsyncIteration:
- pass
-
- return _impl()
-
- async def read(self):
- value = await iter.__anext__()
- if isinstance(value, Exception):
- raise value
- return value
-
- def add_done_callback(*args, **kwargs):
- pass
-
- def cancel(*args, **kwargs):
- pass
-
- def cancelled(*args, **kwargs):
- pass
-
- def code(*args, **kwargs):
- pass
-
- def details(*args, **kwargs):
- pass
-
- def done(*args, **kwargs):
- pass
-
- def initial_metadata(*args, **kwargs):
- pass
-
- def time_remaining(*args, **kwargs):
- pass
-
- def trailing_metadata(*args, **kwargs):
- pass
-
- async def wait_for_connection(*args, **kwargs):
- return async_mock()
-
- class UnaryStreamMultiCallableMock(grpc.aio.UnaryStreamMultiCallable):
- def __init__(self, parent):
- self.parent = parent
-
- def __call__(
- self,
- request,
- *,
- timeout=None,
- metadata=None,
- credentials=None,
- wait_for_ready=None,
- compression=None
- ):
- self.parent.execute_query_calls.append(request)
- if request.resume_token:
- self.parent.resume_tokens.append(request.resume_token)
- return UnaryStreamCallMock()
-
- def add_done_callback(*args, **kwargs):
- pass
-
- def cancel(*args, **kwargs):
- pass
-
- def cancelled(*args, **kwargs):
- pass
-
- def code(*args, **kwargs):
- pass
-
- def details(*args, **kwargs):
- pass
-
- def done(*args, **kwargs):
- pass
-
- def initial_metadata(*args, **kwargs):
- pass
-
- def time_remaining(*args, **kwargs):
- pass
-
- def trailing_metadata(*args, **kwargs):
- pass
-
- def wait_for_connection(*args, **kwargs):
- pass
-
- # unary_stream should return https://grpc.github.io/grpc/python/grpc_asyncio.html#grpc.aio.UnaryStreamMultiCallable
- # PTAL https://grpc.github.io/grpc/python/grpc_asyncio.html#grpc.aio.Channel.unary_stream
- return UnaryStreamMultiCallableMock(self)
- return async_mock()
diff --git a/tests/system/data/test_system.py b/tests/system/data/test_system.py
deleted file mode 100644
index 9fe208551..000000000
--- a/tests/system/data/test_system.py
+++ /dev/null
@@ -1,942 +0,0 @@
-# Copyright 2023 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 pytest
-import pytest_asyncio
-import asyncio
-import uuid
-import os
-from google.api_core import retry
-from google.api_core.exceptions import ClientError
-
-from google.cloud.bigtable.data.read_modify_write_rules import _MAX_INCREMENT_VALUE
-from google.cloud.environment_vars import BIGTABLE_EMULATOR
-
-TEST_FAMILY = "test-family"
-TEST_FAMILY_2 = "test-family-2"
-
-
-@pytest.fixture(scope="session")
-def column_family_config():
- """
- specify column families to create when creating a new test table
- """
- from google.cloud.bigtable_admin_v2 import types
-
- return {TEST_FAMILY: types.ColumnFamily(), TEST_FAMILY_2: types.ColumnFamily()}
-
-
-@pytest.fixture(scope="session")
-def init_table_id():
- """
- The table_id to use when creating a new test table
- """
- return f"test-table-{uuid.uuid4().hex}"
-
-
-@pytest.fixture(scope="session")
-def cluster_config(project_id):
- """
- Configuration for the clusters to use when creating a new instance
- """
- from google.cloud.bigtable_admin_v2 import types
-
- cluster = {
- "test-cluster": types.Cluster(
- location=f"projects/{project_id}/locations/us-central1-b",
- serve_nodes=1,
- )
- }
- return cluster
-
-
-class TempRowBuilder:
- """
- Used to add rows to a table for testing purposes.
- """
-
- def __init__(self, table):
- self.rows = []
- self.table = table
-
- async def add_row(
- self, row_key, *, family=TEST_FAMILY, qualifier=b"q", value=b"test-value"
- ):
- if isinstance(value, str):
- value = value.encode("utf-8")
- elif isinstance(value, int):
- value = value.to_bytes(8, byteorder="big", signed=True)
- request = {
- "table_name": self.table.table_name,
- "row_key": row_key,
- "mutations": [
- {
- "set_cell": {
- "family_name": family,
- "column_qualifier": qualifier,
- "value": value,
- }
- }
- ],
- }
- await self.table.client._gapic_client.mutate_row(request)
- self.rows.append(row_key)
-
- async def delete_rows(self):
- if self.rows:
- request = {
- "table_name": self.table.table_name,
- "entries": [
- {"row_key": row, "mutations": [{"delete_from_row": {}}]}
- for row in self.rows
- ],
- }
- await self.table.client._gapic_client.mutate_rows(request)
-
-
-@pytest.mark.usefixtures("table")
-async def _retrieve_cell_value(table, row_key):
- """
- Helper to read an individual row
- """
- from google.cloud.bigtable.data import ReadRowsQuery
-
- row_list = await table.read_rows(ReadRowsQuery(row_keys=row_key))
- assert len(row_list) == 1
- row = row_list[0]
- cell = row.cells[0]
- return cell.value
-
-
-async def _create_row_and_mutation(
- table, temp_rows, *, start_value=b"start", new_value=b"new_value"
-):
- """
- Helper to create a new row, and a sample set_cell mutation to change its value
- """
- from google.cloud.bigtable.data.mutations import SetCell
-
- row_key = uuid.uuid4().hex.encode()
- family = TEST_FAMILY
- qualifier = b"test-qualifier"
- await temp_rows.add_row(
- row_key, family=family, qualifier=qualifier, value=start_value
- )
- # ensure cell is initialized
- assert (await _retrieve_cell_value(table, row_key)) == start_value
-
- mutation = SetCell(family=TEST_FAMILY, qualifier=qualifier, new_value=new_value)
- return row_key, mutation
-
-
-@pytest_asyncio.fixture(scope="function")
-async def temp_rows(table):
- builder = TempRowBuilder(table)
- yield builder
- await builder.delete_rows()
-
-
-@pytest.mark.usefixtures("table")
-@pytest.mark.usefixtures("client")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=10)
-@pytest.mark.asyncio
-async def test_ping_and_warm_gapic(client, table):
- """
- Simple ping rpc test
- This test ensures channels are able to authenticate with backend
- """
- request = {"name": table.instance_name}
- await client._gapic_client.ping_and_warm(request)
-
-
-@pytest.mark.usefixtures("table")
-@pytest.mark.usefixtures("client")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_ping_and_warm(client, table):
- """
- Test ping and warm from handwritten client
- """
- try:
- channel = client.transport._grpc_channel.pool[0]
- except Exception:
- # for sync client
- channel = client.transport._grpc_channel
- results = await client._ping_and_warm_instances(channel)
- assert len(results) == 1
- assert results[0] is None
-
-
-@pytest.mark.asyncio
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-async def test_mutation_set_cell(table, temp_rows):
- """
- Ensure cells can be set properly
- """
- row_key = b"bulk_mutate"
- new_value = uuid.uuid4().hex.encode()
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value
- )
- await table.mutate_row(row_key, mutation)
-
- # ensure cell is updated
- assert (await _retrieve_cell_value(table, row_key)) == new_value
-
-
-@pytest.mark.skipif(
- bool(os.environ.get(BIGTABLE_EMULATOR)), reason="emulator doesn't use splits"
-)
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_sample_row_keys(client, table, temp_rows, column_split_config):
- """
- Sample keys should return a single sample in small test tables
- """
- await temp_rows.add_row(b"row_key_1")
- await temp_rows.add_row(b"row_key_2")
-
- results = await table.sample_row_keys()
- assert len(results) == len(column_split_config) + 1
- # first keys should match the split config
- for idx in range(len(column_split_config)):
- assert results[idx][0] == column_split_config[idx]
- assert isinstance(results[idx][1], int)
- # last sample should be empty key
- assert results[-1][0] == b""
- assert isinstance(results[-1][1], int)
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_bulk_mutations_set_cell(client, table, temp_rows):
- """
- Ensure cells can be set properly
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry
-
- new_value = uuid.uuid4().hex.encode()
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value
- )
- bulk_mutation = RowMutationEntry(row_key, [mutation])
-
- await table.bulk_mutate_rows([bulk_mutation])
-
- # ensure cell is updated
- assert (await _retrieve_cell_value(table, row_key)) == new_value
-
-
-@pytest.mark.asyncio
-async def test_bulk_mutations_raise_exception(client, table):
- """
- If an invalid mutation is passed, an exception should be raised
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry, SetCell
- from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
- from google.cloud.bigtable.data.exceptions import FailedMutationEntryError
-
- row_key = uuid.uuid4().hex.encode()
- mutation = SetCell(family="nonexistent", qualifier=b"test-qualifier", new_value=b"")
- bulk_mutation = RowMutationEntry(row_key, [mutation])
-
- with pytest.raises(MutationsExceptionGroup) as exc:
- await table.bulk_mutate_rows([bulk_mutation])
- assert len(exc.value.exceptions) == 1
- entry_error = exc.value.exceptions[0]
- assert isinstance(entry_error, FailedMutationEntryError)
- assert entry_error.index == 0
- assert entry_error.entry == bulk_mutation
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_mutations_batcher_context_manager(client, table, temp_rows):
- """
- test batcher with context manager. Should flush on exit
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry
-
- new_value, new_value2 = [uuid.uuid4().hex.encode() for _ in range(2)]
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value
- )
- row_key2, mutation2 = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value2
- )
- bulk_mutation = RowMutationEntry(row_key, [mutation])
- bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
-
- async with table.mutations_batcher() as batcher:
- await batcher.append(bulk_mutation)
- await batcher.append(bulk_mutation2)
- # ensure cell is updated
- assert (await _retrieve_cell_value(table, row_key)) == new_value
- assert len(batcher._staged_entries) == 0
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_mutations_batcher_timer_flush(client, table, temp_rows):
- """
- batch should occur after flush_interval seconds
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry
-
- new_value = uuid.uuid4().hex.encode()
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value
- )
- bulk_mutation = RowMutationEntry(row_key, [mutation])
- flush_interval = 0.1
- async with table.mutations_batcher(flush_interval=flush_interval) as batcher:
- await batcher.append(bulk_mutation)
- await asyncio.sleep(0)
- assert len(batcher._staged_entries) == 1
- await asyncio.sleep(flush_interval + 0.1)
- assert len(batcher._staged_entries) == 0
- # ensure cell is updated
- assert (await _retrieve_cell_value(table, row_key)) == new_value
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_mutations_batcher_count_flush(client, table, temp_rows):
- """
- batch should flush after flush_limit_mutation_count mutations
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry
-
- new_value, new_value2 = [uuid.uuid4().hex.encode() for _ in range(2)]
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value
- )
- bulk_mutation = RowMutationEntry(row_key, [mutation])
- row_key2, mutation2 = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value2
- )
- bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
-
- async with table.mutations_batcher(flush_limit_mutation_count=2) as batcher:
- await batcher.append(bulk_mutation)
- assert len(batcher._flush_jobs) == 0
- # should be noop; flush not scheduled
- assert len(batcher._staged_entries) == 1
- await batcher.append(bulk_mutation2)
- # task should now be scheduled
- assert len(batcher._flush_jobs) == 1
- await asyncio.gather(*batcher._flush_jobs)
- assert len(batcher._staged_entries) == 0
- assert len(batcher._flush_jobs) == 0
- # ensure cells were updated
- assert (await _retrieve_cell_value(table, row_key)) == new_value
- assert (await _retrieve_cell_value(table, row_key2)) == new_value2
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_mutations_batcher_bytes_flush(client, table, temp_rows):
- """
- batch should flush after flush_limit_bytes bytes
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry
-
- new_value, new_value2 = [uuid.uuid4().hex.encode() for _ in range(2)]
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value
- )
- bulk_mutation = RowMutationEntry(row_key, [mutation])
- row_key2, mutation2 = await _create_row_and_mutation(
- table, temp_rows, new_value=new_value2
- )
- bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
-
- flush_limit = bulk_mutation.size() + bulk_mutation2.size() - 1
-
- async with table.mutations_batcher(flush_limit_bytes=flush_limit) as batcher:
- await batcher.append(bulk_mutation)
- assert len(batcher._flush_jobs) == 0
- assert len(batcher._staged_entries) == 1
- await batcher.append(bulk_mutation2)
- # task should now be scheduled
- assert len(batcher._flush_jobs) == 1
- assert len(batcher._staged_entries) == 0
- # let flush complete
- await asyncio.gather(*batcher._flush_jobs)
- # ensure cells were updated
- assert (await _retrieve_cell_value(table, row_key)) == new_value
- assert (await _retrieve_cell_value(table, row_key2)) == new_value2
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_mutations_batcher_no_flush(client, table, temp_rows):
- """
- test with no flush requirements met
- """
- from google.cloud.bigtable.data.mutations import RowMutationEntry
-
- new_value = uuid.uuid4().hex.encode()
- start_value = b"unchanged"
- row_key, mutation = await _create_row_and_mutation(
- table, temp_rows, start_value=start_value, new_value=new_value
- )
- bulk_mutation = RowMutationEntry(row_key, [mutation])
- row_key2, mutation2 = await _create_row_and_mutation(
- table, temp_rows, start_value=start_value, new_value=new_value
- )
- bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
-
- size_limit = bulk_mutation.size() + bulk_mutation2.size() + 1
- async with table.mutations_batcher(
- flush_limit_bytes=size_limit, flush_limit_mutation_count=3, flush_interval=1
- ) as batcher:
- await batcher.append(bulk_mutation)
- assert len(batcher._staged_entries) == 1
- await batcher.append(bulk_mutation2)
- # flush not scheduled
- assert len(batcher._flush_jobs) == 0
- await asyncio.sleep(0.01)
- assert len(batcher._staged_entries) == 2
- assert len(batcher._flush_jobs) == 0
- # ensure cells were not updated
- assert (await _retrieve_cell_value(table, row_key)) == start_value
- assert (await _retrieve_cell_value(table, row_key2)) == start_value
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.parametrize(
- "start,increment,expected",
- [
- (0, 0, 0),
- (0, 1, 1),
- (0, -1, -1),
- (1, 0, 1),
- (0, -100, -100),
- (0, 3000, 3000),
- (10, 4, 14),
- (_MAX_INCREMENT_VALUE, -_MAX_INCREMENT_VALUE, 0),
- (_MAX_INCREMENT_VALUE, 2, -_MAX_INCREMENT_VALUE),
- (-_MAX_INCREMENT_VALUE, -2, _MAX_INCREMENT_VALUE),
- ],
-)
-@pytest.mark.asyncio
-async def test_read_modify_write_row_increment(
- client, table, temp_rows, start, increment, expected
-):
- """
- test read_modify_write_row
- """
- from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
-
- row_key = b"test-row-key"
- family = TEST_FAMILY
- qualifier = b"test-qualifier"
- await temp_rows.add_row(row_key, value=start, family=family, qualifier=qualifier)
-
- rule = IncrementRule(family, qualifier, increment)
- result = await table.read_modify_write_row(row_key, rule)
- assert result.row_key == row_key
- assert len(result) == 1
- assert result[0].family == family
- assert result[0].qualifier == qualifier
- assert int(result[0]) == expected
- # ensure that reading from server gives same value
- assert (await _retrieve_cell_value(table, row_key)) == result[0].value
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.parametrize(
- "start,append,expected",
- [
- (b"", b"", b""),
- ("", "", b""),
- (b"abc", b"123", b"abc123"),
- (b"abc", "123", b"abc123"),
- ("", b"1", b"1"),
- (b"abc", "", b"abc"),
- (b"hello", b"world", b"helloworld"),
- ],
-)
-@pytest.mark.asyncio
-async def test_read_modify_write_row_append(
- client, table, temp_rows, start, append, expected
-):
- """
- test read_modify_write_row
- """
- from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
-
- row_key = b"test-row-key"
- family = TEST_FAMILY
- qualifier = b"test-qualifier"
- await temp_rows.add_row(row_key, value=start, family=family, qualifier=qualifier)
-
- rule = AppendValueRule(family, qualifier, append)
- result = await table.read_modify_write_row(row_key, rule)
- assert result.row_key == row_key
- assert len(result) == 1
- assert result[0].family == family
- assert result[0].qualifier == qualifier
- assert result[0].value == expected
- # ensure that reading from server gives same value
- assert (await _retrieve_cell_value(table, row_key)) == result[0].value
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_read_modify_write_row_chained(client, table, temp_rows):
- """
- test read_modify_write_row with multiple rules
- """
- from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
- from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
-
- row_key = b"test-row-key"
- family = TEST_FAMILY
- qualifier = b"test-qualifier"
- start_amount = 1
- increment_amount = 10
- await temp_rows.add_row(
- row_key, value=start_amount, family=family, qualifier=qualifier
- )
- rule = [
- IncrementRule(family, qualifier, increment_amount),
- AppendValueRule(family, qualifier, "hello"),
- AppendValueRule(family, qualifier, "world"),
- AppendValueRule(family, qualifier, "!"),
- ]
- result = await table.read_modify_write_row(row_key, rule)
- assert result.row_key == row_key
- assert result[0].family == family
- assert result[0].qualifier == qualifier
- # result should be a bytes number string for the IncrementRules, followed by the AppendValueRule values
- assert (
- result[0].value
- == (start_amount + increment_amount).to_bytes(8, "big", signed=True)
- + b"helloworld!"
- )
- # ensure that reading from server gives same value
- assert (await _retrieve_cell_value(table, row_key)) == result[0].value
-
-
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.parametrize(
- "start_val,predicate_range,expected_result",
- [
- (1, (0, 2), True),
- (-1, (0, 2), False),
- ],
-)
-@pytest.mark.asyncio
-async def test_check_and_mutate(
- client, table, temp_rows, start_val, predicate_range, expected_result
-):
- """
- test that check_and_mutate_row works applies the right mutations, and returns the right result
- """
- from google.cloud.bigtable.data.mutations import SetCell
- from google.cloud.bigtable.data.row_filters import ValueRangeFilter
-
- row_key = b"test-row-key"
- family = TEST_FAMILY
- qualifier = b"test-qualifier"
-
- await temp_rows.add_row(
- row_key, value=start_val, family=family, qualifier=qualifier
- )
-
- false_mutation_value = b"false-mutation-value"
- false_mutation = SetCell(
- family=TEST_FAMILY, qualifier=qualifier, new_value=false_mutation_value
- )
- true_mutation_value = b"true-mutation-value"
- true_mutation = SetCell(
- family=TEST_FAMILY, qualifier=qualifier, new_value=true_mutation_value
- )
- predicate = ValueRangeFilter(predicate_range[0], predicate_range[1])
- result = await table.check_and_mutate_row(
- row_key,
- predicate,
- true_case_mutations=true_mutation,
- false_case_mutations=false_mutation,
- )
- assert result == expected_result
- # ensure cell is updated
- expected_value = true_mutation_value if expected_result else false_mutation_value
- assert (await _retrieve_cell_value(table, row_key)) == expected_value
-
-
-@pytest.mark.skipif(
- bool(os.environ.get(BIGTABLE_EMULATOR)),
- reason="emulator doesn't raise InvalidArgument",
-)
-@pytest.mark.usefixtures("client")
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_check_and_mutate_empty_request(client, table):
- """
- check_and_mutate with no true or fale mutations should raise an error
- """
- from google.api_core import exceptions
-
- with pytest.raises(exceptions.InvalidArgument) as e:
- await table.check_and_mutate_row(
- b"row_key", None, true_case_mutations=None, false_case_mutations=None
- )
- assert "No mutations provided" in str(e.value)
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_stream(table, temp_rows):
- """
- Ensure that the read_rows_stream method works
- """
- await temp_rows.add_row(b"row_key_1")
- await temp_rows.add_row(b"row_key_2")
-
- # full table scan
- generator = await table.read_rows_stream({})
- first_row = await generator.__anext__()
- second_row = await generator.__anext__()
- assert first_row.row_key == b"row_key_1"
- assert second_row.row_key == b"row_key_2"
- with pytest.raises(StopAsyncIteration):
- await generator.__anext__()
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows(table, temp_rows):
- """
- Ensure that the read_rows method works
- """
- await temp_rows.add_row(b"row_key_1")
- await temp_rows.add_row(b"row_key_2")
- # full table scan
- row_list = await table.read_rows({})
- assert len(row_list) == 2
- assert row_list[0].row_key == b"row_key_1"
- assert row_list[1].row_key == b"row_key_2"
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_sharded_simple(table, temp_rows):
- """
- Test read rows sharded with two queries
- """
- from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
-
- await temp_rows.add_row(b"a")
- await temp_rows.add_row(b"b")
- await temp_rows.add_row(b"c")
- await temp_rows.add_row(b"d")
- query1 = ReadRowsQuery(row_keys=[b"a", b"c"])
- query2 = ReadRowsQuery(row_keys=[b"b", b"d"])
- row_list = await table.read_rows_sharded([query1, query2])
- assert len(row_list) == 4
- assert row_list[0].row_key == b"a"
- assert row_list[1].row_key == b"c"
- assert row_list[2].row_key == b"b"
- assert row_list[3].row_key == b"d"
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_sharded_from_sample(table, temp_rows):
- """
- Test end-to-end sharding
- """
- from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
- from google.cloud.bigtable.data.read_rows_query import RowRange
-
- await temp_rows.add_row(b"a")
- await temp_rows.add_row(b"b")
- await temp_rows.add_row(b"c")
- await temp_rows.add_row(b"d")
-
- table_shard_keys = await table.sample_row_keys()
- query = ReadRowsQuery(row_ranges=[RowRange(start_key=b"b", end_key=b"z")])
- shard_queries = query.shard(table_shard_keys)
- row_list = await table.read_rows_sharded(shard_queries)
- assert len(row_list) == 3
- assert row_list[0].row_key == b"b"
- assert row_list[1].row_key == b"c"
- assert row_list[2].row_key == b"d"
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_sharded_filters_limits(table, temp_rows):
- """
- Test read rows sharded with filters and limits
- """
- from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
- from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
-
- await temp_rows.add_row(b"a")
- await temp_rows.add_row(b"b")
- await temp_rows.add_row(b"c")
- await temp_rows.add_row(b"d")
-
- label_filter1 = ApplyLabelFilter("first")
- label_filter2 = ApplyLabelFilter("second")
- query1 = ReadRowsQuery(row_keys=[b"a", b"c"], limit=1, row_filter=label_filter1)
- query2 = ReadRowsQuery(row_keys=[b"b", b"d"], row_filter=label_filter2)
- row_list = await table.read_rows_sharded([query1, query2])
- assert len(row_list) == 3
- assert row_list[0].row_key == b"a"
- assert row_list[1].row_key == b"b"
- assert row_list[2].row_key == b"d"
- assert row_list[0][0].labels == ["first"]
- assert row_list[1][0].labels == ["second"]
- assert row_list[2][0].labels == ["second"]
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_range_query(table, temp_rows):
- """
- Ensure that the read_rows method works
- """
- from google.cloud.bigtable.data import ReadRowsQuery
- from google.cloud.bigtable.data import RowRange
-
- await temp_rows.add_row(b"a")
- await temp_rows.add_row(b"b")
- await temp_rows.add_row(b"c")
- await temp_rows.add_row(b"d")
- # full table scan
- query = ReadRowsQuery(row_ranges=RowRange(start_key=b"b", end_key=b"d"))
- row_list = await table.read_rows(query)
- assert len(row_list) == 2
- assert row_list[0].row_key == b"b"
- assert row_list[1].row_key == b"c"
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_single_key_query(table, temp_rows):
- """
- Ensure that the read_rows method works with specified query
- """
- from google.cloud.bigtable.data import ReadRowsQuery
-
- await temp_rows.add_row(b"a")
- await temp_rows.add_row(b"b")
- await temp_rows.add_row(b"c")
- await temp_rows.add_row(b"d")
- # retrieve specific keys
- query = ReadRowsQuery(row_keys=[b"a", b"c"])
- row_list = await table.read_rows(query)
- assert len(row_list) == 2
- assert row_list[0].row_key == b"a"
- assert row_list[1].row_key == b"c"
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.asyncio
-async def test_read_rows_with_filter(table, temp_rows):
- """
- ensure filters are applied
- """
- from google.cloud.bigtable.data import ReadRowsQuery
- from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
-
- await temp_rows.add_row(b"a")
- await temp_rows.add_row(b"b")
- await temp_rows.add_row(b"c")
- await temp_rows.add_row(b"d")
- # retrieve keys with filter
- expected_label = "test-label"
- row_filter = ApplyLabelFilter(expected_label)
- query = ReadRowsQuery(row_filter=row_filter)
- row_list = await table.read_rows(query)
- assert len(row_list) == 4
- for row in row_list:
- assert row[0].labels == [expected_label]
-
-
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_read_rows_stream_close(table, temp_rows):
- """
- Ensure that the read_rows_stream can be closed
- """
- from google.cloud.bigtable.data import ReadRowsQuery
-
- await temp_rows.add_row(b"row_key_1")
- await temp_rows.add_row(b"row_key_2")
- # full table scan
- query = ReadRowsQuery()
- generator = await table.read_rows_stream(query)
- # grab first row
- first_row = await generator.__anext__()
- assert first_row.row_key == b"row_key_1"
- # close stream early
- await generator.aclose()
- with pytest.raises(StopAsyncIteration):
- await generator.__anext__()
-
-
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_read_row(table, temp_rows):
- """
- Test read_row (single row helper)
- """
- from google.cloud.bigtable.data import Row
-
- await temp_rows.add_row(b"row_key_1", value=b"value")
- row = await table.read_row(b"row_key_1")
- assert isinstance(row, Row)
- assert row.row_key == b"row_key_1"
- assert row.cells[0].value == b"value"
-
-
-@pytest.mark.skipif(
- bool(os.environ.get(BIGTABLE_EMULATOR)),
- reason="emulator doesn't raise InvalidArgument",
-)
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_read_row_missing(table):
- """
- Test read_row when row does not exist
- """
- from google.api_core import exceptions
-
- row_key = "row_key_not_exist"
- result = await table.read_row(row_key)
- assert result is None
- with pytest.raises(exceptions.InvalidArgument) as e:
- await table.read_row("")
- assert "Row keys must be non-empty" in str(e)
-
-
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_read_row_w_filter(table, temp_rows):
- """
- Test read_row (single row helper)
- """
- from google.cloud.bigtable.data import Row
- from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
-
- await temp_rows.add_row(b"row_key_1", value=b"value")
- expected_label = "test-label"
- label_filter = ApplyLabelFilter(expected_label)
- row = await table.read_row(b"row_key_1", row_filter=label_filter)
- assert isinstance(row, Row)
- assert row.row_key == b"row_key_1"
- assert row.cells[0].value == b"value"
- assert row.cells[0].labels == [expected_label]
-
-
-@pytest.mark.skipif(
- bool(os.environ.get(BIGTABLE_EMULATOR)),
- reason="emulator doesn't raise InvalidArgument",
-)
-@pytest.mark.usefixtures("table")
-@pytest.mark.asyncio
-async def test_row_exists(table, temp_rows):
- from google.api_core import exceptions
-
- """Test row_exists with rows that exist and don't exist"""
- assert await table.row_exists(b"row_key_1") is False
- await temp_rows.add_row(b"row_key_1")
- assert await table.row_exists(b"row_key_1") is True
- assert await table.row_exists("row_key_1") is True
- assert await table.row_exists(b"row_key_2") is False
- assert await table.row_exists("row_key_2") is False
- assert await table.row_exists("3") is False
- await temp_rows.add_row(b"3")
- assert await table.row_exists(b"3") is True
- with pytest.raises(exceptions.InvalidArgument) as e:
- await table.row_exists("")
- assert "Row keys must be non-empty" in str(e)
-
-
-@pytest.mark.usefixtures("table")
-@retry.AsyncRetry(predicate=retry.if_exception_type(ClientError), initial=1, maximum=5)
-@pytest.mark.parametrize(
- "cell_value,filter_input,expect_match",
- [
- (b"abc", b"abc", True),
- (b"abc", "abc", True),
- (b".", ".", True),
- (".*", ".*", True),
- (".*", b".*", True),
- ("a", ".*", False),
- (b".*", b".*", True),
- (r"\a", r"\a", True),
- (b"\xe2\x98\x83", "☃", True),
- ("☃", "☃", True),
- (r"\C☃", r"\C☃", True),
- (1, 1, True),
- (2, 1, False),
- (68, 68, True),
- ("D", 68, False),
- (68, "D", False),
- (-1, -1, True),
- (2852126720, 2852126720, True),
- (-1431655766, -1431655766, True),
- (-1431655766, -1, False),
- ],
-)
-@pytest.mark.asyncio
-async def test_literal_value_filter(
- table, temp_rows, cell_value, filter_input, expect_match
-):
- """
- Literal value filter does complex escaping on re2 strings.
- Make sure inputs are properly interpreted by the server
- """
- from google.cloud.bigtable.data.row_filters import LiteralValueFilter
- from google.cloud.bigtable.data import ReadRowsQuery
-
- f = LiteralValueFilter(filter_input)
- await temp_rows.add_row(b"row_key_1", value=cell_value)
- query = ReadRowsQuery(row_filter=f)
- row_list = await table.read_rows(query)
- assert len(row_list) == bool(
- expect_match
- ), f"row {type(cell_value)}({cell_value}) not found with {type(filter_input)}({filter_input}) filter"
diff --git a/tests/system/data/test_system_async.py b/tests/system/data/test_system_async.py
new file mode 100644
index 000000000..b97859de1
--- /dev/null
+++ b/tests/system/data/test_system_async.py
@@ -0,0 +1,1016 @@
+# Copyright 2024 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 pytest
+import asyncio
+import uuid
+import os
+from google.api_core import retry
+from google.api_core.exceptions import ClientError
+
+from google.cloud.bigtable.data.read_modify_write_rules import _MAX_INCREMENT_VALUE
+from google.cloud.environment_vars import BIGTABLE_EMULATOR
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+from . import TEST_FAMILY, TEST_FAMILY_2
+
+
+__CROSS_SYNC_OUTPUT__ = "tests.system.data.test_system_autogen"
+
+
+@CrossSync.convert_class(
+ sync_name="TempRowBuilder",
+ add_mapping_for_name="TempRowBuilder",
+)
+class TempRowBuilderAsync:
+ """
+ Used to add rows to a table for testing purposes.
+ """
+
+ def __init__(self, table):
+ self.rows = []
+ self.table = table
+
+ @CrossSync.convert
+ async def add_row(
+ self, row_key, *, family=TEST_FAMILY, qualifier=b"q", value=b"test-value"
+ ):
+ if isinstance(value, str):
+ value = value.encode("utf-8")
+ elif isinstance(value, int):
+ value = value.to_bytes(8, byteorder="big", signed=True)
+ request = {
+ "table_name": self.table.table_name,
+ "row_key": row_key,
+ "mutations": [
+ {
+ "set_cell": {
+ "family_name": family,
+ "column_qualifier": qualifier,
+ "value": value,
+ }
+ }
+ ],
+ }
+ await self.table.client._gapic_client.mutate_row(request)
+ self.rows.append(row_key)
+
+ @CrossSync.convert
+ async def delete_rows(self):
+ if self.rows:
+ request = {
+ "table_name": self.table.table_name,
+ "entries": [
+ {"row_key": row, "mutations": [{"delete_from_row": {}}]}
+ for row in self.rows
+ ],
+ }
+ await self.table.client._gapic_client.mutate_rows(request)
+
+
+@CrossSync.convert_class(sync_name="TestSystem")
+class TestSystemAsync:
+ @CrossSync.convert
+ @CrossSync.pytest_fixture(scope="session")
+ async def client(self):
+ project = os.getenv("GOOGLE_CLOUD_PROJECT") or None
+ async with CrossSync.DataClient(project=project) as client:
+ yield client
+
+ @CrossSync.convert
+ @CrossSync.pytest_fixture(scope="session")
+ async def table(self, client, table_id, instance_id):
+ async with client.get_table(instance_id, table_id) as table:
+ yield table
+
+ @CrossSync.drop
+ @pytest.fixture(scope="session")
+ def event_loop(self):
+ loop = asyncio.get_event_loop()
+ yield loop
+ loop.stop()
+ loop.close()
+
+ @pytest.fixture(scope="session")
+ def column_family_config(self):
+ """
+ specify column families to create when creating a new test table
+ """
+ from google.cloud.bigtable_admin_v2 import types
+
+ return {TEST_FAMILY: types.ColumnFamily(), TEST_FAMILY_2: types.ColumnFamily()}
+
+ @pytest.fixture(scope="session")
+ def init_table_id(self):
+ """
+ The table_id to use when creating a new test table
+ """
+ return f"test-table-{uuid.uuid4().hex}"
+
+ @pytest.fixture(scope="session")
+ def cluster_config(self, project_id):
+ """
+ Configuration for the clusters to use when creating a new instance
+ """
+ from google.cloud.bigtable_admin_v2 import types
+
+ cluster = {
+ "test-cluster": types.Cluster(
+ location=f"projects/{project_id}/locations/us-central1-b",
+ serve_nodes=1,
+ )
+ }
+ return cluster
+
+ @CrossSync.convert
+ @pytest.mark.usefixtures("table")
+ async def _retrieve_cell_value(self, table, row_key):
+ """
+ Helper to read an individual row
+ """
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ row_list = await table.read_rows(ReadRowsQuery(row_keys=row_key))
+ assert len(row_list) == 1
+ row = row_list[0]
+ cell = row.cells[0]
+ return cell.value
+
+ @CrossSync.convert
+ async def _create_row_and_mutation(
+ self, table, temp_rows, *, start_value=b"start", new_value=b"new_value"
+ ):
+ """
+ Helper to create a new row, and a sample set_cell mutation to change its value
+ """
+ from google.cloud.bigtable.data.mutations import SetCell
+
+ row_key = uuid.uuid4().hex.encode()
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ await temp_rows.add_row(
+ row_key, family=family, qualifier=qualifier, value=start_value
+ )
+ # ensure cell is initialized
+ assert await self._retrieve_cell_value(table, row_key) == start_value
+
+ mutation = SetCell(family=TEST_FAMILY, qualifier=qualifier, new_value=new_value)
+ return row_key, mutation
+
+ @CrossSync.convert
+ @CrossSync.pytest_fixture(scope="function")
+ async def temp_rows(self, table):
+ builder = CrossSync.TempRowBuilder(table)
+ yield builder
+ await builder.delete_rows()
+
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.usefixtures("client")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=10
+ )
+ @CrossSync.pytest
+ async def test_ping_and_warm_gapic(self, client, table):
+ """
+ Simple ping rpc test
+ This test ensures channels are able to authenticate with backend
+ """
+ request = {"name": table.instance_name}
+ await client._gapic_client.ping_and_warm(request)
+
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.usefixtures("client")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_ping_and_warm(self, client, table):
+ """
+ Test ping and warm from handwritten client
+ """
+ results = await client._ping_and_warm_instances()
+ assert len(results) == 1
+ assert results[0] is None
+
+ @CrossSync.pytest
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ async def test_mutation_set_cell(self, table, temp_rows):
+ """
+ Ensure cells can be set properly
+ """
+ row_key = b"bulk_mutate"
+ new_value = uuid.uuid4().hex.encode()
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ await table.mutate_row(row_key, mutation)
+
+ # ensure cell is updated
+ assert (await self._retrieve_cell_value(table, row_key)) == new_value
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)), reason="emulator doesn't use splits"
+ )
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_sample_row_keys(self, client, table, temp_rows, column_split_config):
+ """
+ Sample keys should return a single sample in small test tables
+ """
+ await temp_rows.add_row(b"row_key_1")
+ await temp_rows.add_row(b"row_key_2")
+
+ results = await table.sample_row_keys()
+ assert len(results) == len(column_split_config) + 1
+ # first keys should match the split config
+ for idx in range(len(column_split_config)):
+ assert results[idx][0] == column_split_config[idx]
+ assert isinstance(results[idx][1], int)
+ # last sample should be empty key
+ assert results[-1][0] == b""
+ assert isinstance(results[-1][1], int)
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_bulk_mutations_set_cell(self, client, table, temp_rows):
+ """
+ Ensure cells can be set properly
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value = uuid.uuid4().hex.encode()
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+
+ await table.bulk_mutate_rows([bulk_mutation])
+
+ # ensure cell is updated
+ assert (await self._retrieve_cell_value(table, row_key)) == new_value
+
+ @CrossSync.pytest
+ async def test_bulk_mutations_raise_exception(self, client, table):
+ """
+ If an invalid mutation is passed, an exception should be raised
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry, SetCell
+ from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+ from google.cloud.bigtable.data.exceptions import FailedMutationEntryError
+
+ row_key = uuid.uuid4().hex.encode()
+ mutation = SetCell(
+ family="nonexistent", qualifier=b"test-qualifier", new_value=b""
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+
+ with pytest.raises(MutationsExceptionGroup) as exc:
+ await table.bulk_mutate_rows([bulk_mutation])
+ assert len(exc.value.exceptions) == 1
+ entry_error = exc.value.exceptions[0]
+ assert isinstance(entry_error, FailedMutationEntryError)
+ assert entry_error.index == 0
+ assert entry_error.entry == bulk_mutation
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_mutations_batcher_context_manager(self, client, table, temp_rows):
+ """
+ test batcher with context manager. Should flush on exit
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value, new_value2 = [uuid.uuid4().hex.encode() for _ in range(2)]
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ row_key2, mutation2 = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value2
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+
+ async with table.mutations_batcher() as batcher:
+ await batcher.append(bulk_mutation)
+ await batcher.append(bulk_mutation2)
+ # ensure cell is updated
+ assert (await self._retrieve_cell_value(table, row_key)) == new_value
+ assert len(batcher._staged_entries) == 0
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_mutations_batcher_timer_flush(self, client, table, temp_rows):
+ """
+ batch should occur after flush_interval seconds
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value = uuid.uuid4().hex.encode()
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ flush_interval = 0.1
+ async with table.mutations_batcher(flush_interval=flush_interval) as batcher:
+ await batcher.append(bulk_mutation)
+ await CrossSync.yield_to_event_loop()
+ assert len(batcher._staged_entries) == 1
+ await CrossSync.sleep(flush_interval + 0.1)
+ assert len(batcher._staged_entries) == 0
+ # ensure cell is updated
+ assert (await self._retrieve_cell_value(table, row_key)) == new_value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_mutations_batcher_count_flush(self, client, table, temp_rows):
+ """
+ batch should flush after flush_limit_mutation_count mutations
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value, new_value2 = [uuid.uuid4().hex.encode() for _ in range(2)]
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ row_key2, mutation2 = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value2
+ )
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+
+ async with table.mutations_batcher(flush_limit_mutation_count=2) as batcher:
+ await batcher.append(bulk_mutation)
+ assert len(batcher._flush_jobs) == 0
+ # should be noop; flush not scheduled
+ assert len(batcher._staged_entries) == 1
+ await batcher.append(bulk_mutation2)
+ # task should now be scheduled
+ assert len(batcher._flush_jobs) == 1
+ # let flush complete
+ for future in list(batcher._flush_jobs):
+ await future
+ # for sync version: grab result
+ future.result()
+ assert len(batcher._staged_entries) == 0
+ assert len(batcher._flush_jobs) == 0
+ # ensure cells were updated
+ assert (await self._retrieve_cell_value(table, row_key)) == new_value
+ assert (await self._retrieve_cell_value(table, row_key2)) == new_value2
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_mutations_batcher_bytes_flush(self, client, table, temp_rows):
+ """
+ batch should flush after flush_limit_bytes bytes
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value, new_value2 = [uuid.uuid4().hex.encode() for _ in range(2)]
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ row_key2, mutation2 = await self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value2
+ )
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+
+ flush_limit = bulk_mutation.size() + bulk_mutation2.size() - 1
+
+ async with table.mutations_batcher(flush_limit_bytes=flush_limit) as batcher:
+ await batcher.append(bulk_mutation)
+ assert len(batcher._flush_jobs) == 0
+ assert len(batcher._staged_entries) == 1
+ await batcher.append(bulk_mutation2)
+ # task should now be scheduled
+ assert len(batcher._flush_jobs) == 1
+ assert len(batcher._staged_entries) == 0
+ # let flush complete
+ for future in list(batcher._flush_jobs):
+ await future
+ # for sync version: grab result
+ future.result()
+ # ensure cells were updated
+ assert (await self._retrieve_cell_value(table, row_key)) == new_value
+ assert (await self._retrieve_cell_value(table, row_key2)) == new_value2
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_mutations_batcher_no_flush(self, client, table, temp_rows):
+ """
+ test with no flush requirements met
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value = uuid.uuid4().hex.encode()
+ start_value = b"unchanged"
+ row_key, mutation = await self._create_row_and_mutation(
+ table, temp_rows, start_value=start_value, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ row_key2, mutation2 = await self._create_row_and_mutation(
+ table, temp_rows, start_value=start_value, new_value=new_value
+ )
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+
+ size_limit = bulk_mutation.size() + bulk_mutation2.size() + 1
+ async with table.mutations_batcher(
+ flush_limit_bytes=size_limit, flush_limit_mutation_count=3, flush_interval=1
+ ) as batcher:
+ await batcher.append(bulk_mutation)
+ assert len(batcher._staged_entries) == 1
+ await batcher.append(bulk_mutation2)
+ # flush not scheduled
+ assert len(batcher._flush_jobs) == 0
+ await CrossSync.yield_to_event_loop()
+ assert len(batcher._staged_entries) == 2
+ assert len(batcher._flush_jobs) == 0
+ # ensure cells were not updated
+ assert (await self._retrieve_cell_value(table, row_key)) == start_value
+ assert (await self._retrieve_cell_value(table, row_key2)) == start_value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_mutations_batcher_large_batch(self, client, table, temp_rows):
+ """
+ test batcher with large batch of mutations
+ """
+ from google.cloud.bigtable.data.mutations import RowMutationEntry, SetCell
+
+ add_mutation = SetCell(
+ family=TEST_FAMILY, qualifier=b"test-qualifier", new_value=b"a"
+ )
+ row_mutations = []
+ for i in range(50_000):
+ row_key = uuid.uuid4().hex.encode()
+ row_mutations.append(RowMutationEntry(row_key, [add_mutation]))
+ # append row key for eventual deletion
+ temp_rows.rows.append(row_key)
+
+ async with table.mutations_batcher() as batcher:
+ for mutation in row_mutations:
+ await batcher.append(mutation)
+ # ensure cell is updated
+ assert len(batcher._staged_entries) == 0
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.parametrize(
+ "start,increment,expected",
+ [
+ (0, 0, 0),
+ (0, 1, 1),
+ (0, -1, -1),
+ (1, 0, 1),
+ (0, -100, -100),
+ (0, 3000, 3000),
+ (10, 4, 14),
+ (_MAX_INCREMENT_VALUE, -_MAX_INCREMENT_VALUE, 0),
+ (_MAX_INCREMENT_VALUE, 2, -_MAX_INCREMENT_VALUE),
+ (-_MAX_INCREMENT_VALUE, -2, _MAX_INCREMENT_VALUE),
+ ],
+ )
+ @CrossSync.pytest
+ async def test_read_modify_write_row_increment(
+ self, client, table, temp_rows, start, increment, expected
+ ):
+ """
+ test read_modify_write_row
+ """
+ from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ await temp_rows.add_row(
+ row_key, value=start, family=family, qualifier=qualifier
+ )
+
+ rule = IncrementRule(family, qualifier, increment)
+ result = await table.read_modify_write_row(row_key, rule)
+ assert result.row_key == row_key
+ assert len(result) == 1
+ assert result[0].family == family
+ assert result[0].qualifier == qualifier
+ assert int(result[0]) == expected
+ # ensure that reading from server gives same value
+ assert (await self._retrieve_cell_value(table, row_key)) == result[0].value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.parametrize(
+ "start,append,expected",
+ [
+ (b"", b"", b""),
+ ("", "", b""),
+ (b"abc", b"123", b"abc123"),
+ (b"abc", "123", b"abc123"),
+ ("", b"1", b"1"),
+ (b"abc", "", b"abc"),
+ (b"hello", b"world", b"helloworld"),
+ ],
+ )
+ @CrossSync.pytest
+ async def test_read_modify_write_row_append(
+ self, client, table, temp_rows, start, append, expected
+ ):
+ """
+ test read_modify_write_row
+ """
+ from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ await temp_rows.add_row(
+ row_key, value=start, family=family, qualifier=qualifier
+ )
+
+ rule = AppendValueRule(family, qualifier, append)
+ result = await table.read_modify_write_row(row_key, rule)
+ assert result.row_key == row_key
+ assert len(result) == 1
+ assert result[0].family == family
+ assert result[0].qualifier == qualifier
+ assert result[0].value == expected
+ # ensure that reading from server gives same value
+ assert (await self._retrieve_cell_value(table, row_key)) == result[0].value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_read_modify_write_row_chained(self, client, table, temp_rows):
+ """
+ test read_modify_write_row with multiple rules
+ """
+ from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+ from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ start_amount = 1
+ increment_amount = 10
+ await temp_rows.add_row(
+ row_key, value=start_amount, family=family, qualifier=qualifier
+ )
+ rule = [
+ IncrementRule(family, qualifier, increment_amount),
+ AppendValueRule(family, qualifier, "hello"),
+ AppendValueRule(family, qualifier, "world"),
+ AppendValueRule(family, qualifier, "!"),
+ ]
+ result = await table.read_modify_write_row(row_key, rule)
+ assert result.row_key == row_key
+ assert result[0].family == family
+ assert result[0].qualifier == qualifier
+ # result should be a bytes number string for the IncrementRules, followed by the AppendValueRule values
+ assert (
+ result[0].value
+ == (start_amount + increment_amount).to_bytes(8, "big", signed=True)
+ + b"helloworld!"
+ )
+ # ensure that reading from server gives same value
+ assert (await self._retrieve_cell_value(table, row_key)) == result[0].value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.parametrize(
+ "start_val,predicate_range,expected_result",
+ [
+ (1, (0, 2), True),
+ (-1, (0, 2), False),
+ ],
+ )
+ @CrossSync.pytest
+ async def test_check_and_mutate(
+ self, client, table, temp_rows, start_val, predicate_range, expected_result
+ ):
+ """
+ test that check_and_mutate_row works applies the right mutations, and returns the right result
+ """
+ from google.cloud.bigtable.data.mutations import SetCell
+ from google.cloud.bigtable.data.row_filters import ValueRangeFilter
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+
+ await temp_rows.add_row(
+ row_key, value=start_val, family=family, qualifier=qualifier
+ )
+
+ false_mutation_value = b"false-mutation-value"
+ false_mutation = SetCell(
+ family=TEST_FAMILY, qualifier=qualifier, new_value=false_mutation_value
+ )
+ true_mutation_value = b"true-mutation-value"
+ true_mutation = SetCell(
+ family=TEST_FAMILY, qualifier=qualifier, new_value=true_mutation_value
+ )
+ predicate = ValueRangeFilter(predicate_range[0], predicate_range[1])
+ result = await table.check_and_mutate_row(
+ row_key,
+ predicate,
+ true_case_mutations=true_mutation,
+ false_case_mutations=false_mutation,
+ )
+ assert result == expected_result
+ # ensure cell is updated
+ expected_value = (
+ true_mutation_value if expected_result else false_mutation_value
+ )
+ assert (await self._retrieve_cell_value(table, row_key)) == expected_value
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)),
+ reason="emulator doesn't raise InvalidArgument",
+ )
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_check_and_mutate_empty_request(self, client, table):
+ """
+ check_and_mutate with no true or fale mutations should raise an error
+ """
+ from google.api_core import exceptions
+
+ with pytest.raises(exceptions.InvalidArgument) as e:
+ await table.check_and_mutate_row(
+ b"row_key", None, true_case_mutations=None, false_case_mutations=None
+ )
+ assert "No mutations provided" in str(e.value)
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.convert(replace_symbols={"__anext__": "__next__"})
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_stream(self, table, temp_rows):
+ """
+ Ensure that the read_rows_stream method works
+ """
+ await temp_rows.add_row(b"row_key_1")
+ await temp_rows.add_row(b"row_key_2")
+
+ # full table scan
+ generator = await table.read_rows_stream({})
+ first_row = await generator.__anext__()
+ second_row = await generator.__anext__()
+ assert first_row.row_key == b"row_key_1"
+ assert second_row.row_key == b"row_key_2"
+ with pytest.raises(CrossSync.StopIteration):
+ await generator.__anext__()
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows(self, table, temp_rows):
+ """
+ Ensure that the read_rows method works
+ """
+ await temp_rows.add_row(b"row_key_1")
+ await temp_rows.add_row(b"row_key_2")
+ # full table scan
+ row_list = await table.read_rows({})
+ assert len(row_list) == 2
+ assert row_list[0].row_key == b"row_key_1"
+ assert row_list[1].row_key == b"row_key_2"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_sharded_simple(self, table, temp_rows):
+ """
+ Test read rows sharded with two queries
+ """
+ from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+
+ await temp_rows.add_row(b"a")
+ await temp_rows.add_row(b"b")
+ await temp_rows.add_row(b"c")
+ await temp_rows.add_row(b"d")
+ query1 = ReadRowsQuery(row_keys=[b"a", b"c"])
+ query2 = ReadRowsQuery(row_keys=[b"b", b"d"])
+ row_list = await table.read_rows_sharded([query1, query2])
+ assert len(row_list) == 4
+ assert row_list[0].row_key == b"a"
+ assert row_list[1].row_key == b"c"
+ assert row_list[2].row_key == b"b"
+ assert row_list[3].row_key == b"d"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_sharded_from_sample(self, table, temp_rows):
+ """
+ Test end-to-end sharding
+ """
+ from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+ from google.cloud.bigtable.data.read_rows_query import RowRange
+
+ await temp_rows.add_row(b"a")
+ await temp_rows.add_row(b"b")
+ await temp_rows.add_row(b"c")
+ await temp_rows.add_row(b"d")
+
+ table_shard_keys = await table.sample_row_keys()
+ query = ReadRowsQuery(row_ranges=[RowRange(start_key=b"b", end_key=b"z")])
+ shard_queries = query.shard(table_shard_keys)
+ row_list = await table.read_rows_sharded(shard_queries)
+ assert len(row_list) == 3
+ assert row_list[0].row_key == b"b"
+ assert row_list[1].row_key == b"c"
+ assert row_list[2].row_key == b"d"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_sharded_filters_limits(self, table, temp_rows):
+ """
+ Test read rows sharded with filters and limits
+ """
+ from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+ from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
+
+ await temp_rows.add_row(b"a")
+ await temp_rows.add_row(b"b")
+ await temp_rows.add_row(b"c")
+ await temp_rows.add_row(b"d")
+
+ label_filter1 = ApplyLabelFilter("first")
+ label_filter2 = ApplyLabelFilter("second")
+ query1 = ReadRowsQuery(row_keys=[b"a", b"c"], limit=1, row_filter=label_filter1)
+ query2 = ReadRowsQuery(row_keys=[b"b", b"d"], row_filter=label_filter2)
+ row_list = await table.read_rows_sharded([query1, query2])
+ assert len(row_list) == 3
+ assert row_list[0].row_key == b"a"
+ assert row_list[1].row_key == b"b"
+ assert row_list[2].row_key == b"d"
+ assert row_list[0][0].labels == ["first"]
+ assert row_list[1][0].labels == ["second"]
+ assert row_list[2][0].labels == ["second"]
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_range_query(self, table, temp_rows):
+ """
+ Ensure that the read_rows method works
+ """
+ from google.cloud.bigtable.data import ReadRowsQuery
+ from google.cloud.bigtable.data import RowRange
+
+ await temp_rows.add_row(b"a")
+ await temp_rows.add_row(b"b")
+ await temp_rows.add_row(b"c")
+ await temp_rows.add_row(b"d")
+ # full table scan
+ query = ReadRowsQuery(row_ranges=RowRange(start_key=b"b", end_key=b"d"))
+ row_list = await table.read_rows(query)
+ assert len(row_list) == 2
+ assert row_list[0].row_key == b"b"
+ assert row_list[1].row_key == b"c"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_single_key_query(self, table, temp_rows):
+ """
+ Ensure that the read_rows method works with specified query
+ """
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ await temp_rows.add_row(b"a")
+ await temp_rows.add_row(b"b")
+ await temp_rows.add_row(b"c")
+ await temp_rows.add_row(b"d")
+ # retrieve specific keys
+ query = ReadRowsQuery(row_keys=[b"a", b"c"])
+ row_list = await table.read_rows(query)
+ assert len(row_list) == 2
+ assert row_list[0].row_key == b"a"
+ assert row_list[1].row_key == b"c"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @CrossSync.pytest
+ async def test_read_rows_with_filter(self, table, temp_rows):
+ """
+ ensure filters are applied
+ """
+ from google.cloud.bigtable.data import ReadRowsQuery
+ from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
+
+ await temp_rows.add_row(b"a")
+ await temp_rows.add_row(b"b")
+ await temp_rows.add_row(b"c")
+ await temp_rows.add_row(b"d")
+ # retrieve keys with filter
+ expected_label = "test-label"
+ row_filter = ApplyLabelFilter(expected_label)
+ query = ReadRowsQuery(row_filter=row_filter)
+ row_list = await table.read_rows(query)
+ assert len(row_list) == 4
+ for row in row_list:
+ assert row[0].labels == [expected_label]
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.convert(replace_symbols={"__anext__": "__next__", "aclose": "close"})
+ @CrossSync.pytest
+ async def test_read_rows_stream_close(self, table, temp_rows):
+ """
+ Ensure that the read_rows_stream can be closed
+ """
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ await temp_rows.add_row(b"row_key_1")
+ await temp_rows.add_row(b"row_key_2")
+ # full table scan
+ query = ReadRowsQuery()
+ generator = await table.read_rows_stream(query)
+ # grab first row
+ first_row = await generator.__anext__()
+ assert first_row.row_key == b"row_key_1"
+ # close stream early
+ await generator.aclose()
+ with pytest.raises(CrossSync.StopIteration):
+ await generator.__anext__()
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_read_row(self, table, temp_rows):
+ """
+ Test read_row (single row helper)
+ """
+ from google.cloud.bigtable.data import Row
+
+ await temp_rows.add_row(b"row_key_1", value=b"value")
+ row = await table.read_row(b"row_key_1")
+ assert isinstance(row, Row)
+ assert row.row_key == b"row_key_1"
+ assert row.cells[0].value == b"value"
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)),
+ reason="emulator doesn't raise InvalidArgument",
+ )
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_read_row_missing(self, table):
+ """
+ Test read_row when row does not exist
+ """
+ from google.api_core import exceptions
+
+ row_key = "row_key_not_exist"
+ result = await table.read_row(row_key)
+ assert result is None
+ with pytest.raises(exceptions.InvalidArgument) as e:
+ await table.read_row("")
+ assert "Row keys must be non-empty" in str(e)
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_read_row_w_filter(self, table, temp_rows):
+ """
+ Test read_row (single row helper)
+ """
+ from google.cloud.bigtable.data import Row
+ from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
+
+ await temp_rows.add_row(b"row_key_1", value=b"value")
+ expected_label = "test-label"
+ label_filter = ApplyLabelFilter(expected_label)
+ row = await table.read_row(b"row_key_1", row_filter=label_filter)
+ assert isinstance(row, Row)
+ assert row.row_key == b"row_key_1"
+ assert row.cells[0].value == b"value"
+ assert row.cells[0].labels == [expected_label]
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)),
+ reason="emulator doesn't raise InvalidArgument",
+ )
+ @pytest.mark.usefixtures("table")
+ @CrossSync.pytest
+ async def test_row_exists(self, table, temp_rows):
+ from google.api_core import exceptions
+
+ """Test row_exists with rows that exist and don't exist"""
+ assert await table.row_exists(b"row_key_1") is False
+ await temp_rows.add_row(b"row_key_1")
+ assert await table.row_exists(b"row_key_1") is True
+ assert await table.row_exists("row_key_1") is True
+ assert await table.row_exists(b"row_key_2") is False
+ assert await table.row_exists("row_key_2") is False
+ assert await table.row_exists("3") is False
+ await temp_rows.add_row(b"3")
+ assert await table.row_exists(b"3") is True
+ with pytest.raises(exceptions.InvalidArgument) as e:
+ await table.row_exists("")
+ assert "Row keys must be non-empty" in str(e)
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @pytest.mark.parametrize(
+ "cell_value,filter_input,expect_match",
+ [
+ (b"abc", b"abc", True),
+ (b"abc", "abc", True),
+ (b".", ".", True),
+ (".*", ".*", True),
+ (".*", b".*", True),
+ ("a", ".*", False),
+ (b".*", b".*", True),
+ (r"\a", r"\a", True),
+ (b"\xe2\x98\x83", "☃", True),
+ ("☃", "☃", True),
+ (r"\C☃", r"\C☃", True),
+ (1, 1, True),
+ (2, 1, False),
+ (68, 68, True),
+ ("D", 68, False),
+ (68, "D", False),
+ (-1, -1, True),
+ (2852126720, 2852126720, True),
+ (-1431655766, -1431655766, True),
+ (-1431655766, -1, False),
+ ],
+ )
+ @CrossSync.pytest
+ async def test_literal_value_filter(
+ self, table, temp_rows, cell_value, filter_input, expect_match
+ ):
+ """
+ Literal value filter does complex escaping on re2 strings.
+ Make sure inputs are properly interpreted by the server
+ """
+ from google.cloud.bigtable.data.row_filters import LiteralValueFilter
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ f = LiteralValueFilter(filter_input)
+ await temp_rows.add_row(b"row_key_1", value=cell_value)
+ query = ReadRowsQuery(row_filter=f)
+ row_list = await table.read_rows(query)
+ assert len(row_list) == bool(
+ expect_match
+ ), f"row {type(cell_value)}({cell_value}) not found with {type(filter_input)}({filter_input}) filter"
diff --git a/tests/system/data/test_system_autogen.py b/tests/system/data/test_system_autogen.py
new file mode 100644
index 000000000..2dde82bf1
--- /dev/null
+++ b/tests/system/data/test_system_autogen.py
@@ -0,0 +1,828 @@
+# Copyright 2024 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.
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+import pytest
+import uuid
+import os
+from google.api_core import retry
+from google.api_core.exceptions import ClientError
+from google.cloud.bigtable.data.read_modify_write_rules import _MAX_INCREMENT_VALUE
+from google.cloud.environment_vars import BIGTABLE_EMULATOR
+from google.cloud.bigtable.data._cross_sync import CrossSync
+from . import TEST_FAMILY, TEST_FAMILY_2
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("TempRowBuilder")
+class TempRowBuilder:
+ """
+ Used to add rows to a table for testing purposes.
+ """
+
+ def __init__(self, table):
+ self.rows = []
+ self.table = table
+
+ def add_row(
+ self, row_key, *, family=TEST_FAMILY, qualifier=b"q", value=b"test-value"
+ ):
+ if isinstance(value, str):
+ value = value.encode("utf-8")
+ elif isinstance(value, int):
+ value = value.to_bytes(8, byteorder="big", signed=True)
+ request = {
+ "table_name": self.table.table_name,
+ "row_key": row_key,
+ "mutations": [
+ {
+ "set_cell": {
+ "family_name": family,
+ "column_qualifier": qualifier,
+ "value": value,
+ }
+ }
+ ],
+ }
+ self.table.client._gapic_client.mutate_row(request)
+ self.rows.append(row_key)
+
+ def delete_rows(self):
+ if self.rows:
+ request = {
+ "table_name": self.table.table_name,
+ "entries": [
+ {"row_key": row, "mutations": [{"delete_from_row": {}}]}
+ for row in self.rows
+ ],
+ }
+ self.table.client._gapic_client.mutate_rows(request)
+
+
+class TestSystem:
+ @pytest.fixture(scope="session")
+ def client(self):
+ project = os.getenv("GOOGLE_CLOUD_PROJECT") or None
+ with CrossSync._Sync_Impl.DataClient(project=project) as client:
+ yield client
+
+ @pytest.fixture(scope="session")
+ def table(self, client, table_id, instance_id):
+ with client.get_table(instance_id, table_id) as table:
+ yield table
+
+ @pytest.fixture(scope="session")
+ def column_family_config(self):
+ """specify column families to create when creating a new test table"""
+ from google.cloud.bigtable_admin_v2 import types
+
+ return {TEST_FAMILY: types.ColumnFamily(), TEST_FAMILY_2: types.ColumnFamily()}
+
+ @pytest.fixture(scope="session")
+ def init_table_id(self):
+ """The table_id to use when creating a new test table"""
+ return f"test-table-{uuid.uuid4().hex}"
+
+ @pytest.fixture(scope="session")
+ def cluster_config(self, project_id):
+ """Configuration for the clusters to use when creating a new instance"""
+ from google.cloud.bigtable_admin_v2 import types
+
+ cluster = {
+ "test-cluster": types.Cluster(
+ location=f"projects/{project_id}/locations/us-central1-b", serve_nodes=1
+ )
+ }
+ return cluster
+
+ @pytest.mark.usefixtures("table")
+ def _retrieve_cell_value(self, table, row_key):
+ """Helper to read an individual row"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ row_list = table.read_rows(ReadRowsQuery(row_keys=row_key))
+ assert len(row_list) == 1
+ row = row_list[0]
+ cell = row.cells[0]
+ return cell.value
+
+ def _create_row_and_mutation(
+ self, table, temp_rows, *, start_value=b"start", new_value=b"new_value"
+ ):
+ """Helper to create a new row, and a sample set_cell mutation to change its value"""
+ from google.cloud.bigtable.data.mutations import SetCell
+
+ row_key = uuid.uuid4().hex.encode()
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ temp_rows.add_row(
+ row_key, family=family, qualifier=qualifier, value=start_value
+ )
+ assert self._retrieve_cell_value(table, row_key) == start_value
+ mutation = SetCell(family=TEST_FAMILY, qualifier=qualifier, new_value=new_value)
+ return (row_key, mutation)
+
+ @pytest.fixture(scope="function")
+ def temp_rows(self, table):
+ builder = CrossSync._Sync_Impl.TempRowBuilder(table)
+ yield builder
+ builder.delete_rows()
+
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.usefixtures("client")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=10
+ )
+ def test_ping_and_warm_gapic(self, client, table):
+ """Simple ping rpc test
+ This test ensures channels are able to authenticate with backend"""
+ request = {"name": table.instance_name}
+ client._gapic_client.ping_and_warm(request)
+
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.usefixtures("client")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_ping_and_warm(self, client, table):
+ """Test ping and warm from handwritten client"""
+ results = client._ping_and_warm_instances()
+ assert len(results) == 1
+ assert results[0] is None
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_mutation_set_cell(self, table, temp_rows):
+ """Ensure cells can be set properly"""
+ row_key = b"bulk_mutate"
+ new_value = uuid.uuid4().hex.encode()
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ table.mutate_row(row_key, mutation)
+ assert self._retrieve_cell_value(table, row_key) == new_value
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)), reason="emulator doesn't use splits"
+ )
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_sample_row_keys(self, client, table, temp_rows, column_split_config):
+ """Sample keys should return a single sample in small test tables"""
+ temp_rows.add_row(b"row_key_1")
+ temp_rows.add_row(b"row_key_2")
+ results = table.sample_row_keys()
+ assert len(results) == len(column_split_config) + 1
+ for idx in range(len(column_split_config)):
+ assert results[idx][0] == column_split_config[idx]
+ assert isinstance(results[idx][1], int)
+ assert results[-1][0] == b""
+ assert isinstance(results[-1][1], int)
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ def test_bulk_mutations_set_cell(self, client, table, temp_rows):
+ """Ensure cells can be set properly"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value = uuid.uuid4().hex.encode()
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ table.bulk_mutate_rows([bulk_mutation])
+ assert self._retrieve_cell_value(table, row_key) == new_value
+
+ def test_bulk_mutations_raise_exception(self, client, table):
+ """If an invalid mutation is passed, an exception should be raised"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry, SetCell
+ from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+ from google.cloud.bigtable.data.exceptions import FailedMutationEntryError
+
+ row_key = uuid.uuid4().hex.encode()
+ mutation = SetCell(
+ family="nonexistent", qualifier=b"test-qualifier", new_value=b""
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ with pytest.raises(MutationsExceptionGroup) as exc:
+ table.bulk_mutate_rows([bulk_mutation])
+ assert len(exc.value.exceptions) == 1
+ entry_error = exc.value.exceptions[0]
+ assert isinstance(entry_error, FailedMutationEntryError)
+ assert entry_error.index == 0
+ assert entry_error.entry == bulk_mutation
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_mutations_batcher_context_manager(self, client, table, temp_rows):
+ """test batcher with context manager. Should flush on exit"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ (new_value, new_value2) = [uuid.uuid4().hex.encode() for _ in range(2)]
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ (row_key2, mutation2) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value2
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+ with table.mutations_batcher() as batcher:
+ batcher.append(bulk_mutation)
+ batcher.append(bulk_mutation2)
+ assert self._retrieve_cell_value(table, row_key) == new_value
+ assert len(batcher._staged_entries) == 0
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_mutations_batcher_timer_flush(self, client, table, temp_rows):
+ """batch should occur after flush_interval seconds"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value = uuid.uuid4().hex.encode()
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ flush_interval = 0.1
+ with table.mutations_batcher(flush_interval=flush_interval) as batcher:
+ batcher.append(bulk_mutation)
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert len(batcher._staged_entries) == 1
+ CrossSync._Sync_Impl.sleep(flush_interval + 0.1)
+ assert len(batcher._staged_entries) == 0
+ assert self._retrieve_cell_value(table, row_key) == new_value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_mutations_batcher_count_flush(self, client, table, temp_rows):
+ """batch should flush after flush_limit_mutation_count mutations"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ (new_value, new_value2) = [uuid.uuid4().hex.encode() for _ in range(2)]
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ (row_key2, mutation2) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value2
+ )
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+ with table.mutations_batcher(flush_limit_mutation_count=2) as batcher:
+ batcher.append(bulk_mutation)
+ assert len(batcher._flush_jobs) == 0
+ assert len(batcher._staged_entries) == 1
+ batcher.append(bulk_mutation2)
+ assert len(batcher._flush_jobs) == 1
+ for future in list(batcher._flush_jobs):
+ future
+ future.result()
+ assert len(batcher._staged_entries) == 0
+ assert len(batcher._flush_jobs) == 0
+ assert self._retrieve_cell_value(table, row_key) == new_value
+ assert self._retrieve_cell_value(table, row_key2) == new_value2
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_mutations_batcher_bytes_flush(self, client, table, temp_rows):
+ """batch should flush after flush_limit_bytes bytes"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ (new_value, new_value2) = [uuid.uuid4().hex.encode() for _ in range(2)]
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ (row_key2, mutation2) = self._create_row_and_mutation(
+ table, temp_rows, new_value=new_value2
+ )
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+ flush_limit = bulk_mutation.size() + bulk_mutation2.size() - 1
+ with table.mutations_batcher(flush_limit_bytes=flush_limit) as batcher:
+ batcher.append(bulk_mutation)
+ assert len(batcher._flush_jobs) == 0
+ assert len(batcher._staged_entries) == 1
+ batcher.append(bulk_mutation2)
+ assert len(batcher._flush_jobs) == 1
+ assert len(batcher._staged_entries) == 0
+ for future in list(batcher._flush_jobs):
+ future
+ future.result()
+ assert self._retrieve_cell_value(table, row_key) == new_value
+ assert self._retrieve_cell_value(table, row_key2) == new_value2
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ def test_mutations_batcher_no_flush(self, client, table, temp_rows):
+ """test with no flush requirements met"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry
+
+ new_value = uuid.uuid4().hex.encode()
+ start_value = b"unchanged"
+ (row_key, mutation) = self._create_row_and_mutation(
+ table, temp_rows, start_value=start_value, new_value=new_value
+ )
+ bulk_mutation = RowMutationEntry(row_key, [mutation])
+ (row_key2, mutation2) = self._create_row_and_mutation(
+ table, temp_rows, start_value=start_value, new_value=new_value
+ )
+ bulk_mutation2 = RowMutationEntry(row_key2, [mutation2])
+ size_limit = bulk_mutation.size() + bulk_mutation2.size() + 1
+ with table.mutations_batcher(
+ flush_limit_bytes=size_limit, flush_limit_mutation_count=3, flush_interval=1
+ ) as batcher:
+ batcher.append(bulk_mutation)
+ assert len(batcher._staged_entries) == 1
+ batcher.append(bulk_mutation2)
+ assert len(batcher._flush_jobs) == 0
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert len(batcher._staged_entries) == 2
+ assert len(batcher._flush_jobs) == 0
+ assert self._retrieve_cell_value(table, row_key) == start_value
+ assert self._retrieve_cell_value(table, row_key2) == start_value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_mutations_batcher_large_batch(self, client, table, temp_rows):
+ """test batcher with large batch of mutations"""
+ from google.cloud.bigtable.data.mutations import RowMutationEntry, SetCell
+
+ add_mutation = SetCell(
+ family=TEST_FAMILY, qualifier=b"test-qualifier", new_value=b"a"
+ )
+ row_mutations = []
+ for i in range(50000):
+ row_key = uuid.uuid4().hex.encode()
+ row_mutations.append(RowMutationEntry(row_key, [add_mutation]))
+ temp_rows.rows.append(row_key)
+ with table.mutations_batcher() as batcher:
+ for mutation in row_mutations:
+ batcher.append(mutation)
+ assert len(batcher._staged_entries) == 0
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.parametrize(
+ "start,increment,expected",
+ [
+ (0, 0, 0),
+ (0, 1, 1),
+ (0, -1, -1),
+ (1, 0, 1),
+ (0, -100, -100),
+ (0, 3000, 3000),
+ (10, 4, 14),
+ (_MAX_INCREMENT_VALUE, -_MAX_INCREMENT_VALUE, 0),
+ (_MAX_INCREMENT_VALUE, 2, -_MAX_INCREMENT_VALUE),
+ (-_MAX_INCREMENT_VALUE, -2, _MAX_INCREMENT_VALUE),
+ ],
+ )
+ def test_read_modify_write_row_increment(
+ self, client, table, temp_rows, start, increment, expected
+ ):
+ """test read_modify_write_row"""
+ from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ temp_rows.add_row(row_key, value=start, family=family, qualifier=qualifier)
+ rule = IncrementRule(family, qualifier, increment)
+ result = table.read_modify_write_row(row_key, rule)
+ assert result.row_key == row_key
+ assert len(result) == 1
+ assert result[0].family == family
+ assert result[0].qualifier == qualifier
+ assert int(result[0]) == expected
+ assert self._retrieve_cell_value(table, row_key) == result[0].value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.parametrize(
+ "start,append,expected",
+ [
+ (b"", b"", b""),
+ ("", "", b""),
+ (b"abc", b"123", b"abc123"),
+ (b"abc", "123", b"abc123"),
+ ("", b"1", b"1"),
+ (b"abc", "", b"abc"),
+ (b"hello", b"world", b"helloworld"),
+ ],
+ )
+ def test_read_modify_write_row_append(
+ self, client, table, temp_rows, start, append, expected
+ ):
+ """test read_modify_write_row"""
+ from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ temp_rows.add_row(row_key, value=start, family=family, qualifier=qualifier)
+ rule = AppendValueRule(family, qualifier, append)
+ result = table.read_modify_write_row(row_key, rule)
+ assert result.row_key == row_key
+ assert len(result) == 1
+ assert result[0].family == family
+ assert result[0].qualifier == qualifier
+ assert result[0].value == expected
+ assert self._retrieve_cell_value(table, row_key) == result[0].value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ def test_read_modify_write_row_chained(self, client, table, temp_rows):
+ """test read_modify_write_row with multiple rules"""
+ from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+ from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ start_amount = 1
+ increment_amount = 10
+ temp_rows.add_row(
+ row_key, value=start_amount, family=family, qualifier=qualifier
+ )
+ rule = [
+ IncrementRule(family, qualifier, increment_amount),
+ AppendValueRule(family, qualifier, "hello"),
+ AppendValueRule(family, qualifier, "world"),
+ AppendValueRule(family, qualifier, "!"),
+ ]
+ result = table.read_modify_write_row(row_key, rule)
+ assert result.row_key == row_key
+ assert result[0].family == family
+ assert result[0].qualifier == qualifier
+ assert (
+ result[0].value
+ == (start_amount + increment_amount).to_bytes(8, "big", signed=True)
+ + b"helloworld!"
+ )
+ assert self._retrieve_cell_value(table, row_key) == result[0].value
+
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ @pytest.mark.parametrize(
+ "start_val,predicate_range,expected_result",
+ [(1, (0, 2), True), (-1, (0, 2), False)],
+ )
+ def test_check_and_mutate(
+ self, client, table, temp_rows, start_val, predicate_range, expected_result
+ ):
+ """test that check_and_mutate_row works applies the right mutations, and returns the right result"""
+ from google.cloud.bigtable.data.mutations import SetCell
+ from google.cloud.bigtable.data.row_filters import ValueRangeFilter
+
+ row_key = b"test-row-key"
+ family = TEST_FAMILY
+ qualifier = b"test-qualifier"
+ temp_rows.add_row(row_key, value=start_val, family=family, qualifier=qualifier)
+ false_mutation_value = b"false-mutation-value"
+ false_mutation = SetCell(
+ family=TEST_FAMILY, qualifier=qualifier, new_value=false_mutation_value
+ )
+ true_mutation_value = b"true-mutation-value"
+ true_mutation = SetCell(
+ family=TEST_FAMILY, qualifier=qualifier, new_value=true_mutation_value
+ )
+ predicate = ValueRangeFilter(predicate_range[0], predicate_range[1])
+ result = table.check_and_mutate_row(
+ row_key,
+ predicate,
+ true_case_mutations=true_mutation,
+ false_case_mutations=false_mutation,
+ )
+ assert result == expected_result
+ expected_value = (
+ true_mutation_value if expected_result else false_mutation_value
+ )
+ assert self._retrieve_cell_value(table, row_key) == expected_value
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)),
+ reason="emulator doesn't raise InvalidArgument",
+ )
+ @pytest.mark.usefixtures("client")
+ @pytest.mark.usefixtures("table")
+ def test_check_and_mutate_empty_request(self, client, table):
+ """check_and_mutate with no true or fale mutations should raise an error"""
+ from google.api_core import exceptions
+
+ with pytest.raises(exceptions.InvalidArgument) as e:
+ table.check_and_mutate_row(
+ b"row_key", None, true_case_mutations=None, false_case_mutations=None
+ )
+ assert "No mutations provided" in str(e.value)
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_stream(self, table, temp_rows):
+ """Ensure that the read_rows_stream method works"""
+ temp_rows.add_row(b"row_key_1")
+ temp_rows.add_row(b"row_key_2")
+ generator = table.read_rows_stream({})
+ first_row = generator.__next__()
+ second_row = generator.__next__()
+ assert first_row.row_key == b"row_key_1"
+ assert second_row.row_key == b"row_key_2"
+ with pytest.raises(CrossSync._Sync_Impl.StopIteration):
+ generator.__next__()
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows(self, table, temp_rows):
+ """Ensure that the read_rows method works"""
+ temp_rows.add_row(b"row_key_1")
+ temp_rows.add_row(b"row_key_2")
+ row_list = table.read_rows({})
+ assert len(row_list) == 2
+ assert row_list[0].row_key == b"row_key_1"
+ assert row_list[1].row_key == b"row_key_2"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_sharded_simple(self, table, temp_rows):
+ """Test read rows sharded with two queries"""
+ from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+
+ temp_rows.add_row(b"a")
+ temp_rows.add_row(b"b")
+ temp_rows.add_row(b"c")
+ temp_rows.add_row(b"d")
+ query1 = ReadRowsQuery(row_keys=[b"a", b"c"])
+ query2 = ReadRowsQuery(row_keys=[b"b", b"d"])
+ row_list = table.read_rows_sharded([query1, query2])
+ assert len(row_list) == 4
+ assert row_list[0].row_key == b"a"
+ assert row_list[1].row_key == b"c"
+ assert row_list[2].row_key == b"b"
+ assert row_list[3].row_key == b"d"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_sharded_from_sample(self, table, temp_rows):
+ """Test end-to-end sharding"""
+ from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+ from google.cloud.bigtable.data.read_rows_query import RowRange
+
+ temp_rows.add_row(b"a")
+ temp_rows.add_row(b"b")
+ temp_rows.add_row(b"c")
+ temp_rows.add_row(b"d")
+ table_shard_keys = table.sample_row_keys()
+ query = ReadRowsQuery(row_ranges=[RowRange(start_key=b"b", end_key=b"z")])
+ shard_queries = query.shard(table_shard_keys)
+ row_list = table.read_rows_sharded(shard_queries)
+ assert len(row_list) == 3
+ assert row_list[0].row_key == b"b"
+ assert row_list[1].row_key == b"c"
+ assert row_list[2].row_key == b"d"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_sharded_filters_limits(self, table, temp_rows):
+ """Test read rows sharded with filters and limits"""
+ from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+ from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
+
+ temp_rows.add_row(b"a")
+ temp_rows.add_row(b"b")
+ temp_rows.add_row(b"c")
+ temp_rows.add_row(b"d")
+ label_filter1 = ApplyLabelFilter("first")
+ label_filter2 = ApplyLabelFilter("second")
+ query1 = ReadRowsQuery(row_keys=[b"a", b"c"], limit=1, row_filter=label_filter1)
+ query2 = ReadRowsQuery(row_keys=[b"b", b"d"], row_filter=label_filter2)
+ row_list = table.read_rows_sharded([query1, query2])
+ assert len(row_list) == 3
+ assert row_list[0].row_key == b"a"
+ assert row_list[1].row_key == b"b"
+ assert row_list[2].row_key == b"d"
+ assert row_list[0][0].labels == ["first"]
+ assert row_list[1][0].labels == ["second"]
+ assert row_list[2][0].labels == ["second"]
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_range_query(self, table, temp_rows):
+ """Ensure that the read_rows method works"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+ from google.cloud.bigtable.data import RowRange
+
+ temp_rows.add_row(b"a")
+ temp_rows.add_row(b"b")
+ temp_rows.add_row(b"c")
+ temp_rows.add_row(b"d")
+ query = ReadRowsQuery(row_ranges=RowRange(start_key=b"b", end_key=b"d"))
+ row_list = table.read_rows(query)
+ assert len(row_list) == 2
+ assert row_list[0].row_key == b"b"
+ assert row_list[1].row_key == b"c"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_single_key_query(self, table, temp_rows):
+ """Ensure that the read_rows method works with specified query"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ temp_rows.add_row(b"a")
+ temp_rows.add_row(b"b")
+ temp_rows.add_row(b"c")
+ temp_rows.add_row(b"d")
+ query = ReadRowsQuery(row_keys=[b"a", b"c"])
+ row_list = table.read_rows(query)
+ assert len(row_list) == 2
+ assert row_list[0].row_key == b"a"
+ assert row_list[1].row_key == b"c"
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ def test_read_rows_with_filter(self, table, temp_rows):
+ """ensure filters are applied"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+ from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
+
+ temp_rows.add_row(b"a")
+ temp_rows.add_row(b"b")
+ temp_rows.add_row(b"c")
+ temp_rows.add_row(b"d")
+ expected_label = "test-label"
+ row_filter = ApplyLabelFilter(expected_label)
+ query = ReadRowsQuery(row_filter=row_filter)
+ row_list = table.read_rows(query)
+ assert len(row_list) == 4
+ for row in row_list:
+ assert row[0].labels == [expected_label]
+
+ @pytest.mark.usefixtures("table")
+ def test_read_rows_stream_close(self, table, temp_rows):
+ """Ensure that the read_rows_stream can be closed"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ temp_rows.add_row(b"row_key_1")
+ temp_rows.add_row(b"row_key_2")
+ query = ReadRowsQuery()
+ generator = table.read_rows_stream(query)
+ first_row = generator.__next__()
+ assert first_row.row_key == b"row_key_1"
+ generator.close()
+ with pytest.raises(CrossSync._Sync_Impl.StopIteration):
+ generator.__next__()
+
+ @pytest.mark.usefixtures("table")
+ def test_read_row(self, table, temp_rows):
+ """Test read_row (single row helper)"""
+ from google.cloud.bigtable.data import Row
+
+ temp_rows.add_row(b"row_key_1", value=b"value")
+ row = table.read_row(b"row_key_1")
+ assert isinstance(row, Row)
+ assert row.row_key == b"row_key_1"
+ assert row.cells[0].value == b"value"
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)),
+ reason="emulator doesn't raise InvalidArgument",
+ )
+ @pytest.mark.usefixtures("table")
+ def test_read_row_missing(self, table):
+ """Test read_row when row does not exist"""
+ from google.api_core import exceptions
+
+ row_key = "row_key_not_exist"
+ result = table.read_row(row_key)
+ assert result is None
+ with pytest.raises(exceptions.InvalidArgument) as e:
+ table.read_row("")
+ assert "Row keys must be non-empty" in str(e)
+
+ @pytest.mark.usefixtures("table")
+ def test_read_row_w_filter(self, table, temp_rows):
+ """Test read_row (single row helper)"""
+ from google.cloud.bigtable.data import Row
+ from google.cloud.bigtable.data.row_filters import ApplyLabelFilter
+
+ temp_rows.add_row(b"row_key_1", value=b"value")
+ expected_label = "test-label"
+ label_filter = ApplyLabelFilter(expected_label)
+ row = table.read_row(b"row_key_1", row_filter=label_filter)
+ assert isinstance(row, Row)
+ assert row.row_key == b"row_key_1"
+ assert row.cells[0].value == b"value"
+ assert row.cells[0].labels == [expected_label]
+
+ @pytest.mark.skipif(
+ bool(os.environ.get(BIGTABLE_EMULATOR)),
+ reason="emulator doesn't raise InvalidArgument",
+ )
+ @pytest.mark.usefixtures("table")
+ def test_row_exists(self, table, temp_rows):
+ from google.api_core import exceptions
+
+ "Test row_exists with rows that exist and don't exist"
+ assert table.row_exists(b"row_key_1") is False
+ temp_rows.add_row(b"row_key_1")
+ assert table.row_exists(b"row_key_1") is True
+ assert table.row_exists("row_key_1") is True
+ assert table.row_exists(b"row_key_2") is False
+ assert table.row_exists("row_key_2") is False
+ assert table.row_exists("3") is False
+ temp_rows.add_row(b"3")
+ assert table.row_exists(b"3") is True
+ with pytest.raises(exceptions.InvalidArgument) as e:
+ table.row_exists("")
+ assert "Row keys must be non-empty" in str(e)
+
+ @pytest.mark.usefixtures("table")
+ @CrossSync._Sync_Impl.Retry(
+ predicate=retry.if_exception_type(ClientError), initial=1, maximum=5
+ )
+ @pytest.mark.parametrize(
+ "cell_value,filter_input,expect_match",
+ [
+ (b"abc", b"abc", True),
+ (b"abc", "abc", True),
+ (b".", ".", True),
+ (".*", ".*", True),
+ (".*", b".*", True),
+ ("a", ".*", False),
+ (b".*", b".*", True),
+ ("\\a", "\\a", True),
+ (b"\xe2\x98\x83", "☃", True),
+ ("☃", "☃", True),
+ ("\\C☃", "\\C☃", True),
+ (1, 1, True),
+ (2, 1, False),
+ (68, 68, True),
+ ("D", 68, False),
+ (68, "D", False),
+ (-1, -1, True),
+ (2852126720, 2852126720, True),
+ (-1431655766, -1431655766, True),
+ (-1431655766, -1, False),
+ ],
+ )
+ def test_literal_value_filter(
+ self, table, temp_rows, cell_value, filter_input, expect_match
+ ):
+ """Literal value filter does complex escaping on re2 strings.
+ Make sure inputs are properly interpreted by the server"""
+ from google.cloud.bigtable.data.row_filters import LiteralValueFilter
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ f = LiteralValueFilter(filter_input)
+ temp_rows.add_row(b"row_key_1", value=cell_value)
+ query = ReadRowsQuery(row_filter=f)
+ row_list = table.read_rows(query)
+ assert len(row_list) == bool(
+ expect_match
+ ), f"row {type(cell_value)}({cell_value}) not found with {type(filter_input)}({filter_input}) filter"
diff --git a/tests/unit/data/_async/test__mutate_rows.py b/tests/unit/data/_async/test__mutate_rows.py
index e03028c45..13f668fd3 100644
--- a/tests/unit/data/_async/test__mutate_rows.py
+++ b/tests/unit/data/_async/test__mutate_rows.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -16,42 +16,42 @@
from google.cloud.bigtable_v2.types import MutateRowsResponse
from google.rpc import status_pb2
-import google.api_core.exceptions as core_exceptions
+from google.api_core.exceptions import DeadlineExceeded
+from google.api_core.exceptions import Forbidden
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
# try/except added for compatibility with python < 3.8
try:
from unittest import mock
- from unittest.mock import AsyncMock # type: ignore
except ImportError: # pragma: NO COVER
import mock # type: ignore
- from mock import AsyncMock # type: ignore
-
-def _make_mutation(count=1, size=1):
- mutation = mock.Mock()
- mutation.size.return_value = size
- mutation.mutations = [mock.Mock()] * count
- return mutation
+__CROSS_SYNC_OUTPUT__ = "tests.unit.data._sync_autogen.test__mutate_rows"
-class TestMutateRowsOperation:
+@CrossSync.convert_class("TestMutateRowsOperation")
+class TestMutateRowsOperationAsync:
def _target_class(self):
- from google.cloud.bigtable.data._async._mutate_rows import (
- _MutateRowsOperationAsync,
- )
-
- return _MutateRowsOperationAsync
+ return CrossSync._MutateRowsOperation
def _make_one(self, *args, **kwargs):
if not args:
kwargs["gapic_client"] = kwargs.pop("gapic_client", mock.Mock())
- kwargs["table"] = kwargs.pop("table", AsyncMock())
+ kwargs["table"] = kwargs.pop("table", CrossSync.Mock())
kwargs["operation_timeout"] = kwargs.pop("operation_timeout", 5)
kwargs["attempt_timeout"] = kwargs.pop("attempt_timeout", 0.1)
kwargs["retryable_exceptions"] = kwargs.pop("retryable_exceptions", ())
kwargs["mutation_entries"] = kwargs.pop("mutation_entries", [])
return self._target_class()(*args, **kwargs)
+ def _make_mutation(self, count=1, size=1):
+ mutation = mock.Mock()
+ mutation.size.return_value = size
+ mutation.mutations = [mock.Mock()] * count
+ return mutation
+
+ @CrossSync.convert
async def _mock_stream(self, mutation_list, error_dict):
for idx, entry in enumerate(mutation_list):
code = error_dict.get(idx, 0)
@@ -64,7 +64,7 @@ async def _mock_stream(self, mutation_list, error_dict):
)
def _make_mock_gapic(self, mutation_list, error_dict=None):
- mock_fn = AsyncMock()
+ mock_fn = CrossSync.Mock()
if error_dict is None:
error_dict = {}
mock_fn.side_effect = lambda *args, **kwargs: self._mock_stream(
@@ -83,7 +83,7 @@ def test_ctor(self):
client = mock.Mock()
table = mock.Mock()
- entries = [_make_mutation(), _make_mutation()]
+ entries = [self._make_mutation(), self._make_mutation()]
operation_timeout = 0.05
attempt_timeout = 0.01
retryable_exceptions = ()
@@ -101,15 +101,10 @@ def test_ctor(self):
assert client.mutate_rows.call_count == 1
# gapic_fn should call with table details
inner_kwargs = client.mutate_rows.call_args[1]
- assert len(inner_kwargs) == 4
+ assert len(inner_kwargs) == 3
assert inner_kwargs["table_name"] == table.table_name
assert inner_kwargs["app_profile_id"] == table.app_profile_id
assert inner_kwargs["retry"] is None
- metadata = inner_kwargs["metadata"]
- assert len(metadata) == 1
- assert metadata[0][0] == "x-goog-request-params"
- assert str(table.table_name) in metadata[0][1]
- assert str(table.app_profile_id) in metadata[0][1]
# entries should be passed down
entries_w_pb = [_EntryWithProto(e, e._to_pb()) for e in entries]
assert instance.mutations == entries_w_pb
@@ -136,17 +131,14 @@ def test_ctor_too_many_entries(self):
client = mock.Mock()
table = mock.Mock()
- entries = [_make_mutation()] * _MUTATE_ROWS_REQUEST_MUTATION_LIMIT
+ entries = [self._make_mutation()] * (_MUTATE_ROWS_REQUEST_MUTATION_LIMIT + 1)
operation_timeout = 0.05
attempt_timeout = 0.01
- # no errors if at limit
- self._make_one(client, table, entries, operation_timeout, attempt_timeout)
- # raise error after crossing
with pytest.raises(ValueError) as e:
self._make_one(
client,
table,
- entries + [_make_mutation()],
+ entries,
operation_timeout,
attempt_timeout,
)
@@ -155,18 +147,18 @@ def test_ctor_too_many_entries(self):
)
assert "Found 100001" in str(e.value)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_rows_operation(self):
"""
Test successful case of mutate_rows_operation
"""
client = mock.Mock()
table = mock.Mock()
- entries = [_make_mutation(), _make_mutation()]
+ entries = [self._make_mutation(), self._make_mutation()]
operation_timeout = 0.05
cls = self._target_class()
with mock.patch(
- f"{cls.__module__}.{cls.__name__}._run_attempt", AsyncMock()
+ f"{cls.__module__}.{cls.__name__}._run_attempt", CrossSync.Mock()
) as attempt_mock:
instance = self._make_one(
client, table, entries, operation_timeout, operation_timeout
@@ -174,17 +166,15 @@ async def test_mutate_rows_operation(self):
await instance.start()
assert attempt_mock.call_count == 1
- @pytest.mark.parametrize(
- "exc_type", [RuntimeError, ZeroDivisionError, core_exceptions.Forbidden]
- )
- @pytest.mark.asyncio
+ @pytest.mark.parametrize("exc_type", [RuntimeError, ZeroDivisionError, Forbidden])
+ @CrossSync.pytest
async def test_mutate_rows_attempt_exception(self, exc_type):
"""
exceptions raised from attempt should be raised in MutationsExceptionGroup
"""
- client = AsyncMock()
+ client = CrossSync.Mock()
table = mock.Mock()
- entries = [_make_mutation(), _make_mutation()]
+ entries = [self._make_mutation(), self._make_mutation()]
operation_timeout = 0.05
expected_exception = exc_type("test")
client.mutate_rows.side_effect = expected_exception
@@ -202,10 +192,8 @@ async def test_mutate_rows_attempt_exception(self, exc_type):
assert len(instance.errors) == 2
assert len(instance.remaining_indices) == 0
- @pytest.mark.parametrize(
- "exc_type", [RuntimeError, ZeroDivisionError, core_exceptions.Forbidden]
- )
- @pytest.mark.asyncio
+ @pytest.mark.parametrize("exc_type", [RuntimeError, ZeroDivisionError, Forbidden])
+ @CrossSync.pytest
async def test_mutate_rows_exception(self, exc_type):
"""
exceptions raised from retryable should be raised in MutationsExceptionGroup
@@ -215,13 +203,13 @@ async def test_mutate_rows_exception(self, exc_type):
client = mock.Mock()
table = mock.Mock()
- entries = [_make_mutation(), _make_mutation()]
+ entries = [self._make_mutation(), self._make_mutation()]
operation_timeout = 0.05
expected_cause = exc_type("abort")
with mock.patch.object(
self._target_class(),
"_run_attempt",
- AsyncMock(),
+ CrossSync.Mock(),
) as attempt_mock:
attempt_mock.side_effect = expected_cause
found_exc = None
@@ -241,27 +229,24 @@ async def test_mutate_rows_exception(self, exc_type):
@pytest.mark.parametrize(
"exc_type",
- [core_exceptions.DeadlineExceeded, RuntimeError],
+ [DeadlineExceeded, RuntimeError],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_rows_exception_retryable_eventually_pass(self, exc_type):
"""
If an exception fails but eventually passes, it should not raise an exception
"""
- from google.cloud.bigtable.data._async._mutate_rows import (
- _MutateRowsOperationAsync,
- )
client = mock.Mock()
table = mock.Mock()
- entries = [_make_mutation()]
+ entries = [self._make_mutation()]
operation_timeout = 1
expected_cause = exc_type("retry")
num_retries = 2
with mock.patch.object(
- _MutateRowsOperationAsync,
+ self._target_class(),
"_run_attempt",
- AsyncMock(),
+ CrossSync.Mock(),
) as attempt_mock:
attempt_mock.side_effect = [expected_cause] * num_retries + [None]
instance = self._make_one(
@@ -275,7 +260,7 @@ async def test_mutate_rows_exception_retryable_eventually_pass(self, exc_type):
await instance.start()
assert attempt_mock.call_count == num_retries + 1
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_rows_incomplete_ignored(self):
"""
MutateRowsIncomplete exceptions should not be added to error list
@@ -286,12 +271,12 @@ async def test_mutate_rows_incomplete_ignored(self):
client = mock.Mock()
table = mock.Mock()
- entries = [_make_mutation()]
+ entries = [self._make_mutation()]
operation_timeout = 0.05
with mock.patch.object(
self._target_class(),
"_run_attempt",
- AsyncMock(),
+ CrossSync.Mock(),
) as attempt_mock:
attempt_mock.side_effect = _MutateRowsIncomplete("ignored")
found_exc = None
@@ -306,10 +291,10 @@ async def test_mutate_rows_incomplete_ignored(self):
assert len(found_exc.exceptions) == 1
assert isinstance(found_exc.exceptions[0].__cause__, DeadlineExceeded)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_run_attempt_single_entry_success(self):
"""Test mutating a single entry"""
- mutation = _make_mutation()
+ mutation = self._make_mutation()
expected_timeout = 1.3
mock_gapic_fn = self._make_mock_gapic({0: mutation})
instance = self._make_one(
@@ -324,7 +309,7 @@ async def test_run_attempt_single_entry_success(self):
assert kwargs["timeout"] == expected_timeout
assert kwargs["entries"] == [mutation._to_pb()]
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_run_attempt_empty_request(self):
"""Calling with no mutations should result in no API calls"""
mock_gapic_fn = self._make_mock_gapic([])
@@ -334,14 +319,14 @@ async def test_run_attempt_empty_request(self):
await instance._run_attempt()
assert mock_gapic_fn.call_count == 0
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_run_attempt_partial_success_retryable(self):
"""Some entries succeed, but one fails. Should report the proper index, and raise incomplete exception"""
from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
- success_mutation = _make_mutation()
- success_mutation_2 = _make_mutation()
- failure_mutation = _make_mutation()
+ success_mutation = self._make_mutation()
+ success_mutation_2 = self._make_mutation()
+ failure_mutation = self._make_mutation()
mutations = [success_mutation, failure_mutation, success_mutation_2]
mock_gapic_fn = self._make_mock_gapic(mutations, error_dict={1: 300})
instance = self._make_one(
@@ -357,12 +342,12 @@ async def test_run_attempt_partial_success_retryable(self):
assert instance.errors[1][0].grpc_status_code == 300
assert 2 not in instance.errors
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_run_attempt_partial_success_non_retryable(self):
"""Some entries succeed, but one fails. Exception marked as non-retryable. Do not raise incomplete error"""
- success_mutation = _make_mutation()
- success_mutation_2 = _make_mutation()
- failure_mutation = _make_mutation()
+ success_mutation = self._make_mutation()
+ success_mutation_2 = self._make_mutation()
+ failure_mutation = self._make_mutation()
mutations = [success_mutation, failure_mutation, success_mutation_2]
mock_gapic_fn = self._make_mock_gapic(mutations, error_dict={1: 300})
instance = self._make_one(
diff --git a/tests/unit/data/_async/test__read_rows.py b/tests/unit/data/_async/test__read_rows.py
index 2bf8688fd..944681a84 100644
--- a/tests/unit/data/_async/test__read_rows.py
+++ b/tests/unit/data/_async/test__read_rows.py
@@ -1,3 +1,4 @@
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -13,23 +14,22 @@
import pytest
-from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
+from google.cloud.bigtable.data._cross_sync import CrossSync
# try/except added for compatibility with python < 3.8
try:
from unittest import mock
- from unittest.mock import AsyncMock # type: ignore
except ImportError: # pragma: NO COVER
import mock # type: ignore
- from mock import AsyncMock # type: ignore # noqa F401
-TEST_FAMILY = "family_name"
-TEST_QUALIFIER = b"qualifier"
-TEST_TIMESTAMP = 123456789
-TEST_LABELS = ["label1", "label2"]
+__CROSS_SYNC_OUTPUT__ = "tests.unit.data._sync_autogen.test__read_rows"
-class TestReadRowsOperation:
+
+@CrossSync.convert_class(
+ sync_name="TestReadRowsOperation",
+)
+class TestReadRowsOperationAsync:
"""
Tests helper functions in the ReadRowsOperation class
in-depth merging logic in merge_row_response_stream and _read_rows_retryable_attempt
@@ -37,10 +37,9 @@ class TestReadRowsOperation:
"""
@staticmethod
+ @CrossSync.convert
def _get_target_class():
- from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
-
- return _ReadRowsOperationAsync
+ return CrossSync._ReadRowsOperation
def _make_one(self, *args, **kwargs):
return self._get_target_class()(*args, **kwargs)
@@ -60,8 +59,9 @@ def test_ctor(self):
expected_operation_timeout = 42
expected_request_timeout = 44
time_gen_mock = mock.Mock()
+ subpath = "_async" if CrossSync.is_async else "_sync_autogen"
with mock.patch(
- "google.cloud.bigtable.data._async._read_rows._attempt_timeout_generator",
+ f"google.cloud.bigtable.data.{subpath}._read_rows._attempt_timeout_generator",
time_gen_mock,
):
instance = self._make_one(
@@ -78,12 +78,6 @@ def test_ctor(self):
assert instance._remaining_count == row_limit
assert instance.operation_timeout == expected_operation_timeout
assert client.read_rows.call_count == 0
- assert instance._metadata == [
- (
- "x-goog-request-params",
- "table_name=test_table&app_profile_id=test_profile",
- )
- ]
assert instance.request.table_name == table.table_name
assert instance.request.app_profile_id == table.app_profile_id
assert instance.request.rows_limit == row_limit
@@ -242,7 +236,7 @@ def test_revise_to_empty_rowset(self):
(4, 2, 2),
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_revise_limit(self, start_limit, emit_num, expected_limit):
"""
revise_limit should revise the request's limit field
@@ -283,7 +277,7 @@ async def mock_stream():
assert instance._remaining_count == expected_limit
@pytest.mark.parametrize("start_limit,emit_num", [(5, 10), (3, 9), (1, 10)])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_revise_limit_over_limit(self, start_limit, emit_num):
"""
Should raise runtime error if we get in state where emit_num > start_num
@@ -322,7 +316,11 @@ async def mock_stream():
pass
assert "emit count exceeds row limit" in str(e.value)
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @CrossSync.convert(
+ sync_name="test_close",
+ replace_symbols={"aclose": "close", "__anext__": "__next__"},
+ )
async def test_aclose(self):
"""
should be able to close a stream safely with aclose.
@@ -334,7 +332,7 @@ async def mock_stream():
yield 1
with mock.patch.object(
- _ReadRowsOperationAsync, "_read_rows_attempt"
+ self._get_target_class(), "_read_rows_attempt"
) as mock_attempt:
instance = self._make_one(mock.Mock(), mock.Mock(), 1, 1)
wrapped_gen = mock_stream()
@@ -343,20 +341,20 @@ async def mock_stream():
# read one row
await gen.__anext__()
await gen.aclose()
- with pytest.raises(StopAsyncIteration):
+ with pytest.raises(CrossSync.StopIteration):
await gen.__anext__()
# try calling a second time
await gen.aclose()
# ensure close was propagated to wrapped generator
- with pytest.raises(StopAsyncIteration):
+ with pytest.raises(CrossSync.StopIteration):
await wrapped_gen.__anext__()
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @CrossSync.convert(replace_symbols={"__anext__": "__next__"})
async def test_retryable_ignore_repeated_rows(self):
"""
Duplicate rows should cause an invalid chunk error
"""
- from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
from google.cloud.bigtable.data.exceptions import InvalidChunk
from google.cloud.bigtable_v2.types import ReadRowsResponse
@@ -381,37 +379,10 @@ async def mock_stream():
instance = mock.Mock()
instance._last_yielded_row_key = None
instance._remaining_count = None
- stream = _ReadRowsOperationAsync.chunk_stream(instance, mock_awaitable_stream())
+ stream = self._get_target_class().chunk_stream(
+ instance, mock_awaitable_stream()
+ )
await stream.__anext__()
with pytest.raises(InvalidChunk) as exc:
await stream.__anext__()
assert "row keys should be strictly increasing" in str(exc.value)
-
-
-class MockStream(_ReadRowsOperationAsync):
- """
- Mock a _ReadRowsOperationAsync stream for testing
- """
-
- def __init__(self, items=None, errors=None, operation_timeout=None):
- self.transient_errors = errors
- self.operation_timeout = operation_timeout
- self.next_idx = 0
- if items is None:
- items = list(range(10))
- self.items = items
-
- def __aiter__(self):
- return self
-
- async def __anext__(self):
- if self.next_idx >= len(self.items):
- raise StopAsyncIteration
- item = self.items[self.next_idx]
- self.next_idx += 1
- if isinstance(item, Exception):
- raise item
- return item
-
- async def aclose(self):
- pass
diff --git a/tests/unit/data/_async/test_client.py b/tests/unit/data/_async/test_client.py
index 6c49ca0da..8d829a363 100644
--- a/tests/unit/data/_async/test_client.py
+++ b/tests/unit/data/_async/test_client.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
import sys
import pytest
+import mock
from google.cloud.bigtable.data import mutations
from google.auth.credentials import AnonymousCredentials
@@ -31,89 +32,89 @@
from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
-# try/except added for compatibility with python < 3.8
-try:
- from unittest import mock
- from unittest.mock import AsyncMock # type: ignore
-except ImportError: # pragma: NO COVER
- import mock # type: ignore
- from mock import AsyncMock # type: ignore
+from google.cloud.bigtable.data._cross_sync import CrossSync
-VENEER_HEADER_REGEX = re.compile(
- r"gapic\/[0-9]+\.[\w.-]+ gax\/[0-9]+\.[\w.-]+ gccl\/[0-9]+\.[\w.-]+-data-async gl-python\/[0-9]+\.[\w.-]+ grpc\/[0-9]+\.[\w.-]+"
-)
+if CrossSync.is_async:
+ from google.api_core import grpc_helpers_async
+ from google.cloud.bigtable.data._async.client import TableAsync
+ CrossSync.add_mapping("grpc_helpers", grpc_helpers_async)
+else:
+ from google.api_core import grpc_helpers
+ from google.cloud.bigtable.data._sync_autogen.client import Table # noqa: F401
-def _make_client(*args, use_emulator=True, **kwargs):
- import os
- from google.cloud.bigtable.data._async.client import BigtableDataClientAsync
+ CrossSync.add_mapping("grpc_helpers", grpc_helpers)
- env_mask = {}
- # by default, use emulator mode to avoid auth issues in CI
- # emulator mode must be disabled by tests that check channel pooling/refresh background tasks
- if use_emulator:
- env_mask["BIGTABLE_EMULATOR_HOST"] = "localhost"
- else:
- # set some default values
- kwargs["credentials"] = kwargs.get("credentials", AnonymousCredentials())
- kwargs["project"] = kwargs.get("project", "project-id")
- with mock.patch.dict(os.environ, env_mask):
- return BigtableDataClientAsync(*args, **kwargs)
+__CROSS_SYNC_OUTPUT__ = "tests.unit.data._sync_autogen.test_client"
+@CrossSync.convert_class(
+ sync_name="TestBigtableDataClient",
+ add_mapping_for_name="TestBigtableDataClient",
+)
class TestBigtableDataClientAsync:
- def _get_target_class(self):
- from google.cloud.bigtable.data._async.client import BigtableDataClientAsync
-
- return BigtableDataClientAsync
-
- def _make_one(self, *args, **kwargs):
- return _make_client(*args, **kwargs)
+ @staticmethod
+ @CrossSync.convert
+ def _get_target_class():
+ return CrossSync.DataClient
+
+ @classmethod
+ def _make_client(cls, *args, use_emulator=True, **kwargs):
+ import os
+
+ env_mask = {}
+ # by default, use emulator mode to avoid auth issues in CI
+ # emulator mode must be disabled by tests that check channel pooling/refresh background tasks
+ if use_emulator:
+ env_mask["BIGTABLE_EMULATOR_HOST"] = "localhost"
+ import warnings
+
+ warnings.filterwarnings("ignore", category=RuntimeWarning)
+ else:
+ # set some default values
+ kwargs["credentials"] = kwargs.get("credentials", AnonymousCredentials())
+ kwargs["project"] = kwargs.get("project", "project-id")
+ with mock.patch.dict(os.environ, env_mask):
+ return cls._get_target_class()(*args, **kwargs)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_ctor(self):
expected_project = "project-id"
- expected_pool_size = 11
expected_credentials = AnonymousCredentials()
- client = self._make_one(
+ client = self._make_client(
project="project-id",
- pool_size=expected_pool_size,
credentials=expected_credentials,
use_emulator=False,
)
- await asyncio.sleep(0)
+ await CrossSync.yield_to_event_loop()
assert client.project == expected_project
- assert len(client.transport._grpc_channel._pool) == expected_pool_size
assert not client._active_instances
- assert len(client._channel_refresh_tasks) == expected_pool_size
+ assert client._channel_refresh_task is not None
assert client.transport._credentials == expected_credentials
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_ctor_super_inits(self):
- from google.cloud.bigtable_v2.services.bigtable.async_client import (
- BigtableAsyncClient,
- )
from google.cloud.client import ClientWithProject
from google.api_core import client_options as client_options_lib
project = "project-id"
- pool_size = 11
credentials = AnonymousCredentials()
client_options = {"api_endpoint": "foo.bar:1234"}
options_parsed = client_options_lib.from_dict(client_options)
- transport_str = f"pooled_grpc_asyncio_{pool_size}"
- with mock.patch.object(BigtableAsyncClient, "__init__") as bigtable_client_init:
+ with mock.patch.object(
+ CrossSync.GapicClient, "__init__"
+ ) as bigtable_client_init:
bigtable_client_init.return_value = None
with mock.patch.object(
ClientWithProject, "__init__"
) as client_project_init:
client_project_init.return_value = None
try:
- self._make_one(
+ self._make_client(
project=project,
- pool_size=pool_size,
credentials=credentials,
client_options=options_parsed,
use_emulator=False,
@@ -123,7 +124,6 @@ async def test_ctor_super_inits(self):
# test gapic superclass init was called
assert bigtable_client_init.call_count == 1
kwargs = bigtable_client_init.call_args[1]
- assert kwargs["transport"] == transport_str
assert kwargs["credentials"] == credentials
assert kwargs["client_options"] == options_parsed
# test mixin superclass init was called
@@ -133,17 +133,16 @@ async def test_ctor_super_inits(self):
assert kwargs["credentials"] == credentials
assert kwargs["client_options"] == options_parsed
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_ctor_dict_options(self):
- from google.cloud.bigtable_v2.services.bigtable.async_client import (
- BigtableAsyncClient,
- )
from google.api_core.client_options import ClientOptions
client_options = {"api_endpoint": "foo.bar:1234"}
- with mock.patch.object(BigtableAsyncClient, "__init__") as bigtable_client_init:
+ with mock.patch.object(
+ CrossSync.GapicClient, "__init__"
+ ) as bigtable_client_init:
try:
- self._make_one(client_options=client_options)
+ self._make_client(client_options=client_options)
except TypeError:
pass
bigtable_client_init.assert_called_once()
@@ -154,17 +153,29 @@ async def test_ctor_dict_options(self):
with mock.patch.object(
self._get_target_class(), "_start_background_channel_refresh"
) as start_background_refresh:
- client = self._make_one(client_options=client_options, use_emulator=False)
+ client = self._make_client(
+ client_options=client_options, use_emulator=False
+ )
start_background_refresh.assert_called_once()
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_veneer_grpc_headers(self):
+ client_component = "data-async" if CrossSync.is_async else "data"
+ VENEER_HEADER_REGEX = re.compile(
+ r"gapic\/[0-9]+\.[\w.-]+ gax\/[0-9]+\.[\w.-]+ gccl\/[0-9]+\.[\w.-]+-"
+ + client_component
+ + r" gl-python\/[0-9]+\.[\w.-]+ grpc\/[0-9]+\.[\w.-]+"
+ )
+
# client_info should be populated with headers to
# detect as a veneer client
- patch = mock.patch("google.api_core.gapic_v1.method_async.wrap_method")
+ if CrossSync.is_async:
+ patch = mock.patch("google.api_core.gapic_v1.method_async.wrap_method")
+ else:
+ patch = mock.patch("google.api_core.gapic_v1.method.wrap_method")
with patch as gapic_mock:
- client = self._make_one(project="project-id")
+ client = self._make_client(project="project-id")
wrapped_call_list = gapic_mock.call_args_list
assert len(wrapped_call_list) > 0
# each wrapped call should have veneer headers
@@ -179,150 +190,76 @@ async def test_veneer_grpc_headers(self):
), f"'{wrapped_user_agent_sorted}' does not match {VENEER_HEADER_REGEX}"
await client.close()
- @pytest.mark.asyncio
- async def test_channel_pool_creation(self):
- pool_size = 14
- with mock.patch(
- "google.api_core.grpc_helpers_async.create_channel"
- ) as create_channel:
- create_channel.return_value = AsyncMock()
- client = self._make_one(project="project-id", pool_size=pool_size)
- assert create_channel.call_count == pool_size
- await client.close()
- # channels should be unique
- client = self._make_one(project="project-id", pool_size=pool_size)
- pool_list = list(client.transport._grpc_channel._pool)
- pool_set = set(client.transport._grpc_channel._pool)
- assert len(pool_list) == len(pool_set)
- await client.close()
-
- @pytest.mark.asyncio
- async def test_channel_pool_rotation(self):
- from google.cloud.bigtable_v2.services.bigtable.transports.pooled_grpc_asyncio import (
- PooledChannel,
- )
-
- pool_size = 7
-
- with mock.patch.object(PooledChannel, "next_channel") as next_channel:
- client = self._make_one(project="project-id", pool_size=pool_size)
- assert len(client.transport._grpc_channel._pool) == pool_size
- next_channel.reset_mock()
- with mock.patch.object(
- type(client.transport._grpc_channel._pool[0]), "unary_unary"
- ) as unary_unary:
- # calling an rpc `pool_size` times should use a different channel each time
- channel_next = None
- for i in range(pool_size):
- channel_last = channel_next
- channel_next = client.transport.grpc_channel._pool[i]
- assert channel_last != channel_next
- next_channel.return_value = channel_next
- client.transport.ping_and_warm()
- assert next_channel.call_count == i + 1
- unary_unary.assert_called_once()
- unary_unary.reset_mock()
- await client.close()
-
- @pytest.mark.asyncio
- async def test_channel_pool_replace(self):
- with mock.patch.object(asyncio, "sleep"):
- pool_size = 7
- client = self._make_one(project="project-id", pool_size=pool_size)
- for replace_idx in range(pool_size):
- start_pool = [
- channel for channel in client.transport._grpc_channel._pool
- ]
- grace_period = 9
- with mock.patch.object(
- type(client.transport._grpc_channel._pool[0]), "close"
- ) as close:
- new_channel = grpc.aio.insecure_channel("localhost:8080")
- await client.transport.replace_channel(
- replace_idx, grace=grace_period, new_channel=new_channel
- )
- close.assert_called_once_with(grace=grace_period)
- close.assert_awaited_once()
- assert client.transport._grpc_channel._pool[replace_idx] == new_channel
- for i in range(pool_size):
- if i != replace_idx:
- assert client.transport._grpc_channel._pool[i] == start_pool[i]
- else:
- assert client.transport._grpc_channel._pool[i] != start_pool[i]
- await client.close()
-
+ @CrossSync.drop
@pytest.mark.filterwarnings("ignore::RuntimeWarning")
def test__start_background_channel_refresh_sync(self):
# should raise RuntimeError if called in a sync context
- client = self._make_one(project="project-id", use_emulator=False)
+ client = self._make_client(project="project-id", use_emulator=False)
with pytest.raises(RuntimeError):
client._start_background_channel_refresh()
- @pytest.mark.asyncio
- async def test__start_background_channel_refresh_tasks_exist(self):
+ @CrossSync.pytest
+ async def test__start_background_channel_refresh_task_exists(self):
# if tasks exist, should do nothing
- client = self._make_one(project="project-id", use_emulator=False)
- assert len(client._channel_refresh_tasks) > 0
+ client = self._make_client(project="project-id", use_emulator=False)
+ assert client._channel_refresh_task is not None
with mock.patch.object(asyncio, "create_task") as create_task:
client._start_background_channel_refresh()
create_task.assert_not_called()
await client.close()
- @pytest.mark.asyncio
- @pytest.mark.parametrize("pool_size", [1, 3, 7])
- async def test__start_background_channel_refresh(self, pool_size):
+ @CrossSync.pytest
+ async def test__start_background_channel_refresh(self):
# should create background tasks for each channel
- client = self._make_one(
- project="project-id", pool_size=pool_size, use_emulator=False
- )
- ping_and_warm = AsyncMock()
- client._ping_and_warm_instances = ping_and_warm
- client._start_background_channel_refresh()
- assert len(client._channel_refresh_tasks) == pool_size
- for task in client._channel_refresh_tasks:
- assert isinstance(task, asyncio.Task)
- await asyncio.sleep(0.1)
- assert ping_and_warm.call_count == pool_size
- for channel in client.transport._grpc_channel._pool:
- ping_and_warm.assert_any_call(channel)
- await client.close()
+ client = self._make_client(project="project-id")
+ with mock.patch.object(
+ client, "_ping_and_warm_instances", CrossSync.Mock()
+ ) as ping_and_warm:
+ client._emulator_host = None
+ client._start_background_channel_refresh()
+ assert client._channel_refresh_task is not None
+ assert isinstance(client._channel_refresh_task, CrossSync.Task)
+ await CrossSync.sleep(0.1)
+ assert ping_and_warm.call_count == 1
+ await client.close()
- @pytest.mark.asyncio
+ @CrossSync.drop
+ @CrossSync.pytest
@pytest.mark.skipif(
sys.version_info < (3, 8), reason="Task.name requires python3.8 or higher"
)
- async def test__start_background_channel_refresh_tasks_names(self):
+ async def test__start_background_channel_refresh_task_names(self):
# if tasks exist, should do nothing
- pool_size = 3
- client = self._make_one(
- project="project-id", pool_size=pool_size, use_emulator=False
- )
- for i in range(pool_size):
- name = client._channel_refresh_tasks[i].get_name()
- assert str(i) in name
- assert "BigtableDataClientAsync channel refresh " in name
+ client = self._make_client(project="project-id", use_emulator=False)
+ name = client._channel_refresh_task.get_name()
+ assert "channel refresh" in name
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__ping_and_warm_instances(self):
"""
test ping and warm with mocked asyncio.gather
"""
client_mock = mock.Mock()
- with mock.patch.object(asyncio, "gather", AsyncMock()) as gather:
- # simulate gather by returning the same number of items as passed in
- gather.side_effect = lambda *args, **kwargs: [None for _ in args]
+ client_mock._execute_ping_and_warms = (
+ lambda *args: self._get_target_class()._execute_ping_and_warms(
+ client_mock, *args
+ )
+ )
+ with mock.patch.object(
+ CrossSync, "gather_partials", CrossSync.Mock()
+ ) as gather:
+ # gather_partials is expected to call the function passed, and return the result
+ gather.side_effect = lambda partials, **kwargs: [None for _ in partials]
channel = mock.Mock()
# test with no instances
client_mock._active_instances = []
result = await self._get_target_class()._ping_and_warm_instances(
- client_mock, channel
+ client_mock, channel=channel
)
assert len(result) == 0
- gather.assert_called_once()
- gather.assert_awaited_once()
- assert not gather.call_args.args
- assert gather.call_args.kwargs == {"return_exceptions": True}
+ assert gather.call_args[1]["return_exceptions"] is True
+ assert gather.call_args[1]["sync_executor"] == client_mock._executor
# test with instances
client_mock._active_instances = [
(mock.Mock(), mock.Mock(), mock.Mock())
@@ -330,12 +267,15 @@ async def test__ping_and_warm_instances(self):
gather.reset_mock()
channel.reset_mock()
result = await self._get_target_class()._ping_and_warm_instances(
- client_mock, channel
+ client_mock, channel=channel
)
assert len(result) == 4
gather.assert_called_once()
- gather.assert_awaited_once()
- assert len(gather.call_args.args) == 4
+ # expect one partial for each instance
+ partial_list = gather.call_args.args[0]
+ assert len(partial_list) == 4
+ if CrossSync.is_async:
+ gather.assert_awaited_once()
# check grpc call arguments
grpc_call_args = channel.unary_unary().call_args_list
for idx, (_, kwargs) in enumerate(grpc_call_args):
@@ -355,26 +295,33 @@ async def test__ping_and_warm_instances(self):
== f"name={expected_instance}&app_profile_id={expected_app_profile}"
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__ping_and_warm_single_instance(self):
"""
should be able to call ping and warm with single instance
"""
client_mock = mock.Mock()
- with mock.patch.object(asyncio, "gather", AsyncMock()) as gather:
- # simulate gather by returning the same number of items as passed in
- gather.side_effect = lambda *args, **kwargs: [None for _ in args]
- channel = mock.Mock()
+ client_mock._execute_ping_and_warms = (
+ lambda *args: self._get_target_class()._execute_ping_and_warms(
+ client_mock, *args
+ )
+ )
+ with mock.patch.object(
+ CrossSync, "gather_partials", CrossSync.Mock()
+ ) as gather:
+ gather.side_effect = lambda *args, **kwargs: [fn() for fn in args[0]]
# test with large set of instances
client_mock._active_instances = [mock.Mock()] * 100
test_key = ("test-instance", "test-table", "test-app-profile")
result = await self._get_target_class()._ping_and_warm_instances(
- client_mock, channel, test_key
+ client_mock, test_key
)
# should only have been called with test instance
assert len(result) == 1
# check grpc call arguments
- grpc_call_args = channel.unary_unary().call_args_list
+ grpc_call_args = (
+ client_mock.transport.grpc_channel.unary_unary().call_args_list
+ )
assert len(grpc_call_args) == 1
kwargs = grpc_call_args[0][1]
request = kwargs["request"]
@@ -387,7 +334,7 @@ async def test__ping_and_warm_single_instance(self):
metadata[0][1] == "name=test-instance&app_profile_id=test-app-profile"
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"refresh_interval, wait_time, expected_sleep",
[
@@ -405,68 +352,58 @@ async def test__manage_channel_first_sleep(
# first sleep time should be `refresh_interval` seconds after client init
import time
- with mock.patch.object(time, "monotonic") as time:
- time.return_value = 0
- with mock.patch.object(asyncio, "sleep") as sleep:
+ with mock.patch.object(time, "monotonic") as monotonic:
+ monotonic.return_value = 0
+ with mock.patch.object(CrossSync, "event_wait") as sleep:
sleep.side_effect = asyncio.CancelledError
try:
- client = self._make_one(project="project-id")
+ client = self._make_client(project="project-id")
client._channel_init_time = -wait_time
- await client._manage_channel(0, refresh_interval, refresh_interval)
+ await client._manage_channel(refresh_interval, refresh_interval)
except asyncio.CancelledError:
pass
sleep.assert_called_once()
- call_time = sleep.call_args[0][0]
+ call_time = sleep.call_args[0][1]
assert (
abs(call_time - expected_sleep) < 0.1
), f"refresh_interval: {refresh_interval}, wait_time: {wait_time}, expected_sleep: {expected_sleep}"
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__manage_channel_ping_and_warm(self):
"""
_manage channel should call ping and warm internally
"""
import time
+ import threading
client_mock = mock.Mock()
+ client_mock._is_closed.is_set.return_value = False
client_mock._channel_init_time = time.monotonic()
- channel_list = [mock.Mock(), mock.Mock()]
- client_mock.transport.channels = channel_list
- new_channel = mock.Mock()
- client_mock.transport.grpc_channel._create_channel.return_value = new_channel
+ orig_channel = client_mock.transport.grpc_channel
# should ping an warm all new channels, and old channels if sleeping
- with mock.patch.object(asyncio, "sleep"):
- # stop process after replace_channel is called
- client_mock.transport.replace_channel.side_effect = asyncio.CancelledError
- ping_and_warm = client_mock._ping_and_warm_instances = AsyncMock()
+ sleep_tuple = (
+ (asyncio, "sleep") if CrossSync.is_async else (threading.Event, "wait")
+ )
+ with mock.patch.object(*sleep_tuple):
+ # stop process after close is called
+ orig_channel.close.side_effect = asyncio.CancelledError
+ ping_and_warm = client_mock._ping_and_warm_instances = CrossSync.Mock()
# should ping and warm old channel then new if sleep > 0
try:
- channel_idx = 1
- await self._get_target_class()._manage_channel(
- client_mock, channel_idx, 10
- )
+ await self._get_target_class()._manage_channel(client_mock, 10)
except asyncio.CancelledError:
pass
# should have called at loop start, and after replacement
assert ping_and_warm.call_count == 2
# should have replaced channel once
- assert client_mock.transport.replace_channel.call_count == 1
+ assert client_mock.transport._grpc_channel != orig_channel
# make sure new and old channels were warmed
- old_channel = channel_list[channel_idx]
- assert old_channel != new_channel
- called_with = [call[0][0] for call in ping_and_warm.call_args_list]
- assert old_channel in called_with
- assert new_channel in called_with
- # should ping and warm instantly new channel only if not sleeping
- ping_and_warm.reset_mock()
- try:
- await self._get_target_class()._manage_channel(client_mock, 0, 0, 0)
- except asyncio.CancelledError:
- pass
- ping_and_warm.assert_called_once_with(new_channel)
+ called_with = [call[1]["channel"] for call in ping_and_warm.call_args_list]
+ assert orig_channel in called_with
+ assert client_mock.transport.grpc_channel in called_with
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"refresh_interval, num_cycles, expected_sleep",
[
@@ -482,107 +419,95 @@ async def test__manage_channel_sleeps(
import time
import random
- channel_idx = 1
+ channel = mock.Mock()
+ channel.close = CrossSync.Mock()
with mock.patch.object(random, "uniform") as uniform:
uniform.side_effect = lambda min_, max_: min_
- with mock.patch.object(time, "time") as time:
- time.return_value = 0
- with mock.patch.object(asyncio, "sleep") as sleep:
+ with mock.patch.object(time, "time") as time_mock:
+ time_mock.return_value = 0
+ with mock.patch.object(CrossSync, "event_wait") as sleep:
sleep.side_effect = [None for i in range(num_cycles - 1)] + [
asyncio.CancelledError
]
- try:
- client = self._make_one(project="project-id")
- if refresh_interval is not None:
- await client._manage_channel(
- channel_idx, refresh_interval, refresh_interval
- )
- else:
- await client._manage_channel(channel_idx)
- except asyncio.CancelledError:
- pass
+ client = self._make_client(project="project-id")
+ client.transport._grpc_channel = channel
+ with mock.patch.object(
+ client.transport, "create_channel", CrossSync.Mock
+ ):
+ try:
+ if refresh_interval is not None:
+ await client._manage_channel(
+ refresh_interval, refresh_interval, grace_period=0
+ )
+ else:
+ await client._manage_channel(grace_period=0)
+ except asyncio.CancelledError:
+ pass
assert sleep.call_count == num_cycles
- total_sleep = sum([call[0][0] for call in sleep.call_args_list])
+ total_sleep = sum([call[0][1] for call in sleep.call_args_list])
assert (
abs(total_sleep - expected_sleep) < 0.1
), f"refresh_interval={refresh_interval}, num_cycles={num_cycles}, expected_sleep={expected_sleep}"
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__manage_channel_random(self):
import random
- with mock.patch.object(asyncio, "sleep") as sleep:
+ with mock.patch.object(CrossSync, "event_wait") as sleep:
with mock.patch.object(random, "uniform") as uniform:
uniform.return_value = 0
try:
uniform.side_effect = asyncio.CancelledError
- client = self._make_one(project="project-id", pool_size=1)
+ client = self._make_client(project="project-id")
except asyncio.CancelledError:
uniform.side_effect = None
uniform.reset_mock()
sleep.reset_mock()
- min_val = 200
- max_val = 205
- uniform.side_effect = lambda min_, max_: min_
- sleep.side_effect = [None, None, asyncio.CancelledError]
- try:
- await client._manage_channel(0, min_val, max_val)
- except asyncio.CancelledError:
- pass
- assert uniform.call_count == 2
- uniform_args = [call[0] for call in uniform.call_args_list]
- for found_min, found_max in uniform_args:
- assert found_min == min_val
- assert found_max == max_val
+ with mock.patch.object(client.transport, "create_channel"):
+ min_val = 200
+ max_val = 205
+ uniform.side_effect = lambda min_, max_: min_
+ sleep.side_effect = [None, asyncio.CancelledError]
+ try:
+ await client._manage_channel(min_val, max_val, grace_period=0)
+ except asyncio.CancelledError:
+ pass
+ assert uniform.call_count == 2
+ uniform_args = [call[0] for call in uniform.call_args_list]
+ for found_min, found_max in uniform_args:
+ assert found_min == min_val
+ assert found_max == max_val
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize("num_cycles", [0, 1, 10, 100])
async def test__manage_channel_refresh(self, num_cycles):
# make sure that channels are properly refreshed
- from google.cloud.bigtable_v2.services.bigtable.transports.pooled_grpc_asyncio import (
- PooledBigtableGrpcAsyncIOTransport,
- )
- from google.api_core import grpc_helpers_async
-
- expected_grace = 9
expected_refresh = 0.5
- channel_idx = 1
- new_channel = grpc.aio.insecure_channel("localhost:8080")
+ grpc_lib = grpc.aio if CrossSync.is_async else grpc
+ new_channel = grpc_lib.insecure_channel("localhost:8080")
- with mock.patch.object(
- PooledBigtableGrpcAsyncIOTransport, "replace_channel"
- ) as replace_channel:
- with mock.patch.object(asyncio, "sleep") as sleep:
- sleep.side_effect = [None for i in range(num_cycles)] + [
- asyncio.CancelledError
- ]
- with mock.patch.object(
- grpc_helpers_async, "create_channel"
- ) as create_channel:
- create_channel.return_value = new_channel
- client = self._make_one(project="project-id", use_emulator=False)
- create_channel.reset_mock()
- try:
- await client._manage_channel(
- channel_idx,
- refresh_interval_min=expected_refresh,
- refresh_interval_max=expected_refresh,
- grace_period=expected_grace,
- )
- except asyncio.CancelledError:
- pass
- assert sleep.call_count == num_cycles + 1
- assert create_channel.call_count == num_cycles
- assert replace_channel.call_count == num_cycles
- for call in replace_channel.call_args_list:
- args, kwargs = call
- assert args[0] == channel_idx
- assert kwargs["grace"] == expected_grace
- assert kwargs["new_channel"] == new_channel
- await client.close()
+ with mock.patch.object(CrossSync, "event_wait") as sleep:
+ sleep.side_effect = [None for i in range(num_cycles)] + [RuntimeError]
+ with mock.patch.object(
+ CrossSync.grpc_helpers, "create_channel"
+ ) as create_channel:
+ create_channel.return_value = new_channel
+ client = self._make_client(project="project-id")
+ create_channel.reset_mock()
+ try:
+ await client._manage_channel(
+ refresh_interval_min=expected_refresh,
+ refresh_interval_max=expected_refresh,
+ grace_period=0,
+ )
+ except RuntimeError:
+ pass
+ assert sleep.call_count == num_cycles + 1
+ assert create_channel.call_count == num_cycles
+ await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__register_instance(self):
"""
test instance registration
@@ -594,13 +519,8 @@ async def test__register_instance(self):
instance_owners = {}
client_mock._active_instances = active_instances
client_mock._instance_owners = instance_owners
- client_mock._channel_refresh_tasks = []
- client_mock._start_background_channel_refresh.side_effect = (
- lambda: client_mock._channel_refresh_tasks.append(mock.Mock)
- )
- mock_channels = [mock.Mock() for i in range(5)]
- client_mock.transport.channels = mock_channels
- client_mock._ping_and_warm_instances = AsyncMock()
+ client_mock._channel_refresh_task = None
+ client_mock._ping_and_warm_instances = CrossSync.Mock()
table_mock = mock.Mock()
await self._get_target_class()._register_instance(
client_mock, "instance-1", table_mock
@@ -617,21 +537,20 @@ async def test__register_instance(self):
assert expected_key == tuple(list(active_instances)[0])
assert len(instance_owners) == 1
assert expected_key == tuple(list(instance_owners)[0])
- # should be a new task set
- assert client_mock._channel_refresh_tasks
+ # simulate creation of refresh task
+ client_mock._channel_refresh_task = mock.Mock()
# next call should not call _start_background_channel_refresh again
table_mock2 = mock.Mock()
await self._get_target_class()._register_instance(
client_mock, "instance-2", table_mock2
)
assert client_mock._start_background_channel_refresh.call_count == 1
+ assert (
+ client_mock._ping_and_warm_instances.call_args[0][0][0]
+ == "prefix/instance-2"
+ )
# but it should call ping and warm with new instance key
- assert client_mock._ping_and_warm_instances.call_count == len(mock_channels)
- for channel in mock_channels:
- assert channel in [
- call[0][0]
- for call in client_mock._ping_and_warm_instances.call_args_list
- ]
+ assert client_mock._ping_and_warm_instances.call_count == 1
# check for updated lists
assert len(active_instances) == 2
assert len(instance_owners) == 2
@@ -653,7 +572,49 @@ async def test__register_instance(self):
]
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ async def test__register_instance_duplicate(self):
+ """
+ test double instance registration. Should be no-op
+ """
+ # set up mock client
+ client_mock = mock.Mock()
+ client_mock._gapic_client.instance_path.side_effect = lambda a, b: f"prefix/{b}"
+ active_instances = set()
+ instance_owners = {}
+ client_mock._active_instances = active_instances
+ client_mock._instance_owners = instance_owners
+ client_mock._channel_refresh_task = object()
+ mock_channels = [mock.Mock()]
+ client_mock.transport.channels = mock_channels
+ client_mock._ping_and_warm_instances = CrossSync.Mock()
+ table_mock = mock.Mock()
+ expected_key = (
+ "prefix/instance-1",
+ table_mock.table_name,
+ table_mock.app_profile_id,
+ )
+ # fake first registration
+ await self._get_target_class()._register_instance(
+ client_mock, "instance-1", table_mock
+ )
+ assert len(active_instances) == 1
+ assert expected_key == tuple(list(active_instances)[0])
+ assert len(instance_owners) == 1
+ assert expected_key == tuple(list(instance_owners)[0])
+ # should have called ping and warm
+ assert client_mock._ping_and_warm_instances.call_count == 1
+ # next call should do nothing
+ await self._get_target_class()._register_instance(
+ client_mock, "instance-1", table_mock
+ )
+ assert len(active_instances) == 1
+ assert expected_key == tuple(list(active_instances)[0])
+ assert len(instance_owners) == 1
+ assert expected_key == tuple(list(instance_owners)[0])
+ assert client_mock._ping_and_warm_instances.call_count == 1
+
+ @CrossSync.pytest
@pytest.mark.parametrize(
"insert_instances,expected_active,expected_owner_keys",
[
@@ -680,13 +641,8 @@ async def test__register_instance_state(
instance_owners = {}
client_mock._active_instances = active_instances
client_mock._instance_owners = instance_owners
- client_mock._channel_refresh_tasks = []
- client_mock._start_background_channel_refresh.side_effect = (
- lambda: client_mock._channel_refresh_tasks.append(mock.Mock)
- )
- mock_channels = [mock.Mock() for i in range(5)]
- client_mock.transport.channels = mock_channels
- client_mock._ping_and_warm_instances = AsyncMock()
+ client_mock._channel_refresh_task = None
+ client_mock._ping_and_warm_instances = CrossSync.Mock()
table_mock = mock.Mock()
# register instances
for instance, table, profile in insert_instances:
@@ -712,9 +668,9 @@ async def test__register_instance_state(
]
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__remove_instance_registration(self):
- client = self._make_one(project="project-id")
+ client = self._make_client(project="project-id")
table = mock.Mock()
await client._register_instance("instance-1", table)
await client._register_instance("instance-2", table)
@@ -743,16 +699,16 @@ async def test__remove_instance_registration(self):
assert len(client._active_instances) == 1
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__multiple_table_registration(self):
"""
registering with multiple tables with the same key should
add multiple owners to instance_owners, but only keep one copy
of shared key in active_instances
"""
- from google.cloud.bigtable.data._async.client import _WarmedInstanceKey
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
- async with self._make_one(project="project-id") as client:
+ async with self._make_client(project="project-id") as client:
async with client.get_table("instance_1", "table_1") as table_1:
instance_1_path = client._gapic_client.instance_path(
client.project, "instance_1"
@@ -765,12 +721,20 @@ async def test__multiple_table_registration(self):
assert id(table_1) in client._instance_owners[instance_1_key]
# duplicate table should register in instance_owners under same key
async with client.get_table("instance_1", "table_1") as table_2:
+ assert table_2._register_instance_future is not None
+ if not CrossSync.is_async:
+ # give the background task time to run
+ table_2._register_instance_future.result()
assert len(client._instance_owners[instance_1_key]) == 2
assert len(client._active_instances) == 1
assert id(table_1) in client._instance_owners[instance_1_key]
assert id(table_2) in client._instance_owners[instance_1_key]
# unique table should register in instance_owners and active_instances
async with client.get_table("instance_1", "table_3") as table_3:
+ assert table_3._register_instance_future is not None
+ if not CrossSync.is_async:
+ # give the background task time to run
+ table_3._register_instance_future.result()
instance_3_path = client._gapic_client.instance_path(
client.project, "instance_1"
)
@@ -792,17 +756,25 @@ async def test__multiple_table_registration(self):
assert instance_1_key not in client._active_instances
assert len(client._instance_owners[instance_1_key]) == 0
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__multiple_instance_registration(self):
"""
registering with multiple instance keys should update the key
in instance_owners and active_instances
"""
- from google.cloud.bigtable.data._async.client import _WarmedInstanceKey
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
- async with self._make_one(project="project-id") as client:
+ async with self._make_client(project="project-id") as client:
async with client.get_table("instance_1", "table_1") as table_1:
+ assert table_1._register_instance_future is not None
+ if not CrossSync.is_async:
+ # give the background task time to run
+ table_1._register_instance_future.result()
async with client.get_table("instance_2", "table_2") as table_2:
+ assert table_2._register_instance_future is not None
+ if not CrossSync.is_async:
+ # give the background task time to run
+ table_2._register_instance_future.result()
instance_1_path = client._gapic_client.instance_path(
client.project, "instance_1"
)
@@ -831,12 +803,11 @@ async def test__multiple_instance_registration(self):
assert len(client._instance_owners[instance_1_key]) == 0
assert len(client._instance_owners[instance_2_key]) == 0
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_get_table(self):
- from google.cloud.bigtable.data._async.client import TableAsync
- from google.cloud.bigtable.data._async.client import _WarmedInstanceKey
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
- client = self._make_one(project="project-id")
+ client = self._make_client(project="project-id")
assert not client._active_instances
expected_table_id = "table-id"
expected_instance_id = "instance-id"
@@ -846,8 +817,8 @@ async def test_get_table(self):
expected_table_id,
expected_app_profile_id,
)
- await asyncio.sleep(0)
- assert isinstance(table, TableAsync)
+ await CrossSync.yield_to_event_loop()
+ assert isinstance(table, CrossSync.TestTable._get_target_class())
assert table.table_id == expected_table_id
assert (
table.table_name
@@ -867,14 +838,14 @@ async def test_get_table(self):
assert client._instance_owners[instance_key] == {id(table)}
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_get_table_arg_passthrough(self):
"""
All arguments passed in get_table should be sent to constructor
"""
- async with self._make_one(project="project-id") as client:
- with mock.patch(
- "google.cloud.bigtable.data._async.client.TableAsync.__init__",
+ async with self._make_client(project="project-id") as client:
+ with mock.patch.object(
+ CrossSync.TestTable._get_target_class(), "__init__"
) as mock_constructor:
mock_constructor.return_value = None
assert not client._active_instances
@@ -900,25 +871,26 @@ async def test_get_table_arg_passthrough(self):
**expected_kwargs,
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_get_table_context_manager(self):
- from google.cloud.bigtable.data._async.client import TableAsync
- from google.cloud.bigtable.data._async.client import _WarmedInstanceKey
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
expected_table_id = "table-id"
expected_instance_id = "instance-id"
expected_app_profile_id = "app-profile-id"
expected_project_id = "project-id"
- with mock.patch.object(TableAsync, "close") as close_mock:
- async with self._make_one(project=expected_project_id) as client:
+ with mock.patch.object(
+ CrossSync.TestTable._get_target_class(), "close"
+ ) as close_mock:
+ async with self._make_client(project=expected_project_id) as client:
async with client.get_table(
expected_instance_id,
expected_table_id,
expected_app_profile_id,
) as table:
- await asyncio.sleep(0)
- assert isinstance(table, TableAsync)
+ await CrossSync.yield_to_event_loop()
+ assert isinstance(table, CrossSync.TestTable._get_target_class())
assert table.table_id == expected_table_id
assert (
table.table_name
@@ -938,85 +910,63 @@ async def test_get_table_context_manager(self):
assert client._instance_owners[instance_key] == {id(table)}
assert close_mock.call_count == 1
- @pytest.mark.asyncio
- async def test_multiple_pool_sizes(self):
- # should be able to create multiple clients with different pool sizes without issue
- pool_sizes = [1, 2, 4, 8, 16, 32, 64, 128, 256]
- for pool_size in pool_sizes:
- client = self._make_one(
- project="project-id", pool_size=pool_size, use_emulator=False
- )
- assert len(client._channel_refresh_tasks) == pool_size
- client_duplicate = self._make_one(
- project="project-id", pool_size=pool_size, use_emulator=False
- )
- assert len(client_duplicate._channel_refresh_tasks) == pool_size
- assert str(pool_size) in str(client.transport)
- await client.close()
- await client_duplicate.close()
-
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_close(self):
- from google.cloud.bigtable_v2.services.bigtable.transports.pooled_grpc_asyncio import (
- PooledBigtableGrpcAsyncIOTransport,
- )
-
- pool_size = 7
- client = self._make_one(
- project="project-id", pool_size=pool_size, use_emulator=False
- )
- assert len(client._channel_refresh_tasks) == pool_size
- tasks_list = list(client._channel_refresh_tasks)
- for task in client._channel_refresh_tasks:
- assert not task.done()
+ client = self._make_client(project="project-id", use_emulator=False)
+ task = client._channel_refresh_task
+ assert task is not None
+ assert not task.done()
with mock.patch.object(
- PooledBigtableGrpcAsyncIOTransport, "close", AsyncMock()
+ client.transport, "close", CrossSync.Mock()
) as close_mock:
await client.close()
close_mock.assert_called_once()
- close_mock.assert_awaited()
- for task in tasks_list:
- assert task.done()
- assert task.cancelled()
- assert client._channel_refresh_tasks == []
+ if CrossSync.is_async:
+ close_mock.assert_awaited()
+ assert task.done()
+ assert client._channel_refresh_task is None
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_close_with_timeout(self):
- pool_size = 7
expected_timeout = 19
- client = self._make_one(project="project-id", pool_size=pool_size)
- tasks = list(client._channel_refresh_tasks)
- with mock.patch.object(asyncio, "wait_for", AsyncMock()) as wait_for_mock:
+ client = self._make_client(project="project-id", use_emulator=False)
+ with mock.patch.object(CrossSync, "wait", CrossSync.Mock()) as wait_for_mock:
await client.close(timeout=expected_timeout)
wait_for_mock.assert_called_once()
- wait_for_mock.assert_awaited()
+ if CrossSync.is_async:
+ wait_for_mock.assert_awaited()
assert wait_for_mock.call_args[1]["timeout"] == expected_timeout
- client._channel_refresh_tasks = tasks
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_context_manager(self):
+ from functools import partial
+
# context manager should close the client cleanly
- close_mock = AsyncMock()
+ close_mock = CrossSync.Mock()
true_close = None
- async with self._make_one(project="project-id") as client:
- true_close = client.close()
+ async with self._make_client(
+ project="project-id", use_emulator=False
+ ) as client:
+ # grab reference to close coro for async test
+ true_close = partial(client.close)
client.close = close_mock
- for task in client._channel_refresh_tasks:
- assert not task.done()
+ assert not client._channel_refresh_task.done()
assert client.project == "project-id"
assert client._active_instances == set()
close_mock.assert_not_called()
close_mock.assert_called_once()
- close_mock.assert_awaited()
+ if CrossSync.is_async:
+ close_mock.assert_awaited()
# actually close the client
- await true_close
+ await true_close()
+ @CrossSync.drop
def test_client_ctor_sync(self):
# initializing client in a sync context should raise RuntimeError
with pytest.warns(RuntimeWarning) as warnings:
- client = _make_client(project="project-id", use_emulator=False)
+ client = self._make_client(project="project-id", use_emulator=False)
expected_warning = [w for w in warnings if "client.py" in w.filename]
assert len(expected_warning) == 1
assert (
@@ -1024,14 +974,23 @@ def test_client_ctor_sync(self):
in str(expected_warning[0].message)
)
assert client.project == "project-id"
- assert client._channel_refresh_tasks == []
+ assert client._channel_refresh_task is None
+@CrossSync.convert_class("TestTable", add_mapping_for_name="TestTable")
class TestTableAsync:
- @pytest.mark.asyncio
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @staticmethod
+ @CrossSync.convert
+ def _get_target_class():
+ return CrossSync.Table
+
+ @CrossSync.pytest
async def test_table_ctor(self):
- from google.cloud.bigtable.data._async.client import TableAsync
- from google.cloud.bigtable.data._async.client import _WarmedInstanceKey
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
expected_table_id = "table-id"
expected_instance_id = "instance-id"
@@ -1042,10 +1001,10 @@ async def test_table_ctor(self):
expected_read_rows_attempt_timeout = 0.5
expected_mutate_rows_operation_timeout = 2.5
expected_mutate_rows_attempt_timeout = 0.75
- client = _make_client()
+ client = self._make_client()
assert not client._active_instances
- table = TableAsync(
+ table = self._get_target_class()(
client,
expected_instance_id,
expected_table_id,
@@ -1057,7 +1016,7 @@ async def test_table_ctor(self):
default_mutate_rows_operation_timeout=expected_mutate_rows_operation_timeout,
default_mutate_rows_attempt_timeout=expected_mutate_rows_attempt_timeout,
)
- await asyncio.sleep(0)
+ await CrossSync.yield_to_event_loop()
assert table.table_id == expected_table_id
assert table.instance_id == expected_instance_id
assert table.app_profile_id == expected_app_profile_id
@@ -1086,30 +1045,28 @@ async def test_table_ctor(self):
== expected_mutate_rows_attempt_timeout
)
# ensure task reaches completion
- await table._register_instance_task
- assert table._register_instance_task.done()
- assert not table._register_instance_task.cancelled()
- assert table._register_instance_task.exception() is None
+ await table._register_instance_future
+ assert table._register_instance_future.done()
+ assert not table._register_instance_future.cancelled()
+ assert table._register_instance_future.exception() is None
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_table_ctor_defaults(self):
"""
should provide default timeout values and app_profile_id
"""
- from google.cloud.bigtable.data._async.client import TableAsync
-
expected_table_id = "table-id"
expected_instance_id = "instance-id"
- client = _make_client()
+ client = self._make_client()
assert not client._active_instances
- table = TableAsync(
+ table = self._get_target_class()(
client,
expected_instance_id,
expected_table_id,
)
- await asyncio.sleep(0)
+ await CrossSync.yield_to_event_loop()
assert table.table_id == expected_table_id
assert table.instance_id == expected_instance_id
assert table.app_profile_id is None
@@ -1122,14 +1079,12 @@ async def test_table_ctor_defaults(self):
assert table.default_mutate_rows_attempt_timeout == 60
await client.close()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_table_ctor_invalid_timeout_values(self):
"""
bad timeout values should raise ValueError
"""
- from google.cloud.bigtable.data._async.client import TableAsync
-
- client = _make_client()
+ client = self._make_client()
timeout_pairs = [
("default_operation_timeout", "default_attempt_timeout"),
@@ -1144,68 +1099,67 @@ async def test_table_ctor_invalid_timeout_values(self):
]
for operation_timeout, attempt_timeout in timeout_pairs:
with pytest.raises(ValueError) as e:
- TableAsync(client, "", "", **{attempt_timeout: -1})
+ self._get_target_class()(client, "", "", **{attempt_timeout: -1})
assert "attempt_timeout must be greater than 0" in str(e.value)
with pytest.raises(ValueError) as e:
- TableAsync(client, "", "", **{operation_timeout: -1})
+ self._get_target_class()(client, "", "", **{operation_timeout: -1})
assert "operation_timeout must be greater than 0" in str(e.value)
await client.close()
+ @CrossSync.drop
def test_table_ctor_sync(self):
# initializing client in a sync context should raise RuntimeError
- from google.cloud.bigtable.data._async.client import TableAsync
-
client = mock.Mock()
with pytest.raises(RuntimeError) as e:
TableAsync(client, "instance-id", "table-id")
assert e.match("TableAsync must be created within an async event loop context.")
- @pytest.mark.asyncio
+ @CrossSync.pytest
# iterate over all retryable rpcs
@pytest.mark.parametrize(
- "fn_name,fn_args,retry_fn_path,extra_retryables",
+ "fn_name,fn_args,is_stream,extra_retryables",
[
(
"read_rows_stream",
(ReadRowsQuery(),),
- "google.api_core.retry.retry_target_stream_async",
+ True,
(),
),
(
"read_rows",
(ReadRowsQuery(),),
- "google.api_core.retry.retry_target_stream_async",
+ True,
(),
),
(
"read_row",
(b"row_key",),
- "google.api_core.retry.retry_target_stream_async",
+ True,
(),
),
(
"read_rows_sharded",
([ReadRowsQuery()],),
- "google.api_core.retry.retry_target_stream_async",
+ True,
(),
),
(
"row_exists",
(b"row_key",),
- "google.api_core.retry.retry_target_stream_async",
+ True,
(),
),
- ("sample_row_keys", (), "google.api_core.retry.retry_target_async", ()),
+ ("sample_row_keys", (), False, ()),
(
"mutate_row",
(b"row_key", [mock.Mock()]),
- "google.api_core.retry.retry_target_async",
+ False,
(),
),
(
"bulk_mutate_rows",
- ([mutations.RowMutationEntry(b"key", [mock.Mock()])],),
- "google.api_core.retry.retry_target_async",
+ ([mutations.RowMutationEntry(b"key", [mutations.DeleteAllFromRow()])],),
+ False,
(_MutateRowsIncomplete,),
),
],
@@ -1240,17 +1194,26 @@ async def test_customizable_retryable_errors(
expected_retryables,
fn_name,
fn_args,
- retry_fn_path,
+ is_stream,
extra_retryables,
):
"""
Test that retryable functions support user-configurable arguments, and that the configured retryables are passed
down to the gapic layer.
"""
- with mock.patch(retry_fn_path) as retry_fn_mock:
- async with _make_client() as client:
+ retry_fn = "retry_target"
+ if is_stream:
+ retry_fn += "_stream"
+ if CrossSync.is_async:
+ retry_fn = f"CrossSync.{retry_fn}"
+ else:
+ retry_fn = f"CrossSync._Sync_Impl.{retry_fn}"
+ with mock.patch(
+ f"google.cloud.bigtable.data._cross_sync.{retry_fn}"
+ ) as retry_fn_mock:
+ async with self._make_client() as client:
table = client.get_table("instance-id", "table-id")
- expected_predicate = lambda a: a in expected_retryables # noqa
+ expected_predicate = expected_retryables.__contains__
retry_fn_mock.side_effect = RuntimeError("stop early")
with mock.patch(
"google.api_core.retry.if_exception_type"
@@ -1292,20 +1255,22 @@ async def test_customizable_retryable_errors(
],
)
@pytest.mark.parametrize("include_app_profile", [True, False])
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @CrossSync.convert
async def test_call_metadata(self, include_app_profile, fn_name, fn_args, gapic_fn):
- """check that all requests attach proper metadata headers"""
- from google.cloud.bigtable.data import TableAsync
-
profile = "profile" if include_app_profile else None
- client = _make_client()
+ client = self._make_client()
# create mock for rpc stub
transport_mock = mock.MagicMock()
- rpc_mock = mock.AsyncMock()
+ rpc_mock = CrossSync.Mock()
transport_mock._wrapped_methods.__getitem__.return_value = rpc_mock
- client._gapic_client._client._transport = transport_mock
- client._gapic_client._client._is_universe_domain_valid = True
- table = TableAsync(client, "instance-id", "table-id", profile)
+ gapic_client = client._gapic_client
+ if CrossSync.is_async:
+ # inner BigtableClient is held as ._client for BigtableAsyncClient
+ gapic_client = gapic_client._client
+ gapic_client._transport = transport_mock
+ gapic_client._is_universe_domain_valid = True
+ table = self._get_target_class()(client, "instance-id", "table-id", profile)
try:
test_fn = table.__getattribute__(fn_name)
maybe_stream = await test_fn(*fn_args)
@@ -1314,7 +1279,7 @@ async def test_call_metadata(self, include_app_profile, fn_name, fn_args, gapic_
# we expect an exception from attempting to call the mock
pass
assert rpc_mock.call_count == 1
- kwargs = rpc_mock.call_args_list[0].kwargs
+ kwargs = rpc_mock.call_args_list[0][1]
metadata = kwargs["metadata"]
# expect single metadata entry
assert len(metadata) == 1
@@ -1328,20 +1293,32 @@ async def test_call_metadata(self, include_app_profile, fn_name, fn_args, gapic_
assert "app_profile_id=" not in routing_str
-class TestReadRows:
+@CrossSync.convert_class(
+ "TestReadRows",
+ add_mapping_for_name="TestReadRows",
+)
+class TestReadRowsAsync:
"""
Tests for table.read_rows and related methods.
"""
- def _make_table(self, *args, **kwargs):
- from google.cloud.bigtable.data._async.client import TableAsync
+ @staticmethod
+ @CrossSync.convert
+ def _get_operation_class():
+ return CrossSync._ReadRowsOperation
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @CrossSync.convert
+ def _make_table(self, *args, **kwargs):
client_mock = mock.Mock()
client_mock._register_instance.side_effect = (
- lambda *args, **kwargs: asyncio.sleep(0)
+ lambda *args, **kwargs: CrossSync.yield_to_event_loop()
)
client_mock._remove_instance_registration.side_effect = (
- lambda *args, **kwargs: asyncio.sleep(0)
+ lambda *args, **kwargs: CrossSync.yield_to_event_loop()
)
kwargs["instance_id"] = kwargs.get(
"instance_id", args[0] if args else "instance"
@@ -1351,7 +1328,7 @@ def _make_table(self, *args, **kwargs):
)
client_mock._gapic_client.table_path.return_value = kwargs["table_id"]
client_mock._gapic_client.instance_path.return_value = kwargs["instance_id"]
- return TableAsync(client_mock, *args, **kwargs)
+ return CrossSync.TestTable._get_target_class()(client_mock, *args, **kwargs)
def _make_stats(self):
from google.cloud.bigtable_v2.types import RequestStats
@@ -1382,6 +1359,7 @@ def _make_chunk(*args, **kwargs):
return ReadRowsResponse.CellChunk(*args, **kwargs)
@staticmethod
+ @CrossSync.convert
async def _make_gapic_stream(
chunk_list: list[ReadRowsResponse.CellChunk | Exception],
sleep_time=0,
@@ -1394,30 +1372,33 @@ def __init__(self, chunk_list, sleep_time):
self.idx = -1
self.sleep_time = sleep_time
+ @CrossSync.convert(sync_name="__iter__")
def __aiter__(self):
return self
+ @CrossSync.convert(sync_name="__next__")
async def __anext__(self):
self.idx += 1
if len(self.chunk_list) > self.idx:
if sleep_time:
- await asyncio.sleep(self.sleep_time)
+ await CrossSync.sleep(self.sleep_time)
chunk = self.chunk_list[self.idx]
if isinstance(chunk, Exception):
raise chunk
else:
return ReadRowsResponse(chunks=[chunk])
- raise StopAsyncIteration
+ raise CrossSync.StopIteration
def cancel(self):
pass
return mock_stream(chunk_list, sleep_time)
+ @CrossSync.convert
async def execute_fn(self, table, *args, **kwargs):
return await table.read_rows(*args, **kwargs)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows(self):
query = ReadRowsQuery()
chunks = [
@@ -1434,7 +1415,7 @@ async def test_read_rows(self):
assert results[0].row_key == b"test_1"
assert results[1].row_key == b"test_2"
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_stream(self):
query = ReadRowsQuery()
chunks = [
@@ -1453,7 +1434,7 @@ async def test_read_rows_stream(self):
assert results[1].row_key == b"test_2"
@pytest.mark.parametrize("include_app_profile", [True, False])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_query_matches_request(self, include_app_profile):
from google.cloud.bigtable.data import RowRange
from google.cloud.bigtable.data.row_filters import PassAllFilter
@@ -1480,14 +1461,14 @@ async def test_read_rows_query_matches_request(self, include_app_profile):
assert call_request == query_pb
@pytest.mark.parametrize("operation_timeout", [0.001, 0.023, 0.1])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_timeout(self, operation_timeout):
async with self._make_table() as table:
read_rows = table.client._gapic_client.read_rows
query = ReadRowsQuery()
chunks = [self._make_chunk(row_key=b"test_1")]
read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
- chunks, sleep_time=1
+ chunks, sleep_time=0.15
)
try:
await table.read_rows(query, operation_timeout=operation_timeout)
@@ -1505,7 +1486,7 @@ async def test_read_rows_timeout(self, operation_timeout):
(0.05, 0.24, 5),
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_attempt_timeout(
self, per_request_t, operation_t, expected_num
):
@@ -1568,7 +1549,7 @@ async def test_read_rows_attempt_timeout(
core_exceptions.ServiceUnavailable,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_retryable_error(self, exc_type):
async with self._make_table() as table:
read_rows = table.client._gapic_client.read_rows
@@ -1599,7 +1580,7 @@ async def test_read_rows_retryable_error(self, exc_type):
InvalidChunk,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_non_retryable_error(self, exc_type):
async with self._make_table() as table:
read_rows = table.client._gapic_client.read_rows
@@ -1613,18 +1594,17 @@ async def test_read_rows_non_retryable_error(self, exc_type):
except exc_type as e:
assert e == expected_error
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_revise_request(self):
"""
Ensure that _revise_request is called between retries
"""
- from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
from google.cloud.bigtable.data.exceptions import InvalidChunk
from google.cloud.bigtable_v2.types import RowSet
return_val = RowSet()
with mock.patch.object(
- _ReadRowsOperationAsync, "_revise_request_rowset"
+ self._get_operation_class(), "_revise_request_rowset"
) as revise_rowset:
revise_rowset.return_value = return_val
async with self._make_table() as table:
@@ -1648,16 +1628,14 @@ async def test_read_rows_revise_request(self):
revised_call = read_rows.call_args_list[1].args[0]
assert revised_call.rows == return_val
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_default_timeouts(self):
"""
Ensure that the default timeouts are set on the read rows operation when not overridden
"""
- from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
-
operation_timeout = 8
attempt_timeout = 4
- with mock.patch.object(_ReadRowsOperationAsync, "__init__") as mock_op:
+ with mock.patch.object(self._get_operation_class(), "__init__") as mock_op:
mock_op.side_effect = RuntimeError("mock error")
async with self._make_table(
default_read_rows_operation_timeout=operation_timeout,
@@ -1671,16 +1649,14 @@ async def test_read_rows_default_timeouts(self):
assert kwargs["operation_timeout"] == operation_timeout
assert kwargs["attempt_timeout"] == attempt_timeout
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_default_timeout_override(self):
"""
When timeouts are passed, they overwrite default values
"""
- from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
-
operation_timeout = 8
attempt_timeout = 4
- with mock.patch.object(_ReadRowsOperationAsync, "__init__") as mock_op:
+ with mock.patch.object(self._get_operation_class(), "__init__") as mock_op:
mock_op.side_effect = RuntimeError("mock error")
async with self._make_table(
default_operation_timeout=99, default_attempt_timeout=97
@@ -1697,10 +1673,10 @@ async def test_read_rows_default_timeout_override(self):
assert kwargs["operation_timeout"] == operation_timeout
assert kwargs["attempt_timeout"] == attempt_timeout
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_row(self):
"""Test reading a single row"""
- async with _make_client() as client:
+ async with self._make_client() as client:
table = client.get_table("instance", "table")
row_key = b"test_1"
with mock.patch.object(table, "read_rows") as read_rows:
@@ -1725,10 +1701,10 @@ async def test_read_row(self):
assert query.row_ranges == []
assert query.limit == 1
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_row_w_filter(self):
"""Test reading a single row with an added filter"""
- async with _make_client() as client:
+ async with self._make_client() as client:
table = client.get_table("instance", "table")
row_key = b"test_1"
with mock.patch.object(table, "read_rows") as read_rows:
@@ -1758,10 +1734,10 @@ async def test_read_row_w_filter(self):
assert query.limit == 1
assert query.filter == expected_filter
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_row_no_response(self):
"""should return None if row does not exist"""
- async with _make_client() as client:
+ async with self._make_client() as client:
table = client.get_table("instance", "table")
row_key = b"test_1"
with mock.patch.object(table, "read_rows") as read_rows:
@@ -1793,10 +1769,10 @@ async def test_read_row_no_response(self):
([object(), object()], True),
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_row_exists(self, return_value, expected_result):
"""Test checking for row existence"""
- async with _make_client() as client:
+ async with self._make_client() as client:
table = client.get_table("instance", "table")
row_key = b"test_1"
with mock.patch.object(table, "read_rows") as read_rows:
@@ -1830,32 +1806,35 @@ async def test_row_exists(self, return_value, expected_result):
assert query.filter._to_dict() == expected_filter
-class TestReadRowsSharded:
- @pytest.mark.asyncio
+@CrossSync.convert_class("TestReadRowsSharded")
+class TestReadRowsShardedAsync:
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @CrossSync.pytest
async def test_read_rows_sharded_empty_query(self):
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with pytest.raises(ValueError) as exc:
await table.read_rows_sharded([])
assert "empty sharded_query" in str(exc.value)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_multiple_queries(self):
"""
Test with multiple queries. Should return results from both
"""
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
table.client._gapic_client, "read_rows"
) as read_rows:
- read_rows.side_effect = (
- lambda *args, **kwargs: TestReadRows._make_gapic_stream(
- [
- TestReadRows._make_chunk(row_key=k)
- for k in args[0].rows.row_keys
- ]
- )
+ read_rows.side_effect = lambda *args, **kwargs: CrossSync.TestReadRows._make_gapic_stream(
+ [
+ CrossSync.TestReadRows._make_chunk(row_key=k)
+ for k in args[0].rows.row_keys
+ ]
)
query_1 = ReadRowsQuery(b"test_1")
query_2 = ReadRowsQuery(b"test_2")
@@ -1865,19 +1844,19 @@ async def test_read_rows_sharded_multiple_queries(self):
assert result[1].row_key == b"test_2"
@pytest.mark.parametrize("n_queries", [1, 2, 5, 11, 24])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_multiple_queries_calls(self, n_queries):
"""
Each query should trigger a separate read_rows call
"""
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(table, "read_rows") as read_rows:
query_list = [ReadRowsQuery() for _ in range(n_queries)]
await table.read_rows_sharded(query_list)
assert read_rows.call_count == n_queries
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_errors(self):
"""
Errors should be exposed as ShardedReadRowsExceptionGroups
@@ -1885,7 +1864,7 @@ async def test_read_rows_sharded_errors(self):
from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
from google.cloud.bigtable.data.exceptions import FailedQueryShardError
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(table, "read_rows") as read_rows:
read_rows.side_effect = RuntimeError("mock error")
@@ -1905,7 +1884,7 @@ async def test_read_rows_sharded_errors(self):
assert exc.value.exceptions[1].index == 1
assert exc.value.exceptions[1].query == query_2
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_concurrent(self):
"""
Ensure sharded requests are concurrent
@@ -1913,10 +1892,10 @@ async def test_read_rows_sharded_concurrent(self):
import time
async def mock_call(*args, **kwargs):
- await asyncio.sleep(0.1)
+ await CrossSync.sleep(0.1)
return [mock.Mock()]
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(table, "read_rows") as read_rows:
read_rows.side_effect = mock_call
@@ -1927,16 +1906,16 @@ async def mock_call(*args, **kwargs):
assert read_rows.call_count == 10
assert len(result) == 10
# if run in sequence, we would expect this to take 1 second
- assert call_time < 0.2
+ assert call_time < 0.5
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_concurrency_limit(self):
"""
Only 10 queries should be processed concurrently. Others should be queued
Should start a new query as soon as previous finishes
"""
- from google.cloud.bigtable.data._async.client import _CONCURRENCY_LIMIT
+ from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
assert _CONCURRENCY_LIMIT == 10 # change this test if this changes
num_queries = 15
@@ -1954,7 +1933,7 @@ async def mock_call(*args, **kwargs):
starting_timeout = 10
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(table, "read_rows") as read_rows:
read_rows.side_effect = mock_call
@@ -1978,13 +1957,13 @@ async def mock_call(*args, **kwargs):
idx = i + _CONCURRENCY_LIMIT
assert rpc_start_list[idx] - (i * increment_time) < eps
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_expirary(self):
"""
If the operation times out before all shards complete, should raise
a ShardedReadRowsExceptionGroup
"""
- from google.cloud.bigtable.data._async.client import _CONCURRENCY_LIMIT
+ from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
from google.api_core.exceptions import DeadlineExceeded
@@ -2004,7 +1983,7 @@ async def mock_call(*args, **kwargs):
await asyncio.sleep(next_item)
return [mock.Mock()]
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(table, "read_rows") as read_rows:
read_rows.side_effect = mock_call
@@ -2018,7 +1997,7 @@ async def mock_call(*args, **kwargs):
# should keep successful queries
assert len(exc.value.successful_rows) == _CONCURRENCY_LIMIT
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_rows_sharded_negative_batch_timeout(self):
"""
try to run with batch that starts after operation timeout
@@ -2026,35 +2005,45 @@ async def test_read_rows_sharded_negative_batch_timeout(self):
They should raise DeadlineExceeded errors
"""
from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
+ from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
from google.api_core.exceptions import DeadlineExceeded
async def mock_call(*args, **kwargs):
- await asyncio.sleep(0.05)
+ await CrossSync.sleep(0.06)
return [mock.Mock()]
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(table, "read_rows") as read_rows:
read_rows.side_effect = mock_call
- queries = [ReadRowsQuery() for _ in range(15)]
+ num_calls = 15
+ queries = [ReadRowsQuery() for _ in range(num_calls)]
with pytest.raises(ShardedReadRowsExceptionGroup) as exc:
- await table.read_rows_sharded(queries, operation_timeout=0.01)
+ await table.read_rows_sharded(queries, operation_timeout=0.05)
assert isinstance(exc.value, ShardedReadRowsExceptionGroup)
- assert len(exc.value.exceptions) == 5
+ # _CONCURRENCY_LIMIT calls will run, and won't be interrupted
+ # calls after the limit will be cancelled due to timeout
+ assert len(exc.value.exceptions) >= num_calls - _CONCURRENCY_LIMIT
assert all(
isinstance(e.__cause__, DeadlineExceeded)
for e in exc.value.exceptions
)
-class TestSampleRowKeys:
+@CrossSync.convert_class("TestSampleRowKeys")
+class TestSampleRowKeysAsync:
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @CrossSync.convert
async def _make_gapic_stream(self, sample_list: list[tuple[bytes, int]]):
from google.cloud.bigtable_v2.types import SampleRowKeysResponse
for value in sample_list:
yield SampleRowKeysResponse(row_key=value[0], offset_bytes=value[1])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_sample_row_keys(self):
"""
Test that method returns the expected key samples
@@ -2064,10 +2053,10 @@ async def test_sample_row_keys(self):
(b"test_2", 100),
(b"test_3", 200),
]
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
- table.client._gapic_client, "sample_row_keys", AsyncMock()
+ table.client._gapic_client, "sample_row_keys", CrossSync.Mock()
) as sample_row_keys:
sample_row_keys.return_value = self._make_gapic_stream(samples)
result = await table.sample_row_keys()
@@ -2079,12 +2068,12 @@ async def test_sample_row_keys(self):
assert result[1] == samples[1]
assert result[2] == samples[2]
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_sample_row_keys_bad_timeout(self):
"""
should raise error if timeout is negative
"""
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with pytest.raises(ValueError) as e:
await table.sample_row_keys(operation_timeout=-1)
@@ -2093,11 +2082,11 @@ async def test_sample_row_keys_bad_timeout(self):
await table.sample_row_keys(attempt_timeout=-1)
assert "attempt_timeout must be greater than 0" in str(e.value)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_sample_row_keys_default_timeout(self):
"""Should fallback to using table default operation_timeout"""
expected_timeout = 99
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table(
"i",
"t",
@@ -2105,7 +2094,7 @@ async def test_sample_row_keys_default_timeout(self):
default_attempt_timeout=expected_timeout,
) as table:
with mock.patch.object(
- table.client._gapic_client, "sample_row_keys", AsyncMock()
+ table.client._gapic_client, "sample_row_keys", CrossSync.Mock()
) as sample_row_keys:
sample_row_keys.return_value = self._make_gapic_stream([])
result = await table.sample_row_keys()
@@ -2114,7 +2103,7 @@ async def test_sample_row_keys_default_timeout(self):
assert result == []
assert kwargs["retry"] is None
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_sample_row_keys_gapic_params(self):
"""
make sure arguments are propagated to gapic call as expected
@@ -2123,22 +2112,21 @@ async def test_sample_row_keys_gapic_params(self):
expected_profile = "test1"
instance = "instance_name"
table_id = "my_table"
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table(
instance, table_id, app_profile_id=expected_profile
) as table:
with mock.patch.object(
- table.client._gapic_client, "sample_row_keys", AsyncMock()
+ table.client._gapic_client, "sample_row_keys", CrossSync.Mock()
) as sample_row_keys:
sample_row_keys.return_value = self._make_gapic_stream([])
await table.sample_row_keys(attempt_timeout=expected_timeout)
args, kwargs = sample_row_keys.call_args
assert len(args) == 0
- assert len(kwargs) == 5
+ assert len(kwargs) == 4
assert kwargs["timeout"] == expected_timeout
assert kwargs["app_profile_id"] == expected_profile
assert kwargs["table_name"] == table.table_name
- assert kwargs["metadata"] is not None
assert kwargs["retry"] is None
@pytest.mark.parametrize(
@@ -2148,7 +2136,7 @@ async def test_sample_row_keys_gapic_params(self):
core_exceptions.ServiceUnavailable,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_sample_row_keys_retryable_errors(self, retryable_exception):
"""
retryable errors should be retried until timeout
@@ -2156,10 +2144,10 @@ async def test_sample_row_keys_retryable_errors(self, retryable_exception):
from google.api_core.exceptions import DeadlineExceeded
from google.cloud.bigtable.data.exceptions import RetryExceptionGroup
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
- table.client._gapic_client, "sample_row_keys", AsyncMock()
+ table.client._gapic_client, "sample_row_keys", CrossSync.Mock()
) as sample_row_keys:
sample_row_keys.side_effect = retryable_exception("mock")
with pytest.raises(DeadlineExceeded) as e:
@@ -2180,23 +2168,28 @@ async def test_sample_row_keys_retryable_errors(self, retryable_exception):
core_exceptions.Aborted,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_sample_row_keys_non_retryable_errors(self, non_retryable_exception):
"""
non-retryable errors should cause a raise
"""
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
- table.client._gapic_client, "sample_row_keys", AsyncMock()
+ table.client._gapic_client, "sample_row_keys", CrossSync.Mock()
) as sample_row_keys:
sample_row_keys.side_effect = non_retryable_exception("mock")
with pytest.raises(non_retryable_exception):
await table.sample_row_keys()
-class TestMutateRow:
- @pytest.mark.asyncio
+@CrossSync.convert_class("TestMutateRow")
+class TestMutateRowAsync:
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @CrossSync.pytest
@pytest.mark.parametrize(
"mutation_arg",
[
@@ -2217,7 +2210,7 @@ class TestMutateRow:
async def test_mutate_row(self, mutation_arg):
"""Test mutations with no errors"""
expected_attempt_timeout = 19
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_row"
@@ -2252,12 +2245,12 @@ async def test_mutate_row(self, mutation_arg):
core_exceptions.ServiceUnavailable,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_row_retryable_errors(self, retryable_exception):
from google.api_core.exceptions import DeadlineExceeded
from google.cloud.bigtable.data.exceptions import RetryExceptionGroup
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_row"
@@ -2280,14 +2273,14 @@ async def test_mutate_row_retryable_errors(self, retryable_exception):
core_exceptions.ServiceUnavailable,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_row_non_idempotent_retryable_errors(
self, retryable_exception
):
"""
Non-idempotent mutations should not be retried
"""
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_row"
@@ -2313,9 +2306,9 @@ async def test_mutate_row_non_idempotent_retryable_errors(
core_exceptions.Aborted,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_row_non_retryable_errors(self, non_retryable_exception):
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_row"
@@ -2333,41 +2326,23 @@ async def test_mutate_row_non_retryable_errors(self, non_retryable_exception):
"row_key", mutation, operation_timeout=0.2
)
- @pytest.mark.parametrize("include_app_profile", [True, False])
- @pytest.mark.asyncio
- async def test_mutate_row_metadata(self, include_app_profile):
- """request should attach metadata headers"""
- profile = "profile" if include_app_profile else None
- async with _make_client() as client:
- async with client.get_table("i", "t", app_profile_id=profile) as table:
- with mock.patch.object(
- client._gapic_client, "mutate_row", AsyncMock()
- ) as read_rows:
- await table.mutate_row("rk", mock.Mock())
- kwargs = read_rows.call_args_list[0].kwargs
- metadata = kwargs["metadata"]
- goog_metadata = None
- for key, value in metadata:
- if key == "x-goog-request-params":
- goog_metadata = value
- assert goog_metadata is not None, "x-goog-request-params not found"
- assert "table_name=" + table.table_name in goog_metadata
- if include_app_profile:
- assert "app_profile_id=profile" in goog_metadata
- else:
- assert "app_profile_id=" not in goog_metadata
-
@pytest.mark.parametrize("mutations", [[], None])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_mutate_row_no_mutations(self, mutations):
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with pytest.raises(ValueError) as e:
await table.mutate_row("key", mutations=mutations)
assert e.value.args[0] == "No mutations provided"
-class TestBulkMutateRows:
+@CrossSync.convert_class("TestBulkMutateRows")
+class TestBulkMutateRowsAsync:
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @CrossSync.convert
async def _mock_response(self, response_list):
from google.cloud.bigtable_v2.types import MutateRowsResponse
from google.rpc import status_pb2
@@ -2387,13 +2362,14 @@ async def _mock_response(self, response_list):
for i in range(len(response_list))
]
+ @CrossSync.convert
async def generator():
yield MutateRowsResponse(entries=entries)
return generator()
- @pytest.mark.asyncio
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @CrossSync.pytest
@pytest.mark.parametrize(
"mutation_arg",
[
@@ -2416,7 +2392,7 @@ async def generator():
async def test_bulk_mutate_rows(self, mutation_arg):
"""Test mutations with no errors"""
expected_attempt_timeout = 19
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2437,10 +2413,10 @@ async def test_bulk_mutate_rows(self, mutation_arg):
assert kwargs["timeout"] == expected_attempt_timeout
assert kwargs["retry"] is None
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_bulk_mutate_rows_multiple_entries(self):
"""Test mutations with no errors"""
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2461,7 +2437,7 @@ async def test_bulk_mutate_rows_multiple_entries(self):
assert kwargs["entries"][0] == entry_1._to_pb()
assert kwargs["entries"][1] == entry_2._to_pb()
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"exception",
[
@@ -2481,7 +2457,7 @@ async def test_bulk_mutate_rows_idempotent_mutation_error_retryable(
MutationsExceptionGroup,
)
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2506,7 +2482,7 @@ async def test_bulk_mutate_rows_idempotent_mutation_error_retryable(
cause.exceptions[-1], core_exceptions.DeadlineExceeded
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"exception",
[
@@ -2527,7 +2503,7 @@ async def test_bulk_mutate_rows_idempotent_mutation_error_non_retryable(
MutationsExceptionGroup,
)
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2554,7 +2530,7 @@ async def test_bulk_mutate_rows_idempotent_mutation_error_non_retryable(
core_exceptions.ServiceUnavailable,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_bulk_mutate_idempotent_retryable_request_errors(
self, retryable_exception
):
@@ -2567,7 +2543,7 @@ async def test_bulk_mutate_idempotent_retryable_request_errors(
MutationsExceptionGroup,
)
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2588,7 +2564,7 @@ async def test_bulk_mutate_idempotent_retryable_request_errors(
assert isinstance(cause, RetryExceptionGroup)
assert isinstance(cause.exceptions[0], retryable_exception)
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"retryable_exception",
[
@@ -2605,7 +2581,7 @@ async def test_bulk_mutate_rows_non_idempotent_retryable_errors(
MutationsExceptionGroup,
)
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2637,7 +2613,7 @@ async def test_bulk_mutate_rows_non_idempotent_retryable_errors(
ValueError,
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_bulk_mutate_rows_non_retryable_errors(self, non_retryable_exception):
"""
If the request fails with a non-retryable error, mutations should not be retried
@@ -2647,7 +2623,7 @@ async def test_bulk_mutate_rows_non_retryable_errors(self, non_retryable_excepti
MutationsExceptionGroup,
)
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2667,7 +2643,7 @@ async def test_bulk_mutate_rows_non_retryable_errors(self, non_retryable_excepti
cause = failed_exception.__cause__
assert isinstance(cause, non_retryable_exception)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_bulk_mutate_error_index(self):
"""
Test partial failure, partial success. Errors should be associated with the correct index
@@ -2683,7 +2659,7 @@ async def test_bulk_mutate_error_index(self):
MutationsExceptionGroup,
)
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "mutate_rows"
@@ -2718,14 +2694,14 @@ async def test_bulk_mutate_error_index(self):
assert isinstance(cause.exceptions[1], DeadlineExceeded)
assert isinstance(cause.exceptions[2], FailedPrecondition)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_bulk_mutate_error_recovery(self):
"""
If an error occurs, then resolves, no exception should be raised
"""
from google.api_core.exceptions import DeadlineExceeded
- async with _make_client(project="project") as client:
+ async with self._make_client(project="project") as client:
table = client.get_table("instance", "table")
with mock.patch.object(client._gapic_client, "mutate_rows") as mock_gapic:
# fail with a retryable error, then a non-retryable one
@@ -2743,14 +2719,19 @@ async def test_bulk_mutate_error_recovery(self):
await table.bulk_mutate_rows(entries, operation_timeout=1000)
-class TestCheckAndMutateRow:
+@CrossSync.convert_class("TestCheckAndMutateRow")
+class TestCheckAndMutateRowAsync:
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
@pytest.mark.parametrize("gapic_result", [True, False])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_check_and_mutate(self, gapic_result):
from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
app_profile = "app_profile_id"
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table(
"instance", "table", app_profile_id=app_profile
) as table:
@@ -2787,10 +2768,10 @@ async def test_check_and_mutate(self, gapic_result):
assert kwargs["timeout"] == operation_timeout
assert kwargs["retry"] is None
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_check_and_mutate_bad_timeout(self):
"""Should raise error if operation_timeout < 0"""
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with pytest.raises(ValueError) as e:
await table.check_and_mutate_row(
@@ -2802,13 +2783,13 @@ async def test_check_and_mutate_bad_timeout(self):
)
assert str(e.value) == "operation_timeout must be greater than 0"
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_check_and_mutate_single_mutations(self):
"""if single mutations are passed, they should be internally wrapped in a list"""
from google.cloud.bigtable.data.mutations import SetCell
from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "check_and_mutate_row"
@@ -2828,7 +2809,7 @@ async def test_check_and_mutate_single_mutations(self):
assert kwargs["true_mutations"] == [true_mutation._to_pb()]
assert kwargs["false_mutations"] == [false_mutation._to_pb()]
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_check_and_mutate_predicate_object(self):
"""predicate filter should be passed to gapic request"""
from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
@@ -2836,7 +2817,7 @@ async def test_check_and_mutate_predicate_object(self):
mock_predicate = mock.Mock()
predicate_pb = {"predicate": "dict"}
mock_predicate._to_pb.return_value = predicate_pb
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "check_and_mutate_row"
@@ -2854,7 +2835,7 @@ async def test_check_and_mutate_predicate_object(self):
assert mock_predicate._to_pb.call_count == 1
assert kwargs["retry"] is None
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_check_and_mutate_mutations_parsing(self):
"""mutations objects should be converted to protos"""
from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
@@ -2864,7 +2845,7 @@ async def test_check_and_mutate_mutations_parsing(self):
for idx, mutation in enumerate(mutations):
mutation._to_pb.return_value = f"fake {idx}"
mutations.append(DeleteAllFromRow())
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "check_and_mutate_row"
@@ -2891,7 +2872,12 @@ async def test_check_and_mutate_mutations_parsing(self):
)
-class TestReadModifyWriteRow:
+@CrossSync.convert_class("TestReadModifyWriteRow")
+class TestReadModifyWriteRowAsync:
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
@pytest.mark.parametrize(
"call_rules,expected_rules",
[
@@ -2913,12 +2899,12 @@ class TestReadModifyWriteRow:
),
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_modify_write_call_rule_args(self, call_rules, expected_rules):
"""
Test that the gapic call is called with given rules
"""
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with mock.patch.object(
client._gapic_client, "read_modify_write_row"
@@ -2930,21 +2916,21 @@ async def test_read_modify_write_call_rule_args(self, call_rules, expected_rules
assert found_kwargs["retry"] is None
@pytest.mark.parametrize("rules", [[], None])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_modify_write_no_rules(self, rules):
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table") as table:
with pytest.raises(ValueError) as e:
await table.read_modify_write_row("key", rules=rules)
assert e.value.args[0] == "rules must contain at least one item"
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_modify_write_call_defaults(self):
instance = "instance1"
table_id = "table1"
project = "project1"
row_key = "row_key1"
- async with _make_client(project=project) as client:
+ async with self._make_client(project=project) as client:
async with client.get_table(instance, table_id) as table:
with mock.patch.object(
client._gapic_client, "read_modify_write_row"
@@ -2960,12 +2946,12 @@ async def test_read_modify_write_call_defaults(self):
assert kwargs["row_key"] == row_key.encode()
assert kwargs["timeout"] > 1
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_modify_write_call_overrides(self):
row_key = b"row_key1"
expected_timeout = 12345
profile_id = "profile1"
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table(
"instance", "table_id", app_profile_id=profile_id
) as table:
@@ -2983,10 +2969,10 @@ async def test_read_modify_write_call_overrides(self):
assert kwargs["row_key"] == row_key
assert kwargs["timeout"] == expected_timeout
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_modify_write_string_key(self):
row_key = "string_row_key1"
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table_id") as table:
with mock.patch.object(
client._gapic_client, "read_modify_write_row"
@@ -2996,7 +2982,7 @@ async def test_read_modify_write_string_key(self):
kwargs = mock_gapic.call_args_list[0][1]
assert kwargs["row_key"] == row_key.encode()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_read_modify_write_row_building(self):
"""
results from gapic call should be used to construct row
@@ -3006,7 +2992,7 @@ async def test_read_modify_write_row_building(self):
from google.cloud.bigtable_v2.types import Row as RowPB
mock_response = ReadModifyWriteRowResponse(row=RowPB())
- async with _make_client() as client:
+ async with self._make_client() as client:
async with client.get_table("instance", "table_id") as table:
with mock.patch.object(
client._gapic_client, "read_modify_write_row"
@@ -3016,3 +3002,363 @@ async def test_read_modify_write_row_building(self):
await table.read_modify_write_row("key", mock.Mock())
assert constructor_mock.call_count == 1
constructor_mock.assert_called_once_with(mock_response.row)
+
+
+@CrossSync.convert_class("TestExecuteQuery")
+class TestExecuteQueryAsync:
+ TABLE_NAME = "TABLE_NAME"
+ INSTANCE_NAME = "INSTANCE_NAME"
+
+ @CrossSync.convert
+ def _make_client(self, *args, **kwargs):
+ return CrossSync.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @CrossSync.convert
+ def _make_gapic_stream(self, sample_list: list["ExecuteQueryResponse" | Exception]):
+ class MockStream:
+ def __init__(self, sample_list):
+ self.sample_list = sample_list
+
+ def __aiter__(self):
+ return self
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ if not self.sample_list:
+ raise CrossSync.StopIteration
+ value = self.sample_list.pop(0)
+ if isinstance(value, Exception):
+ raise value
+ return value
+
+ async def __anext__(self):
+ return self.__next__()
+
+ return MockStream(sample_list)
+
+ def resonse_with_metadata(self):
+ from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
+
+ schema = {"a": "string_type", "b": "int64_type"}
+ return ExecuteQueryResponse(
+ {
+ "metadata": {
+ "proto_schema": {
+ "columns": [
+ {"name": name, "type_": {_type: {}}}
+ for name, _type in schema.items()
+ ]
+ }
+ }
+ }
+ )
+
+ def resonse_with_result(self, *args, resume_token=None):
+ from google.cloud.bigtable_v2.types.data import ProtoRows, Value as PBValue
+ from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
+
+ if resume_token is None:
+ resume_token_dict = {}
+ else:
+ resume_token_dict = {"resume_token": resume_token}
+
+ values = []
+ for column_value in args:
+ if column_value is None:
+ pb_value = PBValue({})
+ else:
+ pb_value = PBValue(
+ {
+ "int_value"
+ if isinstance(column_value, int)
+ else "string_value": column_value
+ }
+ )
+ values.append(pb_value)
+ rows = ProtoRows(values=values)
+
+ return ExecuteQueryResponse(
+ {
+ "results": {
+ "proto_rows_batch": {
+ "batch_data": ProtoRows.serialize(rows),
+ },
+ **resume_token_dict,
+ }
+ }
+ )
+
+ @CrossSync.pytest
+ async def test_execute_query(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r async for r in result]
+ assert results[0]["a"] == "test"
+ assert results[0]["b"] == 8
+ assert results[1]["a"] == "test2"
+ assert results[1]["b"] == 9
+ assert results[2]["a"] == "test3"
+ assert results[2]["b"] is None
+ assert execute_query_mock.call_count == 1
+
+ @CrossSync.pytest
+ async def test_execute_query_with_params(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME} WHERE b=@b",
+ self.INSTANCE_NAME,
+ parameters={"b": 9},
+ )
+ results = [r async for r in result]
+ assert len(results) == 1
+ assert results[0]["a"] == "test2"
+ assert results[0]["b"] == 9
+ assert execute_query_mock.call_count == 1
+
+ @CrossSync.pytest
+ async def test_execute_query_error_before_metadata(self):
+ from google.api_core.exceptions import DeadlineExceeded
+
+ values = [
+ DeadlineExceeded(""),
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r async for r in result]
+ assert len(results) == 3
+ assert execute_query_mock.call_count == 2
+
+ @CrossSync.pytest
+ async def test_execute_query_error_after_metadata(self):
+ from google.api_core.exceptions import DeadlineExceeded
+
+ values = [
+ self.resonse_with_metadata(),
+ DeadlineExceeded(""),
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r async for r in result]
+ assert len(results) == 3
+ assert execute_query_mock.call_count == 2
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == []
+
+ @CrossSync.pytest
+ async def test_execute_query_with_retries(self):
+ from google.api_core.exceptions import DeadlineExceeded
+
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ DeadlineExceeded(""),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ DeadlineExceeded(""),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r async for r in result]
+ assert results[0]["a"] == "test"
+ assert results[0]["b"] == 8
+ assert results[1]["a"] == "test2"
+ assert results[1]["b"] == 9
+ assert results[2]["a"] == "test3"
+ assert results[2]["b"] is None
+ assert len(results) == 3
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == [b"r1", b"r2"]
+
+ @pytest.mark.parametrize(
+ "exception",
+ [
+ (core_exceptions.DeadlineExceeded("")),
+ (core_exceptions.Aborted("")),
+ (core_exceptions.ServiceUnavailable("")),
+ ],
+ )
+ @CrossSync.pytest
+ async def test_execute_query_retryable_error(self, exception):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test", resume_token=b"t1"),
+ exception,
+ self.resonse_with_result(8, resume_token=b"t2"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r async for r in result]
+ assert len(results) == 1
+ assert execute_query_mock.call_count == 2
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == [b"t1"]
+
+ @CrossSync.pytest
+ async def test_execute_query_retry_partial_row(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test", resume_token=b"t1"),
+ core_exceptions.DeadlineExceeded(""),
+ self.resonse_with_result(8, resume_token=b"t2"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r async for r in result]
+ assert results[0]["a"] == "test"
+ assert results[0]["b"] == 8
+ assert execute_query_mock.call_count == 2
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == [b"t1"]
+
+ @pytest.mark.parametrize(
+ "ExceptionType",
+ [
+ (core_exceptions.InvalidArgument),
+ (core_exceptions.FailedPrecondition),
+ (core_exceptions.PermissionDenied),
+ (core_exceptions.MethodNotImplemented),
+ (core_exceptions.Cancelled),
+ (core_exceptions.AlreadyExists),
+ (core_exceptions.OutOfRange),
+ (core_exceptions.DataLoss),
+ (core_exceptions.Unauthenticated),
+ (core_exceptions.NotFound),
+ (core_exceptions.ResourceExhausted),
+ (core_exceptions.Unknown),
+ (core_exceptions.InternalServerError),
+ ],
+ )
+ @CrossSync.pytest
+ async def test_execute_query_non_retryable(self, ExceptionType):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ ExceptionType(""),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+
+ result = await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ r = await CrossSync.next(result)
+ assert r["a"] == "test"
+ assert r["b"] == 8
+
+ with pytest.raises(ExceptionType):
+ r = await CrossSync.next(result)
+
+ assert execute_query_mock.call_count == 1
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == []
+
+ @CrossSync.pytest
+ async def test_execute_query_metadata_received_multiple_times_detected(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_metadata(),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ with pytest.raises(
+ Exception, match="Invalid ExecuteQuery response received"
+ ):
+ [
+ r
+ async for r in await client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ ]
diff --git a/tests/unit/data/_async/test_mutations_batcher.py b/tests/unit/data/_async/test_mutations_batcher.py
index cca7c9824..2df8dde6d 100644
--- a/tests/unit/data/_async/test_mutations_batcher.py
+++ b/tests/unit/data/_async/test_mutations_batcher.py
@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -13,34 +13,35 @@
# limitations under the License.
import pytest
+import mock
import asyncio
+import time
import google.api_core.exceptions as core_exceptions
+import google.api_core.retry
from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
from google.cloud.bigtable.data import TABLE_DEFAULT
-# try/except added for compatibility with python < 3.8
-try:
- from unittest import mock
- from unittest.mock import AsyncMock
-except ImportError: # pragma: NO COVER
- import mock # type: ignore
- from mock import AsyncMock # type: ignore
+from google.cloud.bigtable.data._cross_sync import CrossSync
+__CROSS_SYNC_OUTPUT__ = "tests.unit.data._sync_autogen.test_mutations_batcher"
-def _make_mutation(count=1, size=1):
- mutation = mock.Mock()
- mutation.size.return_value = size
- mutation.mutations = [mock.Mock()] * count
- return mutation
+@CrossSync.convert_class(sync_name="Test_FlowControl")
+class Test_FlowControlAsync:
+ @staticmethod
+ @CrossSync.convert
+ def _target_class():
+ return CrossSync._FlowControl
-class Test_FlowControl:
def _make_one(self, max_mutation_count=10, max_mutation_bytes=100):
- from google.cloud.bigtable.data._async.mutations_batcher import (
- _FlowControlAsync,
- )
+ return self._target_class()(max_mutation_count, max_mutation_bytes)
- return _FlowControlAsync(max_mutation_count, max_mutation_bytes)
+ @staticmethod
+ def _make_mutation(count=1, size=1):
+ mutation = mock.Mock()
+ mutation.size.return_value = size
+ mutation.mutations = [mock.Mock()] * count
+ return mutation
def test_ctor(self):
max_mutation_count = 9
@@ -50,7 +51,7 @@ def test_ctor(self):
assert instance._max_mutation_bytes == max_mutation_bytes
assert instance._in_flight_mutation_count == 0
assert instance._in_flight_mutation_bytes == 0
- assert isinstance(instance._capacity_condition, asyncio.Condition)
+ assert isinstance(instance._capacity_condition, CrossSync.Condition)
def test_ctor_invalid_values(self):
"""Test that values are positive, and fit within expected limits"""
@@ -110,7 +111,7 @@ def test__has_capacity(
instance._in_flight_mutation_bytes = existing_size
assert instance._has_capacity(new_count, new_size) == expected
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"existing_count,existing_size,added_count,added_size,new_count,new_size",
[
@@ -138,12 +139,12 @@ async def test_remove_from_flow_value_update(
instance = self._make_one()
instance._in_flight_mutation_count = existing_count
instance._in_flight_mutation_bytes = existing_size
- mutation = _make_mutation(added_count, added_size)
+ mutation = self._make_mutation(added_count, added_size)
await instance.remove_from_flow(mutation)
assert instance._in_flight_mutation_count == new_count
assert instance._in_flight_mutation_bytes == new_size
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__remove_from_flow_unlock(self):
"""capacity condition should notify after mutation is complete"""
instance = self._make_one(10, 10)
@@ -156,36 +157,50 @@ async def task_routine():
lambda: instance._has_capacity(1, 1)
)
- task = asyncio.create_task(task_routine())
- await asyncio.sleep(0.05)
+ if CrossSync.is_async:
+ # for async class, build task to test flow unlock
+ task = asyncio.create_task(task_routine())
+
+ def task_alive():
+ return not task.done()
+
+ else:
+ # this branch will be tested in sync version of this test
+ import threading
+
+ thread = threading.Thread(target=task_routine)
+ thread.start()
+ task_alive = thread.is_alive
+ await CrossSync.sleep(0.05)
# should be blocked due to capacity
- assert task.done() is False
+ assert task_alive() is True
# try changing size
- mutation = _make_mutation(count=0, size=5)
+ mutation = self._make_mutation(count=0, size=5)
+
await instance.remove_from_flow([mutation])
- await asyncio.sleep(0.05)
+ await CrossSync.sleep(0.05)
assert instance._in_flight_mutation_count == 10
assert instance._in_flight_mutation_bytes == 5
- assert task.done() is False
+ assert task_alive() is True
# try changing count
instance._in_flight_mutation_bytes = 10
- mutation = _make_mutation(count=5, size=0)
+ mutation = self._make_mutation(count=5, size=0)
await instance.remove_from_flow([mutation])
- await asyncio.sleep(0.05)
+ await CrossSync.sleep(0.05)
assert instance._in_flight_mutation_count == 5
assert instance._in_flight_mutation_bytes == 10
- assert task.done() is False
+ assert task_alive() is True
# try changing both
instance._in_flight_mutation_count = 10
- mutation = _make_mutation(count=5, size=5)
+ mutation = self._make_mutation(count=5, size=5)
await instance.remove_from_flow([mutation])
- await asyncio.sleep(0.05)
+ await CrossSync.sleep(0.05)
assert instance._in_flight_mutation_count == 5
assert instance._in_flight_mutation_bytes == 5
# task should be complete
- assert task.done() is True
+ assert task_alive() is False
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"mutations,count_cap,size_cap,expected_results",
[
@@ -210,7 +225,7 @@ async def test_add_to_flow(self, mutations, count_cap, size_cap, expected_result
"""
Test batching with various flow control settings
"""
- mutation_objs = [_make_mutation(count=m[0], size=m[1]) for m in mutations]
+ mutation_objs = [self._make_mutation(count=m[0], size=m[1]) for m in mutations]
instance = self._make_one(count_cap, size_cap)
i = 0
async for batch in instance.add_to_flow(mutation_objs):
@@ -226,7 +241,7 @@ async def test_add_to_flow(self, mutations, count_cap, size_cap, expected_result
i += 1
assert i == len(expected_results)
- @pytest.mark.asyncio
+ @CrossSync.pytest
@pytest.mark.parametrize(
"mutations,max_limit,expected_results",
[
@@ -242,11 +257,12 @@ async def test_add_to_flow_max_mutation_limits(
Test flow control running up against the max API limit
Should submit request early, even if the flow control has room for more
"""
- with mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher._MUTATE_ROWS_REQUEST_MUTATION_LIMIT",
- max_limit,
- ):
- mutation_objs = [_make_mutation(count=m[0], size=m[1]) for m in mutations]
+ subpath = "_async" if CrossSync.is_async else "_sync_autogen"
+ path = f"google.cloud.bigtable.data.{subpath}.mutations_batcher._MUTATE_ROWS_REQUEST_MUTATION_LIMIT"
+ with mock.patch(path, max_limit):
+ mutation_objs = [
+ self._make_mutation(count=m[0], size=m[1]) for m in mutations
+ ]
# flow control has no limits except API restrictions
instance = self._make_one(float("inf"), float("inf"))
i = 0
@@ -263,14 +279,14 @@ async def test_add_to_flow_max_mutation_limits(
i += 1
assert i == len(expected_results)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_add_to_flow_oversize(self):
"""
mutations over the flow control limits should still be accepted
"""
instance = self._make_one(2, 3)
- large_size_mutation = _make_mutation(count=1, size=10)
- large_count_mutation = _make_mutation(count=10, size=1)
+ large_size_mutation = self._make_mutation(count=1, size=10)
+ large_count_mutation = self._make_mutation(count=10, size=1)
results = [out async for out in instance.add_to_flow([large_size_mutation])]
assert len(results) == 1
await instance.remove_from_flow(results[0])
@@ -280,13 +296,11 @@ async def test_add_to_flow_oversize(self):
assert len(count_results) == 1
+@CrossSync.convert_class(sync_name="TestMutationsBatcher")
class TestMutationsBatcherAsync:
+ @CrossSync.convert
def _get_target_class(self):
- from google.cloud.bigtable.data._async.mutations_batcher import (
- MutationsBatcherAsync,
- )
-
- return MutationsBatcherAsync
+ return CrossSync.MutationsBatcher
def _make_one(self, table=None, **kwargs):
from google.api_core.exceptions import DeadlineExceeded
@@ -303,132 +317,140 @@ def _make_one(self, table=None, **kwargs):
return self._get_target_class()(table, **kwargs)
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._start_flush_timer"
- )
- @pytest.mark.asyncio
- async def test_ctor_defaults(self, flush_timer_mock):
- flush_timer_mock.return_value = asyncio.create_task(asyncio.sleep(0))
- table = mock.Mock()
- table.default_mutate_rows_operation_timeout = 10
- table.default_mutate_rows_attempt_timeout = 8
- table.default_mutate_rows_retryable_errors = [Exception]
- async with self._make_one(table) as instance:
- assert instance._table == table
- assert instance.closed is False
- assert instance._flush_jobs == set()
- assert len(instance._staged_entries) == 0
- assert len(instance._oldest_exceptions) == 0
- assert len(instance._newest_exceptions) == 0
- assert instance._exception_list_limit == 10
- assert instance._exceptions_since_last_raise == 0
- assert instance._flow_control._max_mutation_count == 100000
- assert instance._flow_control._max_mutation_bytes == 104857600
- assert instance._flow_control._in_flight_mutation_count == 0
- assert instance._flow_control._in_flight_mutation_bytes == 0
- assert instance._entries_processed_since_last_raise == 0
- assert (
- instance._operation_timeout
- == table.default_mutate_rows_operation_timeout
- )
- assert (
- instance._attempt_timeout == table.default_mutate_rows_attempt_timeout
- )
- assert (
- instance._retryable_errors == table.default_mutate_rows_retryable_errors
- )
- await asyncio.sleep(0)
- assert flush_timer_mock.call_count == 1
- assert flush_timer_mock.call_args[0][0] == 5
- assert isinstance(instance._flush_timer, asyncio.Future)
+ @staticmethod
+ def _make_mutation(count=1, size=1):
+ mutation = mock.Mock()
+ mutation.size.return_value = size
+ mutation.mutations = [mock.Mock()] * count
+ return mutation
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._start_flush_timer",
- )
- @pytest.mark.asyncio
- async def test_ctor_explicit(self, flush_timer_mock):
+ @CrossSync.pytest
+ async def test_ctor_defaults(self):
+ with mock.patch.object(
+ self._get_target_class(), "_timer_routine", return_value=CrossSync.Future()
+ ) as flush_timer_mock:
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 10
+ table.default_mutate_rows_attempt_timeout = 8
+ table.default_mutate_rows_retryable_errors = [Exception]
+ async with self._make_one(table) as instance:
+ assert instance._table == table
+ assert instance.closed is False
+ assert instance._flush_jobs == set()
+ assert len(instance._staged_entries) == 0
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert instance._exception_list_limit == 10
+ assert instance._exceptions_since_last_raise == 0
+ assert instance._flow_control._max_mutation_count == 100000
+ assert instance._flow_control._max_mutation_bytes == 104857600
+ assert instance._flow_control._in_flight_mutation_count == 0
+ assert instance._flow_control._in_flight_mutation_bytes == 0
+ assert instance._entries_processed_since_last_raise == 0
+ assert (
+ instance._operation_timeout
+ == table.default_mutate_rows_operation_timeout
+ )
+ assert (
+ instance._attempt_timeout
+ == table.default_mutate_rows_attempt_timeout
+ )
+ assert (
+ instance._retryable_errors
+ == table.default_mutate_rows_retryable_errors
+ )
+ await CrossSync.yield_to_event_loop()
+ assert flush_timer_mock.call_count == 1
+ assert flush_timer_mock.call_args[0][0] == 5
+ assert isinstance(instance._flush_timer, CrossSync.Future)
+
+ @CrossSync.pytest
+ async def test_ctor_explicit(self):
"""Test with explicit parameters"""
- flush_timer_mock.return_value = asyncio.create_task(asyncio.sleep(0))
- table = mock.Mock()
- flush_interval = 20
- flush_limit_count = 17
- flush_limit_bytes = 19
- flow_control_max_mutation_count = 1001
- flow_control_max_bytes = 12
- operation_timeout = 11
- attempt_timeout = 2
- retryable_errors = [Exception]
- async with self._make_one(
- table,
- flush_interval=flush_interval,
- flush_limit_mutation_count=flush_limit_count,
- flush_limit_bytes=flush_limit_bytes,
- flow_control_max_mutation_count=flow_control_max_mutation_count,
- flow_control_max_bytes=flow_control_max_bytes,
- batch_operation_timeout=operation_timeout,
- batch_attempt_timeout=attempt_timeout,
- batch_retryable_errors=retryable_errors,
- ) as instance:
- assert instance._table == table
- assert instance.closed is False
- assert instance._flush_jobs == set()
- assert len(instance._staged_entries) == 0
- assert len(instance._oldest_exceptions) == 0
- assert len(instance._newest_exceptions) == 0
- assert instance._exception_list_limit == 10
- assert instance._exceptions_since_last_raise == 0
- assert (
- instance._flow_control._max_mutation_count
- == flow_control_max_mutation_count
- )
- assert instance._flow_control._max_mutation_bytes == flow_control_max_bytes
- assert instance._flow_control._in_flight_mutation_count == 0
- assert instance._flow_control._in_flight_mutation_bytes == 0
- assert instance._entries_processed_since_last_raise == 0
- assert instance._operation_timeout == operation_timeout
- assert instance._attempt_timeout == attempt_timeout
- assert instance._retryable_errors == retryable_errors
- await asyncio.sleep(0)
- assert flush_timer_mock.call_count == 1
- assert flush_timer_mock.call_args[0][0] == flush_interval
- assert isinstance(instance._flush_timer, asyncio.Future)
-
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._start_flush_timer"
- )
- @pytest.mark.asyncio
- async def test_ctor_no_flush_limits(self, flush_timer_mock):
+ with mock.patch.object(
+ self._get_target_class(), "_timer_routine", return_value=CrossSync.Future()
+ ) as flush_timer_mock:
+ table = mock.Mock()
+ flush_interval = 20
+ flush_limit_count = 17
+ flush_limit_bytes = 19
+ flow_control_max_mutation_count = 1001
+ flow_control_max_bytes = 12
+ operation_timeout = 11
+ attempt_timeout = 2
+ retryable_errors = [Exception]
+ async with self._make_one(
+ table,
+ flush_interval=flush_interval,
+ flush_limit_mutation_count=flush_limit_count,
+ flush_limit_bytes=flush_limit_bytes,
+ flow_control_max_mutation_count=flow_control_max_mutation_count,
+ flow_control_max_bytes=flow_control_max_bytes,
+ batch_operation_timeout=operation_timeout,
+ batch_attempt_timeout=attempt_timeout,
+ batch_retryable_errors=retryable_errors,
+ ) as instance:
+ assert instance._table == table
+ assert instance.closed is False
+ assert instance._flush_jobs == set()
+ assert len(instance._staged_entries) == 0
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert instance._exception_list_limit == 10
+ assert instance._exceptions_since_last_raise == 0
+ assert (
+ instance._flow_control._max_mutation_count
+ == flow_control_max_mutation_count
+ )
+ assert (
+ instance._flow_control._max_mutation_bytes == flow_control_max_bytes
+ )
+ assert instance._flow_control._in_flight_mutation_count == 0
+ assert instance._flow_control._in_flight_mutation_bytes == 0
+ assert instance._entries_processed_since_last_raise == 0
+ assert instance._operation_timeout == operation_timeout
+ assert instance._attempt_timeout == attempt_timeout
+ assert instance._retryable_errors == retryable_errors
+ await CrossSync.yield_to_event_loop()
+ assert flush_timer_mock.call_count == 1
+ assert flush_timer_mock.call_args[0][0] == flush_interval
+ assert isinstance(instance._flush_timer, CrossSync.Future)
+
+ @CrossSync.pytest
+ async def test_ctor_no_flush_limits(self):
"""Test with None for flush limits"""
- flush_timer_mock.return_value = asyncio.create_task(asyncio.sleep(0))
- table = mock.Mock()
- table.default_mutate_rows_operation_timeout = 10
- table.default_mutate_rows_attempt_timeout = 8
- table.default_mutate_rows_retryable_errors = ()
- flush_interval = None
- flush_limit_count = None
- flush_limit_bytes = None
- async with self._make_one(
- table,
- flush_interval=flush_interval,
- flush_limit_mutation_count=flush_limit_count,
- flush_limit_bytes=flush_limit_bytes,
- ) as instance:
- assert instance._table == table
- assert instance.closed is False
- assert instance._staged_entries == []
- assert len(instance._oldest_exceptions) == 0
- assert len(instance._newest_exceptions) == 0
- assert instance._exception_list_limit == 10
- assert instance._exceptions_since_last_raise == 0
- assert instance._flow_control._in_flight_mutation_count == 0
- assert instance._flow_control._in_flight_mutation_bytes == 0
- assert instance._entries_processed_since_last_raise == 0
- await asyncio.sleep(0)
- assert flush_timer_mock.call_count == 1
- assert flush_timer_mock.call_args[0][0] is None
- assert isinstance(instance._flush_timer, asyncio.Future)
+ with mock.patch.object(
+ self._get_target_class(), "_timer_routine", return_value=CrossSync.Future()
+ ) as flush_timer_mock:
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 10
+ table.default_mutate_rows_attempt_timeout = 8
+ table.default_mutate_rows_retryable_errors = ()
+ flush_interval = None
+ flush_limit_count = None
+ flush_limit_bytes = None
+ async with self._make_one(
+ table,
+ flush_interval=flush_interval,
+ flush_limit_mutation_count=flush_limit_count,
+ flush_limit_bytes=flush_limit_bytes,
+ ) as instance:
+ assert instance._table == table
+ assert instance.closed is False
+ assert instance._staged_entries == []
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert instance._exception_list_limit == 10
+ assert instance._exceptions_since_last_raise == 0
+ assert instance._flow_control._in_flight_mutation_count == 0
+ assert instance._flow_control._in_flight_mutation_bytes == 0
+ assert instance._entries_processed_since_last_raise == 0
+ await CrossSync.yield_to_event_loop()
+ assert flush_timer_mock.call_count == 1
+ assert flush_timer_mock.call_args[0][0] is None
+ assert isinstance(instance._flush_timer, CrossSync.Future)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_ctor_invalid_values(self):
"""Test that timeout values are positive, and fit within expected limits"""
with pytest.raises(ValueError) as e:
@@ -438,24 +460,21 @@ async def test_ctor_invalid_values(self):
self._make_one(batch_attempt_timeout=-1)
assert "attempt_timeout must be greater than 0" in str(e.value)
+ @CrossSync.convert
def test_default_argument_consistency(self):
"""
We supply default arguments in MutationsBatcherAsync.__init__, and in
table.mutations_batcher. Make sure any changes to defaults are applied to
both places
"""
- from google.cloud.bigtable.data._async.client import TableAsync
- from google.cloud.bigtable.data._async.mutations_batcher import (
- MutationsBatcherAsync,
- )
import inspect
get_batcher_signature = dict(
- inspect.signature(TableAsync.mutations_batcher).parameters
+ inspect.signature(CrossSync.Table.mutations_batcher).parameters
)
get_batcher_signature.pop("self")
batcher_init_signature = dict(
- inspect.signature(MutationsBatcherAsync).parameters
+ inspect.signature(self._get_target_class()).parameters
)
batcher_init_signature.pop("table")
# both should have same number of arguments
@@ -470,97 +489,96 @@ def test_default_argument_consistency(self):
== batcher_init_signature[arg_name].default
)
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._schedule_flush"
- )
- @pytest.mark.asyncio
- async def test__start_flush_timer_w_None(self, flush_mock):
- """Empty timer should return immediately"""
- async with self._make_one() as instance:
- with mock.patch("asyncio.sleep") as sleep_mock:
- await instance._start_flush_timer(None)
- assert sleep_mock.call_count == 0
- assert flush_mock.call_count == 0
+ @CrossSync.pytest
+ @pytest.mark.parametrize("input_val", [None, 0, -1])
+ async def test__start_flush_timer_w_empty_input(self, input_val):
+ """Empty/invalid timer should return immediately"""
+ with mock.patch.object(
+ self._get_target_class(), "_schedule_flush"
+ ) as flush_mock:
+ # mock different method depending on sync vs async
+ async with self._make_one() as instance:
+ if CrossSync.is_async:
+ sleep_obj, sleep_method = asyncio, "wait_for"
+ else:
+ sleep_obj, sleep_method = instance._closed, "wait"
+ with mock.patch.object(sleep_obj, sleep_method) as sleep_mock:
+ result = await instance._timer_routine(input_val)
+ assert sleep_mock.call_count == 0
+ assert flush_mock.call_count == 0
+ assert result is None
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._schedule_flush"
- )
- @pytest.mark.asyncio
- async def test__start_flush_timer_call_when_closed(self, flush_mock):
+ @CrossSync.pytest
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+ async def test__start_flush_timer_call_when_closed(
+ self,
+ ):
"""closed batcher's timer should return immediately"""
- async with self._make_one() as instance:
- await instance.close()
- flush_mock.reset_mock()
- with mock.patch("asyncio.sleep") as sleep_mock:
- await instance._start_flush_timer(1)
- assert sleep_mock.call_count == 0
- assert flush_mock.call_count == 0
+ with mock.patch.object(
+ self._get_target_class(), "_schedule_flush"
+ ) as flush_mock:
+ async with self._make_one() as instance:
+ await instance.close()
+ flush_mock.reset_mock()
+ # mock different method depending on sync vs async
+ if CrossSync.is_async:
+ sleep_obj, sleep_method = asyncio, "wait_for"
+ else:
+ sleep_obj, sleep_method = instance._closed, "wait"
+ with mock.patch.object(sleep_obj, sleep_method) as sleep_mock:
+ await instance._timer_routine(10)
+ assert sleep_mock.call_count == 0
+ assert flush_mock.call_count == 0
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._schedule_flush"
- )
- @pytest.mark.asyncio
- async def test__flush_timer(self, flush_mock):
+ @CrossSync.pytest
+ @pytest.mark.parametrize("num_staged", [0, 1, 10])
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+ async def test__flush_timer(self, num_staged):
"""Timer should continue to call _schedule_flush in a loop"""
- expected_sleep = 12
- async with self._make_one(flush_interval=expected_sleep) as instance:
- instance._staged_entries = [mock.Mock()]
- loop_num = 3
- with mock.patch("asyncio.sleep") as sleep_mock:
- sleep_mock.side_effect = [None] * loop_num + [asyncio.CancelledError()]
- try:
- await instance._flush_timer
- except asyncio.CancelledError:
- pass
- assert sleep_mock.call_count == loop_num + 1
- sleep_mock.assert_called_with(expected_sleep)
- assert flush_mock.call_count == loop_num
-
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._schedule_flush"
- )
- @pytest.mark.asyncio
- async def test__flush_timer_no_mutations(self, flush_mock):
- """Timer should not flush if no new mutations have been staged"""
- expected_sleep = 12
- async with self._make_one(flush_interval=expected_sleep) as instance:
- loop_num = 3
- with mock.patch("asyncio.sleep") as sleep_mock:
- sleep_mock.side_effect = [None] * loop_num + [asyncio.CancelledError()]
- try:
- await instance._flush_timer
- except asyncio.CancelledError:
- pass
- assert sleep_mock.call_count == loop_num + 1
- sleep_mock.assert_called_with(expected_sleep)
- assert flush_mock.call_count == 0
+ from google.cloud.bigtable.data._cross_sync import CrossSync
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher.MutationsBatcherAsync._schedule_flush"
- )
- @pytest.mark.asyncio
- async def test__flush_timer_close(self, flush_mock):
+ with mock.patch.object(
+ self._get_target_class(), "_schedule_flush"
+ ) as flush_mock:
+ expected_sleep = 12
+ async with self._make_one(flush_interval=expected_sleep) as instance:
+ loop_num = 3
+ instance._staged_entries = [mock.Mock()] * num_staged
+ with mock.patch.object(CrossSync, "event_wait") as sleep_mock:
+ sleep_mock.side_effect = [None] * loop_num + [TabError("expected")]
+ with pytest.raises(TabError):
+ await self._get_target_class()._timer_routine(
+ instance, expected_sleep
+ )
+ if CrossSync.is_async:
+ # replace with np-op so there are no issues on close
+ instance._flush_timer = CrossSync.Future()
+ assert sleep_mock.call_count == loop_num + 1
+ sleep_kwargs = sleep_mock.call_args[1]
+ assert sleep_kwargs["timeout"] == expected_sleep
+ assert flush_mock.call_count == (0 if num_staged == 0 else loop_num)
+
+ @CrossSync.pytest
+ async def test__flush_timer_close(self):
"""Timer should continue terminate after close"""
- async with self._make_one() as instance:
- with mock.patch("asyncio.sleep"):
+ with mock.patch.object(self._get_target_class(), "_schedule_flush"):
+ async with self._make_one() as instance:
# let task run in background
- await asyncio.sleep(0.5)
assert instance._flush_timer.done() is False
# close the batcher
await instance.close()
- await asyncio.sleep(0.1)
# task should be complete
assert instance._flush_timer.done() is True
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_append_closed(self):
"""Should raise exception"""
+ instance = self._make_one()
+ await instance.close()
with pytest.raises(RuntimeError):
- instance = self._make_one()
- await instance.close()
await instance.append(mock.Mock())
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_append_wrong_mutation(self):
"""
Mutation objects should raise an exception.
@@ -574,13 +592,13 @@ async def test_append_wrong_mutation(self):
await instance.append(DeleteAllFromRow())
assert str(e.value) == expected_error
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_append_outside_flow_limits(self):
"""entries larger than mutation limits are still processed"""
async with self._make_one(
flow_control_max_mutation_count=1, flow_control_max_bytes=1
) as instance:
- oversized_entry = _make_mutation(count=0, size=2)
+ oversized_entry = self._make_mutation(count=0, size=2)
await instance.append(oversized_entry)
assert instance._staged_entries == [oversized_entry]
assert instance._staged_count == 0
@@ -589,25 +607,21 @@ async def test_append_outside_flow_limits(self):
async with self._make_one(
flow_control_max_mutation_count=1, flow_control_max_bytes=1
) as instance:
- overcount_entry = _make_mutation(count=2, size=0)
+ overcount_entry = self._make_mutation(count=2, size=0)
await instance.append(overcount_entry)
assert instance._staged_entries == [overcount_entry]
assert instance._staged_count == 2
assert instance._staged_bytes == 0
instance._staged_entries = []
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_append_flush_runs_after_limit_hit(self):
"""
If the user appends a bunch of entries above the flush limits back-to-back,
it should still flush in a single task
"""
- from google.cloud.bigtable.data._async.mutations_batcher import (
- MutationsBatcherAsync,
- )
-
with mock.patch.object(
- MutationsBatcherAsync, "_execute_mutate_rows"
+ self._get_target_class(), "_execute_mutate_rows"
) as op_mock:
async with self._make_one(flush_limit_bytes=100) as instance:
# mock network calls
@@ -616,13 +630,13 @@ async def mock_call(*args, **kwargs):
op_mock.side_effect = mock_call
# append a mutation just under the size limit
- await instance.append(_make_mutation(size=99))
+ await instance.append(self._make_mutation(size=99))
# append a bunch of entries back-to-back in a loop
num_entries = 10
for _ in range(num_entries):
- await instance.append(_make_mutation(size=1))
+ await instance.append(self._make_mutation(size=1))
# let any flush jobs finish
- await asyncio.gather(*instance._flush_jobs)
+ await instance._wait_for_batch_results(*instance._flush_jobs)
# should have only flushed once, with large mutation and first mutation in loop
assert op_mock.call_count == 1
sent_batch = op_mock.call_args[0][0]
@@ -642,7 +656,8 @@ async def mock_call(*args, **kwargs):
(1, 1, 0, 0, False),
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
async def test_append(
self, flush_count, flush_bytes, mutation_count, mutation_bytes, expect_flush
):
@@ -653,7 +668,7 @@ async def test_append(
assert instance._staged_count == 0
assert instance._staged_bytes == 0
assert instance._staged_entries == []
- mutation = _make_mutation(count=mutation_count, size=mutation_bytes)
+ mutation = self._make_mutation(count=mutation_count, size=mutation_bytes)
with mock.patch.object(instance, "_schedule_flush") as flush_mock:
await instance.append(mutation)
assert flush_mock.call_count == bool(expect_flush)
@@ -662,7 +677,7 @@ async def test_append(
assert instance._staged_entries == [mutation]
instance._staged_entries = []
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_append_multiple_sequentially(self):
"""Append multiple mutations"""
async with self._make_one(
@@ -671,7 +686,7 @@ async def test_append_multiple_sequentially(self):
assert instance._staged_count == 0
assert instance._staged_bytes == 0
assert instance._staged_entries == []
- mutation = _make_mutation(count=2, size=3)
+ mutation = self._make_mutation(count=2, size=3)
with mock.patch.object(instance, "_schedule_flush") as flush_mock:
await instance.append(mutation)
assert flush_mock.call_count == 0
@@ -690,7 +705,7 @@ async def test_append_multiple_sequentially(self):
assert len(instance._staged_entries) == 3
instance._staged_entries = []
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_flush_flow_control_concurrent_requests(self):
"""
requests should happen in parallel if flow control breaks up single flush into batches
@@ -698,14 +713,14 @@ async def test_flush_flow_control_concurrent_requests(self):
import time
num_calls = 10
- fake_mutations = [_make_mutation(count=1) for _ in range(num_calls)]
+ fake_mutations = [self._make_mutation(count=1) for _ in range(num_calls)]
async with self._make_one(flow_control_max_mutation_count=1) as instance:
with mock.patch.object(
- instance, "_execute_mutate_rows", AsyncMock()
+ instance, "_execute_mutate_rows", CrossSync.Mock()
) as op_mock:
# mock network calls
async def mock_call(*args, **kwargs):
- await asyncio.sleep(0.1)
+ await CrossSync.sleep(0.1)
return []
op_mock.side_effect = mock_call
@@ -713,15 +728,15 @@ async def mock_call(*args, **kwargs):
# flush one large batch, that will be broken up into smaller batches
instance._staged_entries = fake_mutations
instance._schedule_flush()
- await asyncio.sleep(0.01)
+ await CrossSync.sleep(0.01)
# make room for new mutations
for i in range(num_calls):
await instance._flow_control.remove_from_flow(
- [_make_mutation(count=1)]
+ [self._make_mutation(count=1)]
)
- await asyncio.sleep(0.01)
+ await CrossSync.sleep(0.01)
# allow flushes to complete
- await asyncio.gather(*instance._flush_jobs)
+ await instance._wait_for_batch_results(*instance._flush_jobs)
duration = time.monotonic() - start_time
assert len(instance._oldest_exceptions) == 0
assert len(instance._newest_exceptions) == 0
@@ -729,7 +744,7 @@ async def mock_call(*args, **kwargs):
assert duration < 0.5
assert op_mock.call_count == num_calls
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_schedule_flush_no_mutations(self):
"""schedule flush should return None if no staged mutations"""
async with self._make_one() as instance:
@@ -738,11 +753,15 @@ async def test_schedule_flush_no_mutations(self):
assert instance._schedule_flush() is None
assert flush_mock.call_count == 0
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
async def test_schedule_flush_with_mutations(self):
"""if new mutations exist, should add a new flush task to _flush_jobs"""
async with self._make_one() as instance:
with mock.patch.object(instance, "_flush_internal") as flush_mock:
+ if not CrossSync.is_async:
+ # simulate operation
+ flush_mock.side_effect = lambda x: time.sleep(0.1)
for i in range(1, 4):
mutation = mock.Mock()
instance._staged_entries = [mutation]
@@ -753,9 +772,10 @@ async def test_schedule_flush_with_mutations(self):
assert instance._staged_entries == []
assert instance._staged_count == 0
assert instance._staged_bytes == 0
- assert flush_mock.call_count == i
+ assert flush_mock.call_count == 1
+ flush_mock.reset_mock()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__flush_internal(self):
"""
_flush_internal should:
@@ -775,7 +795,7 @@ async def gen(x):
yield x
flow_mock.side_effect = lambda x: gen(x)
- mutations = [_make_mutation(count=1, size=1)] * num_entries
+ mutations = [self._make_mutation(count=1, size=1)] * num_entries
await instance._flush_internal(mutations)
assert instance._entries_processed_since_last_raise == num_entries
assert execute_mock.call_count == 1
@@ -783,20 +803,28 @@ async def gen(x):
instance._oldest_exceptions.clear()
instance._newest_exceptions.clear()
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_flush_clears_job_list(self):
"""
a job should be added to _flush_jobs when _schedule_flush is called,
and removed when it completes
"""
async with self._make_one() as instance:
- with mock.patch.object(instance, "_flush_internal", AsyncMock()):
- mutations = [_make_mutation(count=1, size=1)]
+ with mock.patch.object(
+ instance, "_flush_internal", CrossSync.Mock()
+ ) as flush_mock:
+ if not CrossSync.is_async:
+ # simulate operation
+ flush_mock.side_effect = lambda x: time.sleep(0.1)
+ mutations = [self._make_mutation(count=1, size=1)]
instance._staged_entries = mutations
assert instance._flush_jobs == set()
new_job = instance._schedule_flush()
assert instance._flush_jobs == {new_job}
- await new_job
+ if CrossSync.is_async:
+ await new_job
+ else:
+ new_job.result()
assert instance._flush_jobs == set()
@pytest.mark.parametrize(
@@ -811,7 +839,7 @@ async def test_flush_clears_job_list(self):
(10, 20, 20), # should cap at 20
],
)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__flush_internal_with_errors(
self, num_starting, num_new_errors, expected_total_errors
):
@@ -836,7 +864,7 @@ async def gen(x):
yield x
flow_mock.side_effect = lambda x: gen(x)
- mutations = [_make_mutation(count=1, size=1)] * num_entries
+ mutations = [self._make_mutation(count=1, size=1)] * num_entries
await instance._flush_internal(mutations)
assert instance._entries_processed_since_last_raise == num_entries
assert execute_mock.call_count == 1
@@ -853,10 +881,12 @@ async def gen(x):
instance._oldest_exceptions.clear()
instance._newest_exceptions.clear()
+ @CrossSync.convert
async def _mock_gapic_return(self, num=5):
from google.cloud.bigtable_v2.types import MutateRowsResponse
from google.rpc import status_pb2
+ @CrossSync.convert
async def gen(num):
for i in range(num):
entry = MutateRowsResponse.Entry(
@@ -866,11 +896,11 @@ async def gen(num):
return gen(num)
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_timer_flush_end_to_end(self):
"""Flush should automatically trigger after flush_interval"""
- num_nutations = 10
- mutations = [_make_mutation(count=2, size=2)] * num_nutations
+ num_mutations = 10
+ mutations = [self._make_mutation(count=2, size=2)] * num_mutations
async with self._make_one(flush_interval=0.05) as instance:
instance._table.default_operation_timeout = 10
@@ -879,69 +909,65 @@ async def test_timer_flush_end_to_end(self):
instance._table.client._gapic_client, "mutate_rows"
) as gapic_mock:
gapic_mock.side_effect = (
- lambda *args, **kwargs: self._mock_gapic_return(num_nutations)
+ lambda *args, **kwargs: self._mock_gapic_return(num_mutations)
)
for m in mutations:
await instance.append(m)
assert instance._entries_processed_since_last_raise == 0
# let flush trigger due to timer
- await asyncio.sleep(0.1)
- assert instance._entries_processed_since_last_raise == num_nutations
-
- @pytest.mark.asyncio
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher._MutateRowsOperationAsync",
- )
- async def test__execute_mutate_rows(self, mutate_rows):
- mutate_rows.return_value = AsyncMock()
- start_operation = mutate_rows().start
- table = mock.Mock()
- table.table_name = "test-table"
- table.app_profile_id = "test-app-profile"
- table.default_mutate_rows_operation_timeout = 17
- table.default_mutate_rows_attempt_timeout = 13
- table.default_mutate_rows_retryable_errors = ()
- async with self._make_one(table) as instance:
- batch = [_make_mutation()]
- result = await instance._execute_mutate_rows(batch)
- assert start_operation.call_count == 1
- args, kwargs = mutate_rows.call_args
- assert args[0] == table.client._gapic_client
- assert args[1] == table
- assert args[2] == batch
- kwargs["operation_timeout"] == 17
- kwargs["attempt_timeout"] == 13
- assert result == []
-
- @pytest.mark.asyncio
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher._MutateRowsOperationAsync.start"
- )
- async def test__execute_mutate_rows_returns_errors(self, mutate_rows):
+ await CrossSync.sleep(0.1)
+ assert instance._entries_processed_since_last_raise == num_mutations
+
+ @CrossSync.pytest
+ async def test__execute_mutate_rows(self):
+ with mock.patch.object(CrossSync, "_MutateRowsOperation") as mutate_rows:
+ mutate_rows.return_value = CrossSync.Mock()
+ start_operation = mutate_rows().start
+ table = mock.Mock()
+ table.table_name = "test-table"
+ table.app_profile_id = "test-app-profile"
+ table.default_mutate_rows_operation_timeout = 17
+ table.default_mutate_rows_attempt_timeout = 13
+ table.default_mutate_rows_retryable_errors = ()
+ async with self._make_one(table) as instance:
+ batch = [self._make_mutation()]
+ result = await instance._execute_mutate_rows(batch)
+ assert start_operation.call_count == 1
+ args, kwargs = mutate_rows.call_args
+ assert args[0] == table.client._gapic_client
+ assert args[1] == table
+ assert args[2] == batch
+ kwargs["operation_timeout"] == 17
+ kwargs["attempt_timeout"] == 13
+ assert result == []
+
+ @CrossSync.pytest
+ async def test__execute_mutate_rows_returns_errors(self):
"""Errors from operation should be retruned as list"""
from google.cloud.bigtable.data.exceptions import (
MutationsExceptionGroup,
FailedMutationEntryError,
)
- err1 = FailedMutationEntryError(0, mock.Mock(), RuntimeError("test error"))
- err2 = FailedMutationEntryError(1, mock.Mock(), RuntimeError("test error"))
- mutate_rows.side_effect = MutationsExceptionGroup([err1, err2], 10)
- table = mock.Mock()
- table.default_mutate_rows_operation_timeout = 17
- table.default_mutate_rows_attempt_timeout = 13
- table.default_mutate_rows_retryable_errors = ()
- async with self._make_one(table) as instance:
- batch = [_make_mutation()]
- result = await instance._execute_mutate_rows(batch)
- assert len(result) == 2
- assert result[0] == err1
- assert result[1] == err2
- # indices should be set to None
- assert result[0].index is None
- assert result[1].index is None
-
- @pytest.mark.asyncio
+ with mock.patch.object(CrossSync._MutateRowsOperation, "start") as mutate_rows:
+ err1 = FailedMutationEntryError(0, mock.Mock(), RuntimeError("test error"))
+ err2 = FailedMutationEntryError(1, mock.Mock(), RuntimeError("test error"))
+ mutate_rows.side_effect = MutationsExceptionGroup([err1, err2], 10)
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 17
+ table.default_mutate_rows_attempt_timeout = 13
+ table.default_mutate_rows_retryable_errors = ()
+ async with self._make_one(table) as instance:
+ batch = [self._make_mutation()]
+ result = await instance._execute_mutate_rows(batch)
+ assert len(result) == 2
+ assert result[0] == err1
+ assert result[1] == err2
+ # indices should be set to None
+ assert result[0].index is None
+ assert result[1].index is None
+
+ @CrossSync.pytest
async def test__raise_exceptions(self):
"""Raise exceptions and reset error state"""
from google.cloud.bigtable.data import exceptions
@@ -961,13 +987,19 @@ async def test__raise_exceptions(self):
# try calling again
instance._raise_exceptions()
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @CrossSync.convert(
+ sync_name="test___enter__", replace_symbols={"__aenter__": "__enter__"}
+ )
async def test___aenter__(self):
"""Should return self"""
async with self._make_one() as instance:
assert await instance.__aenter__() == instance
- @pytest.mark.asyncio
+ @CrossSync.pytest
+ @CrossSync.convert(
+ sync_name="test___exit__", replace_symbols={"__aexit__": "__exit__"}
+ )
async def test___aexit__(self):
"""aexit should call close"""
async with self._make_one() as instance:
@@ -975,7 +1007,7 @@ async def test___aexit__(self):
await instance.__aexit__(None, None, None)
assert close_mock.call_count == 1
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_close(self):
"""Should clean up all resources"""
async with self._make_one() as instance:
@@ -988,7 +1020,7 @@ async def test_close(self):
assert flush_mock.call_count == 1
assert raise_mock.call_count == 1
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_close_w_exceptions(self):
"""Raise exceptions on close"""
from google.cloud.bigtable.data import exceptions
@@ -1007,7 +1039,7 @@ async def test_close_w_exceptions(self):
# clear out exceptions
instance._oldest_exceptions, instance._newest_exceptions = ([], [])
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test__on_exit(self, recwarn):
"""Should raise warnings if unflushed mutations exist"""
async with self._make_one() as instance:
@@ -1023,13 +1055,13 @@ async def test__on_exit(self, recwarn):
assert "unflushed mutations" in str(w[0].message).lower()
assert str(num_left) in str(w[0].message)
# calling while closed is noop
- instance.closed = True
+ instance._closed.set()
instance._on_exit()
assert len(recwarn) == 0
# reset staged mutations for cleanup
instance._staged_entries = []
- @pytest.mark.asyncio
+ @CrossSync.pytest
async def test_atexit_registration(self):
"""Should run _on_exit on program termination"""
import atexit
@@ -1039,30 +1071,29 @@ async def test_atexit_registration(self):
async with self._make_one():
assert register_mock.call_count == 1
- @pytest.mark.asyncio
- @mock.patch(
- "google.cloud.bigtable.data._async.mutations_batcher._MutateRowsOperationAsync",
- )
- async def test_timeout_args_passed(self, mutate_rows):
+ @CrossSync.pytest
+ async def test_timeout_args_passed(self):
"""
batch_operation_timeout and batch_attempt_timeout should be used
in api calls
"""
- mutate_rows.return_value = AsyncMock()
- expected_operation_timeout = 17
- expected_attempt_timeout = 13
- async with self._make_one(
- batch_operation_timeout=expected_operation_timeout,
- batch_attempt_timeout=expected_attempt_timeout,
- ) as instance:
- assert instance._operation_timeout == expected_operation_timeout
- assert instance._attempt_timeout == expected_attempt_timeout
- # make simulated gapic call
- await instance._execute_mutate_rows([_make_mutation()])
- assert mutate_rows.call_count == 1
- kwargs = mutate_rows.call_args[1]
- assert kwargs["operation_timeout"] == expected_operation_timeout
- assert kwargs["attempt_timeout"] == expected_attempt_timeout
+ with mock.patch.object(
+ CrossSync, "_MutateRowsOperation", return_value=CrossSync.Mock()
+ ) as mutate_rows:
+ expected_operation_timeout = 17
+ expected_attempt_timeout = 13
+ async with self._make_one(
+ batch_operation_timeout=expected_operation_timeout,
+ batch_attempt_timeout=expected_attempt_timeout,
+ ) as instance:
+ assert instance._operation_timeout == expected_operation_timeout
+ assert instance._attempt_timeout == expected_attempt_timeout
+ # make simulated gapic call
+ await instance._execute_mutate_rows([self._make_mutation()])
+ assert mutate_rows.call_count == 1
+ kwargs = mutate_rows.call_args[1]
+ assert kwargs["operation_timeout"] == expected_operation_timeout
+ assert kwargs["attempt_timeout"] == expected_attempt_timeout
@pytest.mark.parametrize(
"limit,in_e,start_e,end_e",
@@ -1123,7 +1154,7 @@ def test__add_exceptions(self, limit, in_e, start_e, end_e):
for i in range(1, newest_list_diff + 1):
assert mock_batcher._newest_exceptions[-i] == input_list[-i]
- @pytest.mark.asyncio
+ @CrossSync.pytest
# test different inputs for retryable exceptions
@pytest.mark.parametrize(
"input_retryables,expected_retryables",
@@ -1148,6 +1179,7 @@ def test__add_exceptions(self, limit, in_e, start_e, end_e):
([4], [core_exceptions.DeadlineExceeded]),
],
)
+ @CrossSync.convert
async def test_customizable_retryable_errors(
self, input_retryables, expected_retryables
):
@@ -1155,25 +1187,21 @@ async def test_customizable_retryable_errors(
Test that retryable functions support user-configurable arguments, and that the configured retryables are passed
down to the gapic layer.
"""
- from google.cloud.bigtable.data._async.client import TableAsync
-
- with mock.patch(
- "google.api_core.retry.if_exception_type"
+ with mock.patch.object(
+ google.api_core.retry, "if_exception_type"
) as predicate_builder_mock:
- with mock.patch(
- "google.api_core.retry.retry_target_async"
- ) as retry_fn_mock:
+ with mock.patch.object(CrossSync, "retry_target") as retry_fn_mock:
table = None
with mock.patch("asyncio.create_task"):
- table = TableAsync(mock.Mock(), "instance", "table")
+ table = CrossSync.Table(mock.Mock(), "instance", "table")
async with self._make_one(
table, batch_retryable_errors=input_retryables
) as instance:
assert instance._retryable_errors == expected_retryables
- expected_predicate = lambda a: a in expected_retryables # noqa
+ expected_predicate = expected_retryables.__contains__
predicate_builder_mock.return_value = expected_predicate
retry_fn_mock.side_effect = RuntimeError("stop early")
- mutation = _make_mutation(count=1, size=1)
+ mutation = self._make_mutation(count=1, size=1)
await instance._execute_mutate_rows([mutation])
# passed in errors should be used to build the predicate
predicate_builder_mock.assert_called_once_with(
@@ -1182,3 +1210,25 @@ async def test_customizable_retryable_errors(
retry_call_args = retry_fn_mock.call_args_list[0].args
# output of if_exception_type should be sent in to retry constructor
assert retry_call_args[1] is expected_predicate
+
+ @CrossSync.pytest
+ async def test_large_batch_write(self):
+ """
+ Test that a large batch of mutations can be written
+ """
+ import math
+
+ num_mutations = 10_000
+ flush_limit = 1000
+ mutations = [self._make_mutation(count=1, size=1)] * num_mutations
+ async with self._make_one(flush_limit_mutation_count=flush_limit) as instance:
+ operation_mock = mock.Mock()
+ rpc_call_mock = CrossSync.Mock()
+ operation_mock().start = rpc_call_mock
+ CrossSync._MutateRowsOperation = operation_mock
+ for m in mutations:
+ await instance.append(m)
+ expected_calls = math.ceil(num_mutations / flush_limit)
+ assert rpc_call_mock.call_count == expected_calls
+ assert instance._entries_processed_since_last_raise == num_mutations
+ assert len(instance._staged_entries) == 0
diff --git a/tests/unit/data/_async/test_read_rows_acceptance.py b/tests/unit/data/_async/test_read_rows_acceptance.py
new file mode 100644
index 000000000..ab9502223
--- /dev/null
+++ b/tests/unit/data/_async/test_read_rows_acceptance.py
@@ -0,0 +1,355 @@
+# Copyright 2024 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.
+from __future__ import annotations
+
+import os
+import warnings
+import pytest
+import mock
+
+from itertools import zip_longest
+
+from google.cloud.bigtable_v2 import ReadRowsResponse
+
+from google.cloud.bigtable.data.exceptions import InvalidChunk
+from google.cloud.bigtable.data.row import Row
+
+from ...v2_client.test_row_merger import ReadRowsTest, TestFile
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+
+__CROSS_SYNC_OUTPUT__ = "tests.unit.data._sync_autogen.test_read_rows_acceptance"
+
+
+@CrossSync.convert_class(
+ sync_name="TestReadRowsAcceptance",
+)
+class TestReadRowsAcceptanceAsync:
+ @staticmethod
+ @CrossSync.convert
+ def _get_operation_class():
+ return CrossSync._ReadRowsOperation
+
+ @staticmethod
+ @CrossSync.convert
+ def _get_client_class():
+ return CrossSync.DataClient
+
+ def parse_readrows_acceptance_tests():
+ dirname = os.path.dirname(__file__)
+ filename = os.path.join(dirname, "../read-rows-acceptance-test.json")
+
+ with open(filename) as json_file:
+ test_json = TestFile.from_json(json_file.read())
+ return test_json.read_rows_tests
+
+ @staticmethod
+ def extract_results_from_row(row: Row):
+ results = []
+ for family, col, cells in row.items():
+ for cell in cells:
+ results.append(
+ ReadRowsTest.Result(
+ row_key=row.row_key,
+ family_name=family,
+ qualifier=col,
+ timestamp_micros=cell.timestamp_ns // 1000,
+ value=cell.value,
+ label=(cell.labels[0] if cell.labels else ""),
+ )
+ )
+ return results
+
+ @staticmethod
+ @CrossSync.convert
+ async def _coro_wrapper(stream):
+ return stream
+
+ @CrossSync.convert
+ async def _process_chunks(self, *chunks):
+ @CrossSync.convert
+ async def _row_stream():
+ yield ReadRowsResponse(chunks=chunks)
+
+ instance = mock.Mock()
+ instance._remaining_count = None
+ instance._last_yielded_row_key = None
+ chunker = self._get_operation_class().chunk_stream(
+ instance, self._coro_wrapper(_row_stream())
+ )
+ merger = self._get_operation_class().merge_rows(chunker)
+ results = []
+ async for row in merger:
+ results.append(row)
+ return results
+
+ @pytest.mark.parametrize(
+ "test_case", parse_readrows_acceptance_tests(), ids=lambda t: t.description
+ )
+ @CrossSync.pytest
+ async def test_row_merger_scenario(self, test_case: ReadRowsTest):
+ async def _scenerio_stream():
+ for chunk in test_case.chunks:
+ yield ReadRowsResponse(chunks=[chunk])
+
+ try:
+ results = []
+ instance = mock.Mock()
+ instance._last_yielded_row_key = None
+ instance._remaining_count = None
+ chunker = self._get_operation_class().chunk_stream(
+ instance, self._coro_wrapper(_scenerio_stream())
+ )
+ merger = self._get_operation_class().merge_rows(chunker)
+ async for row in merger:
+ for cell in row:
+ cell_result = ReadRowsTest.Result(
+ row_key=cell.row_key,
+ family_name=cell.family,
+ qualifier=cell.qualifier,
+ timestamp_micros=cell.timestamp_micros,
+ value=cell.value,
+ label=cell.labels[0] if cell.labels else "",
+ )
+ results.append(cell_result)
+ except InvalidChunk:
+ results.append(ReadRowsTest.Result(error=True))
+ for expected, actual in zip_longest(test_case.results, results):
+ assert actual == expected
+
+ @pytest.mark.parametrize(
+ "test_case", parse_readrows_acceptance_tests(), ids=lambda t: t.description
+ )
+ @CrossSync.pytest
+ async def test_read_rows_scenario(self, test_case: ReadRowsTest):
+ async def _make_gapic_stream(chunk_list: list[ReadRowsResponse]):
+ from google.cloud.bigtable_v2 import ReadRowsResponse
+
+ class mock_stream:
+ def __init__(self, chunk_list):
+ self.chunk_list = chunk_list
+ self.idx = -1
+
+ def __aiter__(self):
+ return self
+
+ def __iter__(self):
+ return self
+
+ async def __anext__(self):
+ self.idx += 1
+ if len(self.chunk_list) > self.idx:
+ chunk = self.chunk_list[self.idx]
+ return ReadRowsResponse(chunks=[chunk])
+ raise CrossSync.StopIteration
+
+ def __next__(self):
+ return self.__anext__()
+
+ def cancel(self):
+ pass
+
+ return mock_stream(chunk_list)
+
+ with mock.patch.dict(os.environ, {"BIGTABLE_EMULATOR_HOST": "localhost"}):
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ # use emulator mode to avoid auth issues in CI
+ client = self._get_client_class()()
+ try:
+ table = client.get_table("instance", "table")
+ results = []
+ with mock.patch.object(
+ table.client._gapic_client, "read_rows"
+ ) as read_rows:
+ # run once, then return error on retry
+ read_rows.return_value = _make_gapic_stream(test_case.chunks)
+ async for row in await table.read_rows_stream(query={}):
+ for cell in row:
+ cell_result = ReadRowsTest.Result(
+ row_key=cell.row_key,
+ family_name=cell.family,
+ qualifier=cell.qualifier,
+ timestamp_micros=cell.timestamp_micros,
+ value=cell.value,
+ label=cell.labels[0] if cell.labels else "",
+ )
+ results.append(cell_result)
+ except InvalidChunk:
+ results.append(ReadRowsTest.Result(error=True))
+ finally:
+ await client.close()
+ for expected, actual in zip_longest(test_case.results, results):
+ assert actual == expected
+
+ @CrossSync.pytest
+ async def test_out_of_order_rows(self):
+ async def _row_stream():
+ yield ReadRowsResponse(last_scanned_row_key=b"a")
+
+ instance = mock.Mock()
+ instance._remaining_count = None
+ instance._last_yielded_row_key = b"b"
+ chunker = self._get_operation_class().chunk_stream(
+ instance, self._coro_wrapper(_row_stream())
+ )
+ merger = self._get_operation_class().merge_rows(chunker)
+ with pytest.raises(InvalidChunk):
+ async for _ in merger:
+ pass
+
+ @CrossSync.pytest
+ async def test_bare_reset(self):
+ first_chunk = ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a", family_name="f", qualifier=b"q", value=b"v"
+ )
+ )
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, row_key=b"a")
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, family_name="f")
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, qualifier=b"q")
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, timestamp_micros=1000)
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, labels=["a"])
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, value=b"v")
+ ),
+ )
+
+ @CrossSync.pytest
+ async def test_missing_family(self):
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value=b"v",
+ commit_row=True,
+ )
+ )
+
+ @CrossSync.pytest
+ async def test_mid_cell_row_key_change(self):
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(row_key=b"b", value=b"v", commit_row=True),
+ )
+
+ @CrossSync.pytest
+ async def test_mid_cell_family_change(self):
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(
+ family_name="f2", value=b"v", commit_row=True
+ ),
+ )
+
+ @CrossSync.pytest
+ async def test_mid_cell_qualifier_change(self):
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(
+ qualifier=b"q2", value=b"v", commit_row=True
+ ),
+ )
+
+ @CrossSync.pytest
+ async def test_mid_cell_timestamp_change(self):
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(
+ timestamp_micros=2000, value=b"v", commit_row=True
+ ),
+ )
+
+ @CrossSync.pytest
+ async def test_mid_cell_labels_change(self):
+ with pytest.raises(InvalidChunk):
+ await self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(labels=["b"], value=b"v", commit_row=True),
+ )
diff --git a/tests/unit/data/_cross_sync/test_cross_sync.py b/tests/unit/data/_cross_sync/test_cross_sync.py
new file mode 100644
index 000000000..410f59437
--- /dev/null
+++ b/tests/unit/data/_cross_sync/test_cross_sync.py
@@ -0,0 +1,579 @@
+# Copyright 2024 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 typing
+import asyncio
+import pytest
+import pytest_asyncio
+import threading
+import concurrent.futures
+import time
+import queue
+import functools
+import sys
+from google import api_core
+from google.cloud.bigtable.data._cross_sync.cross_sync import CrossSync, T
+
+# try/except added for compatibility with python < 3.8
+try:
+ from unittest import mock
+ from unittest.mock import AsyncMock # type: ignore
+except ImportError: # pragma: NO COVER
+ import mock # type: ignore
+ from mock import AsyncMock # type: ignore
+
+
+class TestCrossSync:
+ async def async_iter(self, in_list):
+ for i in in_list:
+ yield i
+
+ @pytest.fixture
+ def cs_sync(self):
+ return CrossSync._Sync_Impl
+
+ @pytest_asyncio.fixture
+ def cs_async(self):
+ return CrossSync
+
+ @pytest.mark.parametrize(
+ "attr, async_version, sync_version",
+ [
+ ("is_async", True, False),
+ ("sleep", asyncio.sleep, time.sleep),
+ (
+ "retry_target",
+ api_core.retry.retry_target_async,
+ api_core.retry.retry_target,
+ ),
+ (
+ "retry_target_stream",
+ api_core.retry.retry_target_stream_async,
+ api_core.retry.retry_target_stream,
+ ),
+ ("Retry", api_core.retry.AsyncRetry, api_core.retry.Retry),
+ ("Queue", asyncio.Queue, queue.Queue),
+ ("Condition", asyncio.Condition, threading.Condition),
+ ("Future", asyncio.Future, concurrent.futures.Future),
+ ("Task", asyncio.Task, concurrent.futures.Future),
+ ("Event", asyncio.Event, threading.Event),
+ ("Semaphore", asyncio.Semaphore, threading.Semaphore),
+ ("StopIteration", StopAsyncIteration, StopIteration),
+ # types
+ ("Awaitable", typing.Awaitable, typing.Union[T]),
+ ("Iterable", typing.AsyncIterable, typing.Iterable),
+ ("Iterator", typing.AsyncIterator, typing.Iterator),
+ ("Generator", typing.AsyncGenerator, typing.Generator),
+ ],
+ )
+ def test_alias_attributes(
+ self, attr, async_version, sync_version, cs_sync, cs_async
+ ):
+ """
+ Test basic alias attributes, to ensure they point to the right place
+ in both sync and async versions.
+ """
+ assert (
+ getattr(cs_async, attr) == async_version
+ ), f"Failed async version for {attr}"
+ assert getattr(cs_sync, attr) == sync_version, f"Failed sync version for {attr}"
+
+ @pytest.mark.asyncio
+ async def test_Mock(self, cs_sync, cs_async):
+ """
+ Test Mock class in both sync and async versions
+ """
+ import unittest.mock
+
+ assert isinstance(cs_async.Mock(), AsyncMock)
+ assert isinstance(cs_sync.Mock(), unittest.mock.Mock)
+ # test with return value
+ assert await cs_async.Mock(return_value=1)() == 1
+ assert cs_sync.Mock(return_value=1)() == 1
+
+ def test_next(self, cs_sync):
+ """
+ Test sync version of CrossSync.next()
+ """
+ it = iter([1, 2, 3])
+ assert cs_sync.next(it) == 1
+ assert cs_sync.next(it) == 2
+ assert cs_sync.next(it) == 3
+ with pytest.raises(StopIteration):
+ cs_sync.next(it)
+ with pytest.raises(cs_sync.StopIteration):
+ cs_sync.next(it)
+
+ @pytest.mark.asyncio
+ async def test_next_async(self, cs_async):
+ """
+ test async version of CrossSync.next()
+ """
+ async_it = self.async_iter([1, 2, 3])
+ assert await cs_async.next(async_it) == 1
+ assert await cs_async.next(async_it) == 2
+ assert await cs_async.next(async_it) == 3
+ with pytest.raises(StopAsyncIteration):
+ await cs_async.next(async_it)
+ with pytest.raises(cs_async.StopIteration):
+ await cs_async.next(async_it)
+
+ def test_gather_partials(self, cs_sync):
+ """
+ Test sync version of CrossSync.gather_partials()
+ """
+ with concurrent.futures.ThreadPoolExecutor() as e:
+ partials = [lambda i=i: i + 1 for i in range(5)]
+ results = cs_sync.gather_partials(partials, sync_executor=e)
+ assert results == [1, 2, 3, 4, 5]
+
+ def test_gather_partials_with_excepptions(self, cs_sync):
+ """
+ Test sync version of CrossSync.gather_partials() with exceptions
+ """
+ with concurrent.futures.ThreadPoolExecutor() as e:
+ partials = [lambda i=i: i + 1 if i != 3 else 1 / 0 for i in range(5)]
+ with pytest.raises(ZeroDivisionError):
+ cs_sync.gather_partials(partials, sync_executor=e)
+
+ def test_gather_partials_return_exceptions(self, cs_sync):
+ """
+ Test sync version of CrossSync.gather_partials() with return_exceptions=True
+ """
+ with concurrent.futures.ThreadPoolExecutor() as e:
+ partials = [lambda i=i: i + 1 if i != 3 else 1 / 0 for i in range(5)]
+ results = cs_sync.gather_partials(
+ partials, return_exceptions=True, sync_executor=e
+ )
+ assert len(results) == 5
+ assert results[0] == 1
+ assert results[1] == 2
+ assert results[2] == 3
+ assert isinstance(results[3], ZeroDivisionError)
+ assert results[4] == 5
+
+ def test_gather_partials_no_executor(self, cs_sync):
+ """
+ Test sync version of CrossSync.gather_partials() without an executor
+ """
+ partials = [lambda i=i: i + 1 for i in range(5)]
+ with pytest.raises(ValueError) as e:
+ cs_sync.gather_partials(partials)
+ assert "sync_executor is required" in str(e.value)
+
+ @pytest.mark.asyncio
+ async def test_gather_partials_async(self, cs_async):
+ """
+ Test async version of CrossSync.gather_partials()
+ """
+
+ async def coro(i):
+ return i + 1
+
+ partials = [functools.partial(coro, i) for i in range(5)]
+ results = await cs_async.gather_partials(partials)
+ assert results == [1, 2, 3, 4, 5]
+
+ @pytest.mark.asyncio
+ async def test_gather_partials_async_with_exceptions(self, cs_async):
+ """
+ Test async version of CrossSync.gather_partials() with exceptions
+ """
+
+ async def coro(i):
+ return i + 1 if i != 3 else 1 / 0
+
+ partials = [functools.partial(coro, i) for i in range(5)]
+ with pytest.raises(ZeroDivisionError):
+ await cs_async.gather_partials(partials)
+
+ @pytest.mark.asyncio
+ async def test_gather_partials_async_return_exceptions(self, cs_async):
+ """
+ Test async version of CrossSync.gather_partials() with return_exceptions=True
+ """
+
+ async def coro(i):
+ return i + 1 if i != 3 else 1 / 0
+
+ partials = [functools.partial(coro, i) for i in range(5)]
+ results = await cs_async.gather_partials(partials, return_exceptions=True)
+ assert len(results) == 5
+ assert results[0] == 1
+ assert results[1] == 2
+ assert results[2] == 3
+ assert isinstance(results[3], ZeroDivisionError)
+ assert results[4] == 5
+
+ @pytest.mark.asyncio
+ async def test_gather_partials_async_uses_asyncio_gather(self, cs_async):
+ """
+ CrossSync.gather_partials() should use asyncio.gather() internally
+ """
+
+ async def coro(i):
+ return i + 1
+
+ return_exceptions = object()
+ partials = [functools.partial(coro, i) for i in range(5)]
+ with mock.patch.object(asyncio, "gather", AsyncMock()) as gather:
+ await cs_async.gather_partials(
+ partials, return_exceptions=return_exceptions
+ )
+ gather.assert_called_once()
+ found_args, found_kwargs = gather.call_args
+ assert found_kwargs["return_exceptions"] == return_exceptions
+ for coro in found_args:
+ await coro
+
+ def test_wait(self, cs_sync):
+ """
+ Test sync version of CrossSync.wait()
+
+ If future is complete, it should be in the first (complete) set
+ """
+ future = concurrent.futures.Future()
+ future.set_result(1)
+ s1, s2 = cs_sync.wait([future])
+ assert s1 == {future}
+ assert s2 == set()
+
+ def test_wait_timeout(self, cs_sync):
+ """
+ If timeout occurs, future should be in the second (incomplete) set
+ """
+ future = concurrent.futures.Future()
+ timeout = 0.1
+ start_time = time.monotonic()
+ s1, s2 = cs_sync.wait([future], timeout)
+ end_time = time.monotonic()
+ assert abs((end_time - start_time) - timeout) < 0.01
+ assert s1 == set()
+ assert s2 == {future}
+
+ def test_wait_passthrough(self, cs_sync):
+ """
+ sync version of CrossSync.wait() should pass through to concurrent.futures.wait()
+ """
+ future = object()
+ timeout = object()
+ with mock.patch.object(concurrent.futures, "wait", mock.Mock()) as wait:
+ result = cs_sync.wait([future], timeout)
+ assert wait.call_count == 1
+ assert wait.call_args == (([future],), {"timeout": timeout})
+ assert result == wait.return_value
+
+ def test_wait_empty_input(self, cs_sync):
+ """
+ If no futures are provided, return empty sets
+ """
+ s1, s2 = cs_sync.wait([])
+ assert s1 == set()
+ assert s2 == set()
+
+ @pytest.mark.asyncio
+ async def test_wait_async(self, cs_async):
+ """
+ Test async version of CrossSync.wait()
+ """
+ future = asyncio.Future()
+ future.set_result(1)
+ s1, s2 = await cs_async.wait([future])
+ assert s1 == {future}
+ assert s2 == set()
+
+ @pytest.mark.asyncio
+ async def test_wait_async_timeout(self, cs_async):
+ """
+ If timeout occurs, future should be in the second (incomplete) set
+ """
+ future = asyncio.Future()
+ timeout = 0.1
+ start_time = time.monotonic()
+ s1, s2 = await cs_async.wait([future], timeout)
+ end_time = time.monotonic()
+ assert abs((end_time - start_time) - timeout) < 0.01
+ assert s1 == set()
+ assert s2 == {future}
+
+ @pytest.mark.asyncio
+ async def test_wait_async_passthrough(self, cs_async):
+ """
+ async version of CrossSync.wait() should pass through to asyncio.wait()
+ """
+ future = object()
+ timeout = object()
+ with mock.patch.object(asyncio, "wait", AsyncMock()) as wait:
+ result = await cs_async.wait([future], timeout)
+ assert wait.call_count == 1
+ assert wait.call_args == (([future],), {"timeout": timeout})
+ assert result == wait.return_value
+
+ @pytest.mark.asyncio
+ async def test_wait_async_empty_input(self, cs_async):
+ """
+ If no futures are provided, return empty sets
+ """
+ s1, s2 = await cs_async.wait([])
+ assert s1 == set()
+ assert s2 == set()
+
+ def test_event_wait_passthrough(self, cs_sync):
+ """
+ Test sync version of CrossSync.event_wait()
+ should pass through timeout directly to the event.wait() call
+ """
+ event = mock.Mock()
+ timeout = object()
+ cs_sync.event_wait(event, timeout)
+ event.wait.assert_called_once_with(timeout=timeout)
+
+ @pytest.mark.parametrize("timeout", [0, 0.01, 0.05])
+ def test_event_wait_timeout_exceeded(self, cs_sync, timeout):
+ """
+ Test sync version of CrossSync.event_wait()
+ """
+ event = threading.Event()
+ start_time = time.monotonic()
+ cs_sync.event_wait(event, timeout=timeout)
+ end_time = time.monotonic()
+ assert abs((end_time - start_time) - timeout) < 0.01
+
+ def test_event_wait_already_set(self, cs_sync):
+ """
+ if event is already set, do not block
+ """
+ event = threading.Event()
+ event.set()
+ start_time = time.monotonic()
+ cs_sync.event_wait(event, timeout=10)
+ end_time = time.monotonic()
+ assert end_time - start_time < 0.01
+
+ @pytest.mark.parametrize("break_early", [True, False])
+ @pytest.mark.asyncio
+ async def test_event_wait_async(self, cs_async, break_early):
+ """
+ With no timeout, call event.wait() with no arguments
+ """
+ event = AsyncMock()
+ await cs_async.event_wait(event, async_break_early=break_early)
+ event.wait.assert_called_once_with()
+
+ @pytest.mark.asyncio
+ async def test_event_wait_async_with_timeout(self, cs_async):
+ """
+ In with timeout set, should call event.wait(), wrapped in wait_for()
+ for the timeout
+ """
+ event = mock.Mock()
+ event.wait.return_value = object()
+ timeout = object()
+ with mock.patch.object(asyncio, "wait_for", AsyncMock()) as wait_for:
+ await cs_async.event_wait(event, timeout=timeout)
+ assert wait_for.await_count == 1
+ assert wait_for.call_count == 1
+ wait_for.assert_called_once_with(event.wait(), timeout=timeout)
+
+ @pytest.mark.asyncio
+ async def test_event_wait_async_timeout_exceeded(self, cs_async):
+ """
+ If tiemout exceeded, break without throwing exception
+ """
+ event = asyncio.Event()
+ timeout = 0.5
+ start_time = time.monotonic()
+ await cs_async.event_wait(event, timeout=timeout)
+ end_time = time.monotonic()
+ assert abs((end_time - start_time) - timeout) < 0.01
+
+ @pytest.mark.parametrize("break_early", [True, False])
+ @pytest.mark.asyncio
+ async def test_event_wait_async_already_set(self, cs_async, break_early):
+ """
+ if event is already set, return immediately
+ """
+ event = AsyncMock()
+ event.is_set = lambda: True
+ start_time = time.monotonic()
+ await cs_async.event_wait(event, async_break_early=break_early)
+ end_time = time.monotonic()
+ assert abs(end_time - start_time) < 0.01
+
+ @pytest.mark.asyncio
+ async def test_event_wait_no_break_early(self, cs_async):
+ """
+ if async_break_early is False, and the event is not set,
+ simply sleep for the timeout
+ """
+ event = mock.Mock()
+ event.is_set.return_value = False
+ timeout = object()
+ with mock.patch.object(asyncio, "sleep", AsyncMock()) as sleep:
+ await cs_async.event_wait(event, timeout=timeout, async_break_early=False)
+ sleep.assert_called_once_with(timeout)
+
+ def test_create_task(self, cs_sync):
+ """
+ Test creating Future using create_task()
+ """
+ executor = concurrent.futures.ThreadPoolExecutor()
+ fn = lambda x, y: x + y # noqa: E731
+ result = cs_sync.create_task(fn, 1, y=4, sync_executor=executor)
+ assert isinstance(result, cs_sync.Task)
+ assert result.result() == 5
+
+ def test_create_task_passthrough(self, cs_sync):
+ """
+ sync version passed through to executor.submit()
+ """
+ fn = object()
+ executor = mock.Mock()
+ executor.submit.return_value = object()
+ args = [1, 2, 3]
+ kwargs = {"a": 1, "b": 2}
+ result = cs_sync.create_task(fn, *args, **kwargs, sync_executor=executor)
+ assert result == executor.submit.return_value
+ assert executor.submit.call_count == 1
+ assert executor.submit.call_args == ((fn, *args), kwargs)
+
+ def test_create_task_no_executor(self, cs_sync):
+ """
+ if no executor is provided, raise an exception
+ """
+ with pytest.raises(ValueError) as e:
+ cs_sync.create_task(lambda: None)
+ assert "sync_executor is required" in str(e.value)
+
+ @pytest.mark.asyncio
+ async def test_create_task_async(self, cs_async):
+ """
+ Test creating Future using create_task()
+ """
+
+ async def coro_fn(x, y):
+ return x + y
+
+ result = cs_async.create_task(coro_fn, 1, y=4)
+ assert isinstance(result, asyncio.Task)
+ assert await result == 5
+
+ @pytest.mark.asyncio
+ async def test_create_task_async_passthrough(self, cs_async):
+ """
+ async version passed through to asyncio.create_task()
+ """
+ coro_fn = mock.Mock()
+ coro_fn.return_value = object()
+ args = [1, 2, 3]
+ kwargs = {"a": 1, "b": 2}
+ with mock.patch.object(asyncio, "create_task", mock.Mock()) as create_task:
+ cs_async.create_task(coro_fn, *args, **kwargs)
+ create_task.assert_called_once()
+ create_task.assert_called_once_with(coro_fn.return_value)
+ coro_fn.assert_called_once_with(*args, **kwargs)
+
+ @pytest.mark.skipif(
+ sys.version_info < (3, 8), reason="Task names require python 3.8"
+ )
+ @pytest.mark.asyncio
+ async def test_create_task_async_with_name(self, cs_async):
+ """
+ Test creating a task with a name
+ """
+
+ async def coro_fn():
+ return None
+
+ name = "test-name-456"
+ result = cs_async.create_task(coro_fn, task_name=name)
+ assert isinstance(result, asyncio.Task)
+ assert result.get_name() == name
+
+ def test_yeild_to_event_loop(self, cs_sync):
+ """
+ no-op in sync version
+ """
+ assert cs_sync.yield_to_event_loop() is None
+
+ @pytest.mark.asyncio
+ async def test_yield_to_event_loop_async(self, cs_async):
+ """
+ should call await asyncio.sleep(0)
+ """
+ with mock.patch.object(asyncio, "sleep", AsyncMock()) as sleep:
+ await cs_async.yield_to_event_loop()
+ sleep.assert_called_once_with(0)
+
+ def test_verify_async_event_loop(self, cs_sync):
+ """
+ no-op in sync version
+ """
+ assert cs_sync.verify_async_event_loop() is None
+
+ @pytest.mark.asyncio
+ async def test_verify_async_event_loop_async(self, cs_async):
+ """
+ should call asyncio.get_running_loop()
+ """
+ with mock.patch.object(asyncio, "get_running_loop") as get_running_loop:
+ cs_async.verify_async_event_loop()
+ get_running_loop.assert_called_once()
+
+ def test_verify_async_event_loop_no_event_loop(self, cs_async):
+ """
+ Should raise an exception if no event loop is running
+ """
+ with pytest.raises(RuntimeError) as e:
+ cs_async.verify_async_event_loop()
+ assert "no running event loop" in str(e.value)
+
+ def test_rmaio(self, cs_async):
+ """
+ rm_aio should return whatever is passed to it
+ """
+ assert cs_async.rm_aio(1) == 1
+ assert cs_async.rm_aio("test") == "test"
+ obj = object()
+ assert cs_async.rm_aio(obj) == obj
+
+ def test_add_mapping(self, cs_sync, cs_async):
+ """
+ Add dynamic attributes to each class using add_mapping()
+ """
+ for cls in [cs_sync, cs_async]:
+ cls.add_mapping("test", 1)
+ assert cls.test == 1
+ assert cls._runtime_replacements[(cls, "test")] == 1
+
+ def test_add_duplicate_mapping(self, cs_sync, cs_async):
+ """
+ Adding the same attribute twice should raise an exception
+ """
+ for cls in [cs_sync, cs_async]:
+ cls.add_mapping("duplicate", 1)
+ with pytest.raises(AttributeError) as e:
+ cls.add_mapping("duplicate", 2)
+ assert "Conflicting assignments" in str(e.value)
+
+ def test_add_mapping_decorator(self, cs_sync, cs_async):
+ """
+ add_mapping_decorator should allow wrapping classes with add_mapping()
+ """
+ for cls in [cs_sync, cs_async]:
+
+ @cls.add_mapping_decorator("decorated")
+ class Decorated:
+ pass
+
+ assert cls.decorated == Decorated
diff --git a/tests/unit/data/_cross_sync/test_cross_sync_decorators.py b/tests/unit/data/_cross_sync/test_cross_sync_decorators.py
new file mode 100644
index 000000000..3be579379
--- /dev/null
+++ b/tests/unit/data/_cross_sync/test_cross_sync_decorators.py
@@ -0,0 +1,542 @@
+# Copyright 2024 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 pytest
+import pytest_asyncio
+import ast
+from unittest import mock
+from google.cloud.bigtable.data._cross_sync.cross_sync import CrossSync
+from google.cloud.bigtable.data._cross_sync._decorators import (
+ ConvertClass,
+ Convert,
+ Drop,
+ Pytest,
+ PytestFixture,
+)
+
+
+@pytest.fixture
+def globals_mock():
+ mock_transform = mock.Mock()
+ mock_transform().visit = lambda x: x
+ global_dict = {
+ k: mock_transform
+ for k in ["RmAioFunctions", "SymbolReplacer", "CrossSyncMethodDecoratorHandler"]
+ }
+ return global_dict
+
+
+class TestConvertClassDecorator:
+ def _get_class(self):
+ return ConvertClass
+
+ def test_ctor_defaults(self):
+ """
+ Should set default values for path, add_mapping_for_name, and docstring_format_vars
+ """
+ instance = self._get_class()()
+ assert instance.sync_name is None
+ assert instance.replace_symbols is None
+ assert instance.add_mapping_for_name is None
+ assert instance.async_docstring_format_vars == {}
+ assert instance.sync_docstring_format_vars == {}
+ assert instance.rm_aio is False
+
+ def test_ctor(self):
+ sync_name = "sync_name"
+ replace_symbols = {"a": "b"}
+ docstring_format_vars = {"A": (1, 2)}
+ add_mapping_for_name = "test_name"
+ rm_aio = True
+
+ instance = self._get_class()(
+ sync_name,
+ replace_symbols=replace_symbols,
+ docstring_format_vars=docstring_format_vars,
+ add_mapping_for_name=add_mapping_for_name,
+ rm_aio=rm_aio,
+ )
+ assert instance.sync_name is sync_name
+ assert instance.replace_symbols is replace_symbols
+ assert instance.add_mapping_for_name is add_mapping_for_name
+ assert instance.async_docstring_format_vars == {"A": 1}
+ assert instance.sync_docstring_format_vars == {"A": 2}
+ assert instance.rm_aio is rm_aio
+
+ def test_class_decorator(self):
+ """
+ Should return class being decorated
+ """
+ unwrapped_class = mock.Mock
+ wrapped_class = self._get_class().decorator(unwrapped_class, sync_name="s")
+ assert unwrapped_class == wrapped_class
+
+ def test_class_decorator_adds_mapping(self):
+ """
+ If add_mapping_for_name is set, should call CrossSync.add_mapping with the class being decorated
+ """
+ with mock.patch.object(CrossSync, "add_mapping") as add_mapping:
+ mock_cls = mock.Mock
+ # check decoration with no add_mapping
+ self._get_class().decorator(sync_name="s")(mock_cls)
+ assert add_mapping.call_count == 0
+ # check decoration with add_mapping
+ name = "test_name"
+ self._get_class().decorator(sync_name="s", add_mapping_for_name=name)(
+ mock_cls
+ )
+ assert add_mapping.call_count == 1
+ add_mapping.assert_called_once_with(name, mock_cls)
+
+ @pytest.mark.parametrize(
+ "docstring,format_vars,expected",
+ [
+ ["test docstring", {}, "test docstring"],
+ ["{}", {}, "{}"],
+ ["test_docstring", {"A": (1, 2)}, "test_docstring"],
+ ["{A}", {"A": (1, 2)}, "1"],
+ ["{A} {B}", {"A": (1, 2), "B": (3, 4)}, "1 3"],
+ ["hello {world_var}", {"world_var": ("world", "moon")}, "hello world"],
+ ["{empty}", {"empty": ("", "")}, ""],
+ ["{empty}", {"empty": (None, None)}, ""],
+ ["maybe{empty}", {"empty": (None, "yes")}, "maybe"],
+ ["maybe{empty}", {"empty": (" no", None)}, "maybe no"],
+ ],
+ )
+ def test_class_decorator_docstring_update(self, docstring, format_vars, expected):
+ """
+ If docstring_format_vars is set, should update the docstring
+ of the class being decorated
+ """
+
+ @ConvertClass.decorator(sync_name="s", docstring_format_vars=format_vars)
+ class Class:
+ __doc__ = docstring
+
+ assert Class.__doc__ == expected
+ # check internal state
+ instance = self._get_class()(sync_name="s", docstring_format_vars=format_vars)
+ async_replacements = {k: v[0] or "" for k, v in format_vars.items()}
+ sync_replacements = {k: v[1] or "" for k, v in format_vars.items()}
+ assert instance.async_docstring_format_vars == async_replacements
+ assert instance.sync_docstring_format_vars == sync_replacements
+
+ def test_sync_ast_transform_replaces_name(self, globals_mock):
+ """
+ Should update the name of the new class
+ """
+ decorator = self._get_class()("SyncClass")
+ mock_node = ast.ClassDef(name="AsyncClass", bases=[], keywords=[], body=[])
+
+ result = decorator.sync_ast_transform(mock_node, globals_mock)
+
+ assert isinstance(result, ast.ClassDef)
+ assert result.name == "SyncClass"
+
+ def test_sync_ast_transform_strips_cross_sync_decorators(self, globals_mock):
+ """
+ should remove all CrossSync decorators from the class
+ """
+ decorator = self._get_class()("path")
+ cross_sync_decorator = ast.Call(
+ func=ast.Attribute(
+ value=ast.Name(id="CrossSync", ctx=ast.Load()),
+ attr="some_decorator",
+ ctx=ast.Load(),
+ ),
+ args=[],
+ keywords=[],
+ )
+ other_decorator = ast.Name(id="other_decorator", ctx=ast.Load())
+ mock_node = ast.ClassDef(
+ name="AsyncClass",
+ bases=[],
+ keywords=[],
+ body=[],
+ decorator_list=[cross_sync_decorator, other_decorator],
+ )
+
+ result = decorator.sync_ast_transform(mock_node, globals_mock)
+
+ assert isinstance(result, ast.ClassDef)
+ assert len(result.decorator_list) == 1
+ assert isinstance(result.decorator_list[0], ast.Name)
+ assert result.decorator_list[0].id == "other_decorator"
+
+ def test_sync_ast_transform_add_mapping(self, globals_mock):
+ """
+ If add_mapping_for_name is set, should add CrossSync.add_mapping_decorator to new class
+ """
+ decorator = self._get_class()("path", add_mapping_for_name="sync_class")
+ mock_node = ast.ClassDef(name="AsyncClass", bases=[], keywords=[], body=[])
+
+ result = decorator.sync_ast_transform(mock_node, globals_mock)
+
+ assert isinstance(result, ast.ClassDef)
+ assert len(result.decorator_list) == 1
+ assert isinstance(result.decorator_list[0], ast.Call)
+ assert isinstance(result.decorator_list[0].func, ast.Attribute)
+ assert result.decorator_list[0].func.attr == "add_mapping_decorator"
+ assert result.decorator_list[0].args[0].value == "sync_class"
+
+ @pytest.mark.parametrize(
+ "docstring,format_vars,expected",
+ [
+ ["test docstring", {}, "test docstring"],
+ ["{}", {}, "{}"],
+ ["test_docstring", {"A": (1, 2)}, "test_docstring"],
+ ["{A}", {"A": (1, 2)}, "2"],
+ ["{A} {B}", {"A": (1, 2), "B": (3, 4)}, "2 4"],
+ ["hello {world_var}", {"world_var": ("world", "moon")}, "hello moon"],
+ ],
+ )
+ def test_sync_ast_transform_add_docstring_format(
+ self, docstring, format_vars, expected, globals_mock
+ ):
+ """
+ If docstring_format_vars is set, should format the docstring of the new class
+ """
+ decorator = self._get_class()(
+ "path.to.SyncClass", docstring_format_vars=format_vars
+ )
+ mock_node = ast.ClassDef(
+ name="AsyncClass",
+ bases=[],
+ keywords=[],
+ body=[ast.Expr(value=ast.Constant(value=docstring))],
+ )
+ result = decorator.sync_ast_transform(mock_node, globals_mock)
+
+ assert isinstance(result, ast.ClassDef)
+ assert isinstance(result.body[0], ast.Expr)
+ assert isinstance(result.body[0].value, ast.Constant)
+ assert result.body[0].value.value == expected
+
+ def test_sync_ast_transform_replace_symbols(self, globals_mock):
+ """
+ SymbolReplacer should be called with replace_symbols
+ """
+ replace_symbols = {"a": "b", "c": "d"}
+ decorator = self._get_class()(
+ "path.to.SyncClass", replace_symbols=replace_symbols
+ )
+ mock_node = ast.ClassDef(name="AsyncClass", bases=[], keywords=[], body=[])
+ symbol_transform_mock = mock.Mock()
+ globals_mock = {**globals_mock, "SymbolReplacer": symbol_transform_mock}
+ decorator.sync_ast_transform(mock_node, globals_mock)
+ # make sure SymbolReplacer was called with replace_symbols
+ assert symbol_transform_mock.call_count == 1
+ found_dict = symbol_transform_mock.call_args[0][0]
+ assert "a" in found_dict
+ for k, v in replace_symbols.items():
+ assert found_dict[k] == v
+
+ def test_sync_ast_transform_rmaio_calls_async_to_sync(self):
+ """
+ Should call AsyncToSync if rm_aio is set
+ """
+ decorator = self._get_class()(rm_aio=True)
+ mock_node = ast.ClassDef(name="AsyncClass", bases=[], keywords=[], body=[])
+ async_to_sync_mock = mock.Mock()
+ async_to_sync_mock.visit.side_effect = lambda x: x
+ globals_mock = {"AsyncToSync": lambda: async_to_sync_mock}
+
+ decorator.sync_ast_transform(mock_node, globals_mock)
+ assert async_to_sync_mock.visit.call_count == 1
+
+
+class TestConvertDecorator:
+ def _get_class(self):
+ return Convert
+
+ def test_ctor_defaults(self):
+ instance = self._get_class()()
+ assert instance.sync_name is None
+ assert instance.replace_symbols is None
+ assert instance.async_docstring_format_vars == {}
+ assert instance.sync_docstring_format_vars == {}
+ assert instance.rm_aio is True
+
+ def test_ctor(self):
+ sync_name = "sync_name"
+ replace_symbols = {"a": "b"}
+ docstring_format_vars = {"A": (1, 2)}
+ rm_aio = False
+
+ instance = self._get_class()(
+ sync_name=sync_name,
+ replace_symbols=replace_symbols,
+ docstring_format_vars=docstring_format_vars,
+ rm_aio=rm_aio,
+ )
+ assert instance.sync_name is sync_name
+ assert instance.replace_symbols is replace_symbols
+ assert instance.async_docstring_format_vars == {"A": 1}
+ assert instance.sync_docstring_format_vars == {"A": 2}
+ assert instance.rm_aio is rm_aio
+
+ def test_async_decorator_no_docstring(self):
+ """
+ If no docstring_format_vars is set, should be a no-op
+ """
+ unwrapped_class = mock.Mock
+ wrapped_class = self._get_class().decorator(unwrapped_class)
+ assert unwrapped_class == wrapped_class
+
+ @pytest.mark.parametrize(
+ "docstring,format_vars,expected",
+ [
+ ["test docstring", {}, "test docstring"],
+ ["{}", {}, "{}"],
+ ["test_docstring", {"A": (1, 2)}, "test_docstring"],
+ ["{A}", {"A": (1, 2)}, "1"],
+ ["{A} {B}", {"A": (1, 2), "B": (3, 4)}, "1 3"],
+ ["hello {world_var}", {"world_var": ("world", "moon")}, "hello world"],
+ ["{empty}", {"empty": ("", "")}, ""],
+ ["{empty}", {"empty": (None, None)}, ""],
+ ["maybe{empty}", {"empty": (None, "yes")}, "maybe"],
+ ["maybe{empty}", {"empty": (" no", None)}, "maybe no"],
+ ],
+ )
+ def test_async_decorator_docstring_update(self, docstring, format_vars, expected):
+ """
+ If docstring_format_vars is set, should update the docstring
+ of the class being decorated
+ """
+
+ @Convert.decorator(docstring_format_vars=format_vars)
+ class Class:
+ __doc__ = docstring
+
+ assert Class.__doc__ == expected
+ # check internal state
+ instance = self._get_class()(docstring_format_vars=format_vars)
+ async_replacements = {k: v[0] or "" for k, v in format_vars.items()}
+ sync_replacements = {k: v[1] or "" for k, v in format_vars.items()}
+ assert instance.async_docstring_format_vars == async_replacements
+ assert instance.sync_docstring_format_vars == sync_replacements
+
+ def test_sync_ast_transform_remove_adef(self):
+ """
+ Should convert `async def` methods to `def` methods
+ """
+ decorator = self._get_class()(rm_aio=False)
+ mock_node = ast.AsyncFunctionDef(
+ name="test_method", args=ast.arguments(), body=[]
+ )
+
+ result = decorator.sync_ast_transform(mock_node, {})
+
+ assert isinstance(result, ast.FunctionDef)
+ assert result.name == "test_method"
+
+ def test_sync_ast_transform_replaces_name(self, globals_mock):
+ """
+ Should update the name of the method if sync_name is set
+ """
+ decorator = self._get_class()(sync_name="new_method_name", rm_aio=False)
+ mock_node = ast.AsyncFunctionDef(
+ name="old_method_name", args=ast.arguments(), body=[]
+ )
+
+ result = decorator.sync_ast_transform(mock_node, globals_mock)
+
+ assert isinstance(result, ast.FunctionDef)
+ assert result.name == "new_method_name"
+
+ def test_sync_ast_transform_rmaio_calls_async_to_sync(self):
+ """
+ Should call AsyncToSync if rm_aio is set
+ """
+ decorator = self._get_class()(rm_aio=True)
+ mock_node = ast.AsyncFunctionDef(
+ name="test_method", args=ast.arguments(), body=[]
+ )
+ async_to_sync_mock = mock.Mock()
+ async_to_sync_mock.visit.return_value = mock_node
+ globals_mock = {"AsyncToSync": lambda: async_to_sync_mock}
+
+ decorator.sync_ast_transform(mock_node, globals_mock)
+ assert async_to_sync_mock.visit.call_count == 1
+
+ def test_sync_ast_transform_replace_symbols(self):
+ """
+ Should call SymbolReplacer with replace_symbols if replace_symbols is set
+ """
+ replace_symbols = {"old_symbol": "new_symbol"}
+ decorator = self._get_class()(replace_symbols=replace_symbols, rm_aio=False)
+ mock_node = ast.AsyncFunctionDef(
+ name="test_method", args=ast.arguments(), body=[]
+ )
+ symbol_replacer_mock = mock.Mock()
+ globals_mock = {"SymbolReplacer": symbol_replacer_mock}
+
+ decorator.sync_ast_transform(mock_node, globals_mock)
+
+ assert symbol_replacer_mock.call_count == 1
+ assert symbol_replacer_mock.call_args[0][0] == replace_symbols
+ assert symbol_replacer_mock(replace_symbols).visit.call_count == 1
+
+ @pytest.mark.parametrize(
+ "docstring,format_vars,expected",
+ [
+ ["test docstring", {}, "test docstring"],
+ ["{}", {}, "{}"],
+ ["test_docstring", {"A": (1, 2)}, "test_docstring"],
+ ["{A}", {"A": (1, 2)}, "2"],
+ ["{A} {B}", {"A": (1, 2), "B": (3, 4)}, "2 4"],
+ ["hello {world_var}", {"world_var": ("world", "moon")}, "hello moon"],
+ ],
+ )
+ def test_sync_ast_transform_add_docstring_format(
+ self, docstring, format_vars, expected
+ ):
+ """
+ If docstring_format_vars is set, should format the docstring of the new method
+ """
+ decorator = self._get_class()(docstring_format_vars=format_vars, rm_aio=False)
+ mock_node = ast.AsyncFunctionDef(
+ name="test_method",
+ args=ast.arguments(),
+ body=[ast.Expr(value=ast.Constant(value=docstring))],
+ )
+
+ result = decorator.sync_ast_transform(mock_node, {})
+
+ assert isinstance(result, ast.FunctionDef)
+ assert isinstance(result.body[0], ast.Expr)
+ assert isinstance(result.body[0].value, ast.Constant)
+ assert result.body[0].value.value == expected
+
+
+class TestDropDecorator:
+ def _get_class(self):
+ return Drop
+
+ def test_decorator_functionality(self):
+ """
+ applying the decorator should be a no-op
+ """
+ unwrapped = lambda x: x # noqa: E731
+ wrapped = self._get_class().decorator(unwrapped)
+ assert unwrapped == wrapped
+ assert unwrapped(1) == wrapped(1)
+ assert wrapped(1) == 1
+
+ def test_sync_ast_transform(self):
+ """
+ Should return None for any input method
+ """
+ decorator = self._get_class()()
+ mock_node = ast.AsyncFunctionDef(
+ name="test_method", args=ast.arguments(), body=[]
+ )
+
+ result = decorator.sync_ast_transform(mock_node, {})
+
+ assert result is None
+
+
+class TestPytestDecorator:
+ def _get_class(self):
+ return Pytest
+
+ def test_ctor(self):
+ instance = self._get_class()()
+ assert instance.rm_aio is True
+ instance = self._get_class()(rm_aio=False)
+ assert instance.rm_aio is False
+
+ def test_decorator_functionality(self):
+ """
+ Should wrap the class with pytest.mark.asyncio
+ """
+ unwrapped_fn = mock.Mock
+ wrapped_class = self._get_class().decorator(unwrapped_fn)
+ assert wrapped_class == pytest.mark.asyncio(unwrapped_fn)
+
+ def test_sync_ast_transform(self):
+ """
+ If rm_aio is True (default), should call AsyncToSync on the class
+ """
+ decorator = self._get_class()()
+ mock_node = ast.AsyncFunctionDef(
+ name="AsyncMethod", args=ast.arguments(), body=[]
+ )
+
+ async_to_sync_mock = mock.Mock()
+ async_to_sync_mock.visit.side_effect = lambda x: x
+ globals_mock = {"AsyncToSync": lambda: async_to_sync_mock}
+
+ transformed = decorator.sync_ast_transform(mock_node, globals_mock)
+ assert async_to_sync_mock.visit.call_count == 1
+ assert isinstance(transformed, ast.FunctionDef)
+
+ def test_sync_ast_transform_no_rm_aio(self):
+ """
+ if rm_aio is False, should remove the async keyword from the method
+ """
+ decorator = self._get_class()(rm_aio=False)
+ mock_node = ast.AsyncFunctionDef(
+ name="AsyncMethod", args=ast.arguments(), body=[]
+ )
+
+ async_to_sync_mock = mock.Mock()
+ async_to_sync_mock.visit.return_value = mock_node
+ globals_mock = {"AsyncToSync": lambda: async_to_sync_mock}
+
+ transformed = decorator.sync_ast_transform(mock_node, globals_mock)
+ assert async_to_sync_mock.visit.call_count == 0
+ assert isinstance(transformed, ast.FunctionDef)
+
+
+class TestPytestFixtureDecorator:
+ def _get_class(self):
+ return PytestFixture
+
+ def test_decorator_functionality(self):
+ """
+ Should wrap the class with pytest_asyncio.fixture
+ """
+ with mock.patch.object(pytest_asyncio, "fixture") as fixture:
+
+ @PytestFixture.decorator(1, 2, scope="function", params=[3, 4])
+ def fn():
+ pass
+
+ assert fixture.call_count == 1
+ assert fixture.call_args[0] == (1, 2)
+ assert fixture.call_args[1] == {"scope": "function", "params": [3, 4]}
+
+ def test_sync_ast_transform(self):
+ """
+ Should attach pytest.fixture to generated method
+ """
+ decorator = self._get_class()(1, 2, scope="function")
+
+ mock_node = ast.AsyncFunctionDef(
+ name="test_method", args=ast.arguments(), body=[]
+ )
+
+ result = decorator.sync_ast_transform(mock_node, {})
+
+ assert isinstance(result, ast.AsyncFunctionDef)
+ assert len(result.decorator_list) == 1
+ assert isinstance(result.decorator_list[0], ast.Call)
+ assert result.decorator_list[0].func.value.id == "pytest"
+ assert result.decorator_list[0].func.attr == "fixture"
+ assert result.decorator_list[0].args[0].value == 1
+ assert result.decorator_list[0].args[1].value == 2
+ assert result.decorator_list[0].keywords[0].arg == "scope"
+ assert result.decorator_list[0].keywords[0].value.value == "function"
diff --git a/tests/unit/data/_sync_autogen/__init__.py b/tests/unit/data/_sync_autogen/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/data/_sync_autogen/test__mutate_rows.py b/tests/unit/data/_sync_autogen/test__mutate_rows.py
new file mode 100644
index 000000000..2173c88fb
--- /dev/null
+++ b/tests/unit/data/_sync_autogen/test__mutate_rows.py
@@ -0,0 +1,307 @@
+# Copyright 2024 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.
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+import pytest
+from google.cloud.bigtable_v2.types import MutateRowsResponse
+from google.rpc import status_pb2
+from google.api_core.exceptions import DeadlineExceeded
+from google.api_core.exceptions import Forbidden
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+try:
+ from unittest import mock
+except ImportError:
+ import mock
+
+
+class TestMutateRowsOperation:
+ def _target_class(self):
+ return CrossSync._Sync_Impl._MutateRowsOperation
+
+ def _make_one(self, *args, **kwargs):
+ if not args:
+ kwargs["gapic_client"] = kwargs.pop("gapic_client", mock.Mock())
+ kwargs["table"] = kwargs.pop("table", CrossSync._Sync_Impl.Mock())
+ kwargs["operation_timeout"] = kwargs.pop("operation_timeout", 5)
+ kwargs["attempt_timeout"] = kwargs.pop("attempt_timeout", 0.1)
+ kwargs["retryable_exceptions"] = kwargs.pop("retryable_exceptions", ())
+ kwargs["mutation_entries"] = kwargs.pop("mutation_entries", [])
+ return self._target_class()(*args, **kwargs)
+
+ def _make_mutation(self, count=1, size=1):
+ mutation = mock.Mock()
+ mutation.size.return_value = size
+ mutation.mutations = [mock.Mock()] * count
+ return mutation
+
+ def _mock_stream(self, mutation_list, error_dict):
+ for idx, entry in enumerate(mutation_list):
+ code = error_dict.get(idx, 0)
+ yield MutateRowsResponse(
+ entries=[
+ MutateRowsResponse.Entry(
+ index=idx, status=status_pb2.Status(code=code)
+ )
+ ]
+ )
+
+ def _make_mock_gapic(self, mutation_list, error_dict=None):
+ mock_fn = CrossSync._Sync_Impl.Mock()
+ if error_dict is None:
+ error_dict = {}
+ mock_fn.side_effect = lambda *args, **kwargs: self._mock_stream(
+ mutation_list, error_dict
+ )
+ return mock_fn
+
+ def test_ctor(self):
+ """test that constructor sets all the attributes correctly"""
+ from google.cloud.bigtable.data._async._mutate_rows import _EntryWithProto
+ from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
+ from google.api_core.exceptions import DeadlineExceeded
+ from google.api_core.exceptions import Aborted
+
+ client = mock.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation(), self._make_mutation()]
+ operation_timeout = 0.05
+ attempt_timeout = 0.01
+ retryable_exceptions = ()
+ instance = self._make_one(
+ client,
+ table,
+ entries,
+ operation_timeout,
+ attempt_timeout,
+ retryable_exceptions,
+ )
+ assert client.mutate_rows.call_count == 0
+ instance._gapic_fn()
+ assert client.mutate_rows.call_count == 1
+ inner_kwargs = client.mutate_rows.call_args[1]
+ assert len(inner_kwargs) == 3
+ assert inner_kwargs["table_name"] == table.table_name
+ assert inner_kwargs["app_profile_id"] == table.app_profile_id
+ assert inner_kwargs["retry"] is None
+ entries_w_pb = [_EntryWithProto(e, e._to_pb()) for e in entries]
+ assert instance.mutations == entries_w_pb
+ assert next(instance.timeout_generator) == attempt_timeout
+ assert instance.is_retryable is not None
+ assert instance.is_retryable(DeadlineExceeded("")) is False
+ assert instance.is_retryable(Aborted("")) is False
+ assert instance.is_retryable(_MutateRowsIncomplete("")) is True
+ assert instance.is_retryable(RuntimeError("")) is False
+ assert instance.remaining_indices == list(range(len(entries)))
+ assert instance.errors == {}
+
+ def test_ctor_too_many_entries(self):
+ """should raise an error if an operation is created with more than 100,000 entries"""
+ from google.cloud.bigtable.data._async._mutate_rows import (
+ _MUTATE_ROWS_REQUEST_MUTATION_LIMIT,
+ )
+
+ assert _MUTATE_ROWS_REQUEST_MUTATION_LIMIT == 100000
+ client = mock.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation()] * (_MUTATE_ROWS_REQUEST_MUTATION_LIMIT + 1)
+ operation_timeout = 0.05
+ attempt_timeout = 0.01
+ with pytest.raises(ValueError) as e:
+ self._make_one(client, table, entries, operation_timeout, attempt_timeout)
+ assert "mutate_rows requests can contain at most 100000 mutations" in str(
+ e.value
+ )
+ assert "Found 100001" in str(e.value)
+
+ def test_mutate_rows_operation(self):
+ """Test successful case of mutate_rows_operation"""
+ client = mock.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation(), self._make_mutation()]
+ operation_timeout = 0.05
+ cls = self._target_class()
+ with mock.patch(
+ f"{cls.__module__}.{cls.__name__}._run_attempt", CrossSync._Sync_Impl.Mock()
+ ) as attempt_mock:
+ instance = self._make_one(
+ client, table, entries, operation_timeout, operation_timeout
+ )
+ instance.start()
+ assert attempt_mock.call_count == 1
+
+ @pytest.mark.parametrize("exc_type", [RuntimeError, ZeroDivisionError, Forbidden])
+ def test_mutate_rows_attempt_exception(self, exc_type):
+ """exceptions raised from attempt should be raised in MutationsExceptionGroup"""
+ client = CrossSync._Sync_Impl.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation(), self._make_mutation()]
+ operation_timeout = 0.05
+ expected_exception = exc_type("test")
+ client.mutate_rows.side_effect = expected_exception
+ found_exc = None
+ try:
+ instance = self._make_one(
+ client, table, entries, operation_timeout, operation_timeout
+ )
+ instance._run_attempt()
+ except Exception as e:
+ found_exc = e
+ assert client.mutate_rows.call_count == 1
+ assert type(found_exc) is exc_type
+ assert found_exc == expected_exception
+ assert len(instance.errors) == 2
+ assert len(instance.remaining_indices) == 0
+
+ @pytest.mark.parametrize("exc_type", [RuntimeError, ZeroDivisionError, Forbidden])
+ def test_mutate_rows_exception(self, exc_type):
+ """exceptions raised from retryable should be raised in MutationsExceptionGroup"""
+ from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+ from google.cloud.bigtable.data.exceptions import FailedMutationEntryError
+
+ client = mock.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation(), self._make_mutation()]
+ operation_timeout = 0.05
+ expected_cause = exc_type("abort")
+ with mock.patch.object(
+ self._target_class(), "_run_attempt", CrossSync._Sync_Impl.Mock()
+ ) as attempt_mock:
+ attempt_mock.side_effect = expected_cause
+ found_exc = None
+ try:
+ instance = self._make_one(
+ client, table, entries, operation_timeout, operation_timeout
+ )
+ instance.start()
+ except MutationsExceptionGroup as e:
+ found_exc = e
+ assert attempt_mock.call_count == 1
+ assert len(found_exc.exceptions) == 2
+ assert isinstance(found_exc.exceptions[0], FailedMutationEntryError)
+ assert isinstance(found_exc.exceptions[1], FailedMutationEntryError)
+ assert found_exc.exceptions[0].__cause__ == expected_cause
+ assert found_exc.exceptions[1].__cause__ == expected_cause
+
+ @pytest.mark.parametrize("exc_type", [DeadlineExceeded, RuntimeError])
+ def test_mutate_rows_exception_retryable_eventually_pass(self, exc_type):
+ """If an exception fails but eventually passes, it should not raise an exception"""
+ client = mock.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation()]
+ operation_timeout = 1
+ expected_cause = exc_type("retry")
+ num_retries = 2
+ with mock.patch.object(
+ self._target_class(), "_run_attempt", CrossSync._Sync_Impl.Mock()
+ ) as attempt_mock:
+ attempt_mock.side_effect = [expected_cause] * num_retries + [None]
+ instance = self._make_one(
+ client,
+ table,
+ entries,
+ operation_timeout,
+ operation_timeout,
+ retryable_exceptions=(exc_type,),
+ )
+ instance.start()
+ assert attempt_mock.call_count == num_retries + 1
+
+ def test_mutate_rows_incomplete_ignored(self):
+ """MutateRowsIncomplete exceptions should not be added to error list"""
+ from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
+ from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+ from google.api_core.exceptions import DeadlineExceeded
+
+ client = mock.Mock()
+ table = mock.Mock()
+ entries = [self._make_mutation()]
+ operation_timeout = 0.05
+ with mock.patch.object(
+ self._target_class(), "_run_attempt", CrossSync._Sync_Impl.Mock()
+ ) as attempt_mock:
+ attempt_mock.side_effect = _MutateRowsIncomplete("ignored")
+ found_exc = None
+ try:
+ instance = self._make_one(
+ client, table, entries, operation_timeout, operation_timeout
+ )
+ instance.start()
+ except MutationsExceptionGroup as e:
+ found_exc = e
+ assert attempt_mock.call_count > 0
+ assert len(found_exc.exceptions) == 1
+ assert isinstance(found_exc.exceptions[0].__cause__, DeadlineExceeded)
+
+ def test_run_attempt_single_entry_success(self):
+ """Test mutating a single entry"""
+ mutation = self._make_mutation()
+ expected_timeout = 1.3
+ mock_gapic_fn = self._make_mock_gapic({0: mutation})
+ instance = self._make_one(
+ mutation_entries=[mutation], attempt_timeout=expected_timeout
+ )
+ with mock.patch.object(instance, "_gapic_fn", mock_gapic_fn):
+ instance._run_attempt()
+ assert len(instance.remaining_indices) == 0
+ assert mock_gapic_fn.call_count == 1
+ (_, kwargs) = mock_gapic_fn.call_args
+ assert kwargs["timeout"] == expected_timeout
+ assert kwargs["entries"] == [mutation._to_pb()]
+
+ def test_run_attempt_empty_request(self):
+ """Calling with no mutations should result in no API calls"""
+ mock_gapic_fn = self._make_mock_gapic([])
+ instance = self._make_one(mutation_entries=[])
+ instance._run_attempt()
+ assert mock_gapic_fn.call_count == 0
+
+ def test_run_attempt_partial_success_retryable(self):
+ """Some entries succeed, but one fails. Should report the proper index, and raise incomplete exception"""
+ from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
+
+ success_mutation = self._make_mutation()
+ success_mutation_2 = self._make_mutation()
+ failure_mutation = self._make_mutation()
+ mutations = [success_mutation, failure_mutation, success_mutation_2]
+ mock_gapic_fn = self._make_mock_gapic(mutations, error_dict={1: 300})
+ instance = self._make_one(mutation_entries=mutations)
+ instance.is_retryable = lambda x: True
+ with mock.patch.object(instance, "_gapic_fn", mock_gapic_fn):
+ with pytest.raises(_MutateRowsIncomplete):
+ instance._run_attempt()
+ assert instance.remaining_indices == [1]
+ assert 0 not in instance.errors
+ assert len(instance.errors[1]) == 1
+ assert instance.errors[1][0].grpc_status_code == 300
+ assert 2 not in instance.errors
+
+ def test_run_attempt_partial_success_non_retryable(self):
+ """Some entries succeed, but one fails. Exception marked as non-retryable. Do not raise incomplete error"""
+ success_mutation = self._make_mutation()
+ success_mutation_2 = self._make_mutation()
+ failure_mutation = self._make_mutation()
+ mutations = [success_mutation, failure_mutation, success_mutation_2]
+ mock_gapic_fn = self._make_mock_gapic(mutations, error_dict={1: 300})
+ instance = self._make_one(mutation_entries=mutations)
+ instance.is_retryable = lambda x: False
+ with mock.patch.object(instance, "_gapic_fn", mock_gapic_fn):
+ instance._run_attempt()
+ assert instance.remaining_indices == []
+ assert 0 not in instance.errors
+ assert len(instance.errors[1]) == 1
+ assert instance.errors[1][0].grpc_status_code == 300
+ assert 2 not in instance.errors
diff --git a/tests/unit/data/_sync_autogen/test__read_rows.py b/tests/unit/data/_sync_autogen/test__read_rows.py
new file mode 100644
index 000000000..973b07bcb
--- /dev/null
+++ b/tests/unit/data/_sync_autogen/test__read_rows.py
@@ -0,0 +1,354 @@
+# Copyright 2024 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.
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+import pytest
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+try:
+ from unittest import mock
+except ImportError:
+ import mock
+
+
+class TestReadRowsOperation:
+ """
+ Tests helper functions in the ReadRowsOperation class
+ in-depth merging logic in merge_row_response_stream and _read_rows_retryable_attempt
+ is tested in test_read_rows_acceptance test_client_read_rows, and conformance tests
+ """
+
+ @staticmethod
+ def _get_target_class():
+ return CrossSync._Sync_Impl._ReadRowsOperation
+
+ def _make_one(self, *args, **kwargs):
+ return self._get_target_class()(*args, **kwargs)
+
+ def test_ctor(self):
+ from google.cloud.bigtable.data import ReadRowsQuery
+
+ row_limit = 91
+ query = ReadRowsQuery(limit=row_limit)
+ client = mock.Mock()
+ client.read_rows = mock.Mock()
+ client.read_rows.return_value = None
+ table = mock.Mock()
+ table._client = client
+ table.table_name = "test_table"
+ table.app_profile_id = "test_profile"
+ expected_operation_timeout = 42
+ expected_request_timeout = 44
+ time_gen_mock = mock.Mock()
+ subpath = "_async" if CrossSync._Sync_Impl.is_async else "_sync_autogen"
+ with mock.patch(
+ f"google.cloud.bigtable.data.{subpath}._read_rows._attempt_timeout_generator",
+ time_gen_mock,
+ ):
+ instance = self._make_one(
+ query,
+ table,
+ operation_timeout=expected_operation_timeout,
+ attempt_timeout=expected_request_timeout,
+ )
+ assert time_gen_mock.call_count == 1
+ time_gen_mock.assert_called_once_with(
+ expected_request_timeout, expected_operation_timeout
+ )
+ assert instance._last_yielded_row_key is None
+ assert instance._remaining_count == row_limit
+ assert instance.operation_timeout == expected_operation_timeout
+ assert client.read_rows.call_count == 0
+ assert instance.request.table_name == table.table_name
+ assert instance.request.app_profile_id == table.app_profile_id
+ assert instance.request.rows_limit == row_limit
+
+ @pytest.mark.parametrize(
+ "in_keys,last_key,expected",
+ [
+ (["b", "c", "d"], "a", ["b", "c", "d"]),
+ (["a", "b", "c"], "b", ["c"]),
+ (["a", "b", "c"], "c", []),
+ (["a", "b", "c"], "d", []),
+ (["d", "c", "b", "a"], "b", ["d", "c"]),
+ ],
+ )
+ @pytest.mark.parametrize("with_range", [True, False])
+ def test_revise_request_rowset_keys_with_range(
+ self, in_keys, last_key, expected, with_range
+ ):
+ from google.cloud.bigtable_v2.types import RowSet as RowSetPB
+ from google.cloud.bigtable_v2.types import RowRange as RowRangePB
+ from google.cloud.bigtable.data.exceptions import _RowSetComplete
+
+ in_keys = [key.encode("utf-8") for key in in_keys]
+ expected = [key.encode("utf-8") for key in expected]
+ last_key = last_key.encode("utf-8")
+ if with_range:
+ sample_range = [RowRangePB(start_key_open=last_key)]
+ else:
+ sample_range = []
+ row_set = RowSetPB(row_keys=in_keys, row_ranges=sample_range)
+ if not with_range and expected == []:
+ with pytest.raises(_RowSetComplete):
+ self._get_target_class()._revise_request_rowset(row_set, last_key)
+ else:
+ revised = self._get_target_class()._revise_request_rowset(row_set, last_key)
+ assert revised.row_keys == expected
+ assert revised.row_ranges == sample_range
+
+ @pytest.mark.parametrize(
+ "in_ranges,last_key,expected",
+ [
+ (
+ [{"start_key_open": "b", "end_key_closed": "d"}],
+ "a",
+ [{"start_key_open": "b", "end_key_closed": "d"}],
+ ),
+ (
+ [{"start_key_closed": "b", "end_key_closed": "d"}],
+ "a",
+ [{"start_key_closed": "b", "end_key_closed": "d"}],
+ ),
+ (
+ [{"start_key_open": "a", "end_key_closed": "d"}],
+ "b",
+ [{"start_key_open": "b", "end_key_closed": "d"}],
+ ),
+ (
+ [{"start_key_closed": "a", "end_key_open": "d"}],
+ "b",
+ [{"start_key_open": "b", "end_key_open": "d"}],
+ ),
+ (
+ [{"start_key_closed": "b", "end_key_closed": "d"}],
+ "b",
+ [{"start_key_open": "b", "end_key_closed": "d"}],
+ ),
+ ([{"start_key_closed": "b", "end_key_closed": "d"}], "d", []),
+ ([{"start_key_closed": "b", "end_key_open": "d"}], "d", []),
+ ([{"start_key_closed": "b", "end_key_closed": "d"}], "e", []),
+ ([{"start_key_closed": "b"}], "z", [{"start_key_open": "z"}]),
+ ([{"start_key_closed": "b"}], "a", [{"start_key_closed": "b"}]),
+ (
+ [{"end_key_closed": "z"}],
+ "a",
+ [{"start_key_open": "a", "end_key_closed": "z"}],
+ ),
+ (
+ [{"end_key_open": "z"}],
+ "a",
+ [{"start_key_open": "a", "end_key_open": "z"}],
+ ),
+ ],
+ )
+ @pytest.mark.parametrize("with_key", [True, False])
+ def test_revise_request_rowset_ranges(
+ self, in_ranges, last_key, expected, with_key
+ ):
+ from google.cloud.bigtable_v2.types import RowSet as RowSetPB
+ from google.cloud.bigtable_v2.types import RowRange as RowRangePB
+ from google.cloud.bigtable.data.exceptions import _RowSetComplete
+
+ next_key = (last_key + "a").encode("utf-8")
+ last_key = last_key.encode("utf-8")
+ in_ranges = [
+ RowRangePB(**{k: v.encode("utf-8") for (k, v) in r.items()})
+ for r in in_ranges
+ ]
+ expected = [
+ RowRangePB(**{k: v.encode("utf-8") for (k, v) in r.items()})
+ for r in expected
+ ]
+ if with_key:
+ row_keys = [next_key]
+ else:
+ row_keys = []
+ row_set = RowSetPB(row_ranges=in_ranges, row_keys=row_keys)
+ if not with_key and expected == []:
+ with pytest.raises(_RowSetComplete):
+ self._get_target_class()._revise_request_rowset(row_set, last_key)
+ else:
+ revised = self._get_target_class()._revise_request_rowset(row_set, last_key)
+ assert revised.row_keys == row_keys
+ assert revised.row_ranges == expected
+
+ @pytest.mark.parametrize("last_key", ["a", "b", "c"])
+ def test_revise_request_full_table(self, last_key):
+ from google.cloud.bigtable_v2.types import RowSet as RowSetPB
+ from google.cloud.bigtable_v2.types import RowRange as RowRangePB
+
+ last_key = last_key.encode("utf-8")
+ row_set = RowSetPB()
+ for selected_set in [row_set, None]:
+ revised = self._get_target_class()._revise_request_rowset(
+ selected_set, last_key
+ )
+ assert revised.row_keys == []
+ assert len(revised.row_ranges) == 1
+ assert revised.row_ranges[0] == RowRangePB(start_key_open=last_key)
+
+ def test_revise_to_empty_rowset(self):
+ """revising to an empty rowset should raise error"""
+ from google.cloud.bigtable.data.exceptions import _RowSetComplete
+ from google.cloud.bigtable_v2.types import RowSet as RowSetPB
+ from google.cloud.bigtable_v2.types import RowRange as RowRangePB
+
+ row_keys = [b"a", b"b", b"c"]
+ row_range = RowRangePB(end_key_open=b"c")
+ row_set = RowSetPB(row_keys=row_keys, row_ranges=[row_range])
+ with pytest.raises(_RowSetComplete):
+ self._get_target_class()._revise_request_rowset(row_set, b"d")
+
+ @pytest.mark.parametrize(
+ "start_limit,emit_num,expected_limit",
+ [
+ (10, 0, 10),
+ (10, 1, 9),
+ (10, 10, 0),
+ (None, 10, None),
+ (None, 0, None),
+ (4, 2, 2),
+ ],
+ )
+ def test_revise_limit(self, start_limit, emit_num, expected_limit):
+ """revise_limit should revise the request's limit field
+ - if limit is 0 (unlimited), it should never be revised
+ - if start_limit-emit_num == 0, the request should end early
+ - if the number emitted exceeds the new limit, an exception should
+ should be raised (tested in test_revise_limit_over_limit)"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+ from google.cloud.bigtable_v2.types import ReadRowsResponse
+
+ def awaitable_stream():
+ def mock_stream():
+ for i in range(emit_num):
+ yield ReadRowsResponse(
+ chunks=[
+ ReadRowsResponse.CellChunk(
+ row_key=str(i).encode(),
+ family_name="b",
+ qualifier=b"c",
+ value=b"d",
+ commit_row=True,
+ )
+ ]
+ )
+
+ return mock_stream()
+
+ query = ReadRowsQuery(limit=start_limit)
+ table = mock.Mock()
+ table.table_name = "table_name"
+ table.app_profile_id = "app_profile_id"
+ instance = self._make_one(query, table, 10, 10)
+ assert instance._remaining_count == start_limit
+ for val in instance.chunk_stream(awaitable_stream()):
+ pass
+ assert instance._remaining_count == expected_limit
+
+ @pytest.mark.parametrize("start_limit,emit_num", [(5, 10), (3, 9), (1, 10)])
+ def test_revise_limit_over_limit(self, start_limit, emit_num):
+ """Should raise runtime error if we get in state where emit_num > start_num
+ (unless start_num == 0, which represents unlimited)"""
+ from google.cloud.bigtable.data import ReadRowsQuery
+ from google.cloud.bigtable_v2.types import ReadRowsResponse
+ from google.cloud.bigtable.data.exceptions import InvalidChunk
+
+ def awaitable_stream():
+ def mock_stream():
+ for i in range(emit_num):
+ yield ReadRowsResponse(
+ chunks=[
+ ReadRowsResponse.CellChunk(
+ row_key=str(i).encode(),
+ family_name="b",
+ qualifier=b"c",
+ value=b"d",
+ commit_row=True,
+ )
+ ]
+ )
+
+ return mock_stream()
+
+ query = ReadRowsQuery(limit=start_limit)
+ table = mock.Mock()
+ table.table_name = "table_name"
+ table.app_profile_id = "app_profile_id"
+ instance = self._make_one(query, table, 10, 10)
+ assert instance._remaining_count == start_limit
+ with pytest.raises(InvalidChunk) as e:
+ for val in instance.chunk_stream(awaitable_stream()):
+ pass
+ assert "emit count exceeds row limit" in str(e.value)
+
+ def test_close(self):
+ """should be able to close a stream safely with close.
+ Closed generators should raise StopAsyncIteration on next yield"""
+
+ def mock_stream():
+ while True:
+ yield 1
+
+ with mock.patch.object(
+ self._get_target_class(), "_read_rows_attempt"
+ ) as mock_attempt:
+ instance = self._make_one(mock.Mock(), mock.Mock(), 1, 1)
+ wrapped_gen = mock_stream()
+ mock_attempt.return_value = wrapped_gen
+ gen = instance.start_operation()
+ gen.__next__()
+ gen.close()
+ with pytest.raises(CrossSync._Sync_Impl.StopIteration):
+ gen.__next__()
+ gen.close()
+ with pytest.raises(CrossSync._Sync_Impl.StopIteration):
+ wrapped_gen.__next__()
+
+ def test_retryable_ignore_repeated_rows(self):
+ """Duplicate rows should cause an invalid chunk error"""
+ from google.cloud.bigtable.data.exceptions import InvalidChunk
+ from google.cloud.bigtable_v2.types import ReadRowsResponse
+
+ row_key = b"duplicate"
+
+ def mock_awaitable_stream():
+ def mock_stream():
+ while True:
+ yield ReadRowsResponse(
+ chunks=[
+ ReadRowsResponse.CellChunk(row_key=row_key, commit_row=True)
+ ]
+ )
+ yield ReadRowsResponse(
+ chunks=[
+ ReadRowsResponse.CellChunk(row_key=row_key, commit_row=True)
+ ]
+ )
+
+ return mock_stream()
+
+ instance = mock.Mock()
+ instance._last_yielded_row_key = None
+ instance._remaining_count = None
+ stream = self._get_target_class().chunk_stream(
+ instance, mock_awaitable_stream()
+ )
+ stream.__next__()
+ with pytest.raises(InvalidChunk) as exc:
+ stream.__next__()
+ assert "row keys should be strictly increasing" in str(exc.value)
diff --git a/tests/unit/data/_sync_autogen/test_client.py b/tests/unit/data/_sync_autogen/test_client.py
new file mode 100644
index 000000000..51c88c63e
--- /dev/null
+++ b/tests/unit/data/_sync_autogen/test_client.py
@@ -0,0 +1,2889 @@
+# Copyright 2024 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.
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+import grpc
+import asyncio
+import re
+import pytest
+import mock
+from google.cloud.bigtable.data import mutations
+from google.auth.credentials import AnonymousCredentials
+from google.cloud.bigtable_v2.types import ReadRowsResponse
+from google.cloud.bigtable.data.read_rows_query import ReadRowsQuery
+from google.api_core import exceptions as core_exceptions
+from google.cloud.bigtable.data.exceptions import InvalidChunk
+from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
+from google.cloud.bigtable.data import TABLE_DEFAULT
+from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+from google.cloud.bigtable.data.read_modify_write_rules import AppendValueRule
+from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
+from google.cloud.bigtable.data._cross_sync import CrossSync
+from google.api_core import grpc_helpers
+
+CrossSync._Sync_Impl.add_mapping("grpc_helpers", grpc_helpers)
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("TestBigtableDataClient")
+class TestBigtableDataClient:
+ @staticmethod
+ def _get_target_class():
+ return CrossSync._Sync_Impl.DataClient
+
+ @classmethod
+ def _make_client(cls, *args, use_emulator=True, **kwargs):
+ import os
+
+ env_mask = {}
+ if use_emulator:
+ env_mask["BIGTABLE_EMULATOR_HOST"] = "localhost"
+ import warnings
+
+ warnings.filterwarnings("ignore", category=RuntimeWarning)
+ else:
+ kwargs["credentials"] = kwargs.get("credentials", AnonymousCredentials())
+ kwargs["project"] = kwargs.get("project", "project-id")
+ with mock.patch.dict(os.environ, env_mask):
+ return cls._get_target_class()(*args, **kwargs)
+
+ def test_ctor(self):
+ expected_project = "project-id"
+ expected_credentials = AnonymousCredentials()
+ client = self._make_client(
+ project="project-id", credentials=expected_credentials, use_emulator=False
+ )
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert client.project == expected_project
+ assert not client._active_instances
+ assert client._channel_refresh_task is not None
+ assert client.transport._credentials == expected_credentials
+ client.close()
+
+ def test_ctor_super_inits(self):
+ from google.cloud.client import ClientWithProject
+ from google.api_core import client_options as client_options_lib
+
+ project = "project-id"
+ credentials = AnonymousCredentials()
+ client_options = {"api_endpoint": "foo.bar:1234"}
+ options_parsed = client_options_lib.from_dict(client_options)
+ with mock.patch.object(
+ CrossSync._Sync_Impl.GapicClient, "__init__"
+ ) as bigtable_client_init:
+ bigtable_client_init.return_value = None
+ with mock.patch.object(
+ ClientWithProject, "__init__"
+ ) as client_project_init:
+ client_project_init.return_value = None
+ try:
+ self._make_client(
+ project=project,
+ credentials=credentials,
+ client_options=options_parsed,
+ use_emulator=False,
+ )
+ except AttributeError:
+ pass
+ assert bigtable_client_init.call_count == 1
+ kwargs = bigtable_client_init.call_args[1]
+ assert kwargs["credentials"] == credentials
+ assert kwargs["client_options"] == options_parsed
+ assert client_project_init.call_count == 1
+ kwargs = client_project_init.call_args[1]
+ assert kwargs["project"] == project
+ assert kwargs["credentials"] == credentials
+ assert kwargs["client_options"] == options_parsed
+
+ def test_ctor_dict_options(self):
+ from google.api_core.client_options import ClientOptions
+
+ client_options = {"api_endpoint": "foo.bar:1234"}
+ with mock.patch.object(
+ CrossSync._Sync_Impl.GapicClient, "__init__"
+ ) as bigtable_client_init:
+ try:
+ self._make_client(client_options=client_options)
+ except TypeError:
+ pass
+ bigtable_client_init.assert_called_once()
+ kwargs = bigtable_client_init.call_args[1]
+ called_options = kwargs["client_options"]
+ assert called_options.api_endpoint == "foo.bar:1234"
+ assert isinstance(called_options, ClientOptions)
+ with mock.patch.object(
+ self._get_target_class(), "_start_background_channel_refresh"
+ ) as start_background_refresh:
+ client = self._make_client(
+ client_options=client_options, use_emulator=False
+ )
+ start_background_refresh.assert_called_once()
+ client.close()
+
+ def test_veneer_grpc_headers(self):
+ client_component = "data-async" if CrossSync._Sync_Impl.is_async else "data"
+ VENEER_HEADER_REGEX = re.compile(
+ "gapic\\/[0-9]+\\.[\\w.-]+ gax\\/[0-9]+\\.[\\w.-]+ gccl\\/[0-9]+\\.[\\w.-]+-"
+ + client_component
+ + " gl-python\\/[0-9]+\\.[\\w.-]+ grpc\\/[0-9]+\\.[\\w.-]+"
+ )
+ patch = mock.patch("google.api_core.gapic_v1.method.wrap_method")
+ with patch as gapic_mock:
+ client = self._make_client(project="project-id")
+ wrapped_call_list = gapic_mock.call_args_list
+ assert len(wrapped_call_list) > 0
+ for call in wrapped_call_list:
+ client_info = call.kwargs["client_info"]
+ assert client_info is not None, f"{call} has no client_info"
+ wrapped_user_agent_sorted = " ".join(
+ sorted(client_info.to_user_agent().split(" "))
+ )
+ assert VENEER_HEADER_REGEX.match(
+ wrapped_user_agent_sorted
+ ), f"'{wrapped_user_agent_sorted}' does not match {VENEER_HEADER_REGEX}"
+ client.close()
+
+ def test__start_background_channel_refresh_task_exists(self):
+ client = self._make_client(project="project-id", use_emulator=False)
+ assert client._channel_refresh_task is not None
+ with mock.patch.object(asyncio, "create_task") as create_task:
+ client._start_background_channel_refresh()
+ create_task.assert_not_called()
+ client.close()
+
+ def test__start_background_channel_refresh(self):
+ client = self._make_client(project="project-id")
+ with mock.patch.object(
+ client, "_ping_and_warm_instances", CrossSync._Sync_Impl.Mock()
+ ) as ping_and_warm:
+ client._emulator_host = None
+ client._start_background_channel_refresh()
+ assert client._channel_refresh_task is not None
+ assert isinstance(client._channel_refresh_task, CrossSync._Sync_Impl.Task)
+ CrossSync._Sync_Impl.sleep(0.1)
+ assert ping_and_warm.call_count == 1
+ client.close()
+
+ def test__ping_and_warm_instances(self):
+ """test ping and warm with mocked asyncio.gather"""
+ client_mock = mock.Mock()
+ client_mock._execute_ping_and_warms = (
+ lambda *args: self._get_target_class()._execute_ping_and_warms(
+ client_mock, *args
+ )
+ )
+ with mock.patch.object(
+ CrossSync._Sync_Impl, "gather_partials", CrossSync._Sync_Impl.Mock()
+ ) as gather:
+ gather.side_effect = lambda partials, **kwargs: [None for _ in partials]
+ channel = mock.Mock()
+ client_mock._active_instances = []
+ result = self._get_target_class()._ping_and_warm_instances(
+ client_mock, channel=channel
+ )
+ assert len(result) == 0
+ assert gather.call_args[1]["return_exceptions"] is True
+ assert gather.call_args[1]["sync_executor"] == client_mock._executor
+ client_mock._active_instances = [
+ (mock.Mock(), mock.Mock(), mock.Mock())
+ ] * 4
+ gather.reset_mock()
+ channel.reset_mock()
+ result = self._get_target_class()._ping_and_warm_instances(
+ client_mock, channel=channel
+ )
+ assert len(result) == 4
+ gather.assert_called_once()
+ partial_list = gather.call_args.args[0]
+ assert len(partial_list) == 4
+ grpc_call_args = channel.unary_unary().call_args_list
+ for idx, (_, kwargs) in enumerate(grpc_call_args):
+ (
+ expected_instance,
+ expected_table,
+ expected_app_profile,
+ ) = client_mock._active_instances[idx]
+ request = kwargs["request"]
+ assert request["name"] == expected_instance
+ assert request["app_profile_id"] == expected_app_profile
+ metadata = kwargs["metadata"]
+ assert len(metadata) == 1
+ assert metadata[0][0] == "x-goog-request-params"
+ assert (
+ metadata[0][1]
+ == f"name={expected_instance}&app_profile_id={expected_app_profile}"
+ )
+
+ def test__ping_and_warm_single_instance(self):
+ """should be able to call ping and warm with single instance"""
+ client_mock = mock.Mock()
+ client_mock._execute_ping_and_warms = (
+ lambda *args: self._get_target_class()._execute_ping_and_warms(
+ client_mock, *args
+ )
+ )
+ with mock.patch.object(
+ CrossSync._Sync_Impl, "gather_partials", CrossSync._Sync_Impl.Mock()
+ ) as gather:
+ gather.side_effect = lambda *args, **kwargs: [fn() for fn in args[0]]
+ client_mock._active_instances = [mock.Mock()] * 100
+ test_key = ("test-instance", "test-table", "test-app-profile")
+ result = self._get_target_class()._ping_and_warm_instances(
+ client_mock, test_key
+ )
+ assert len(result) == 1
+ grpc_call_args = (
+ client_mock.transport.grpc_channel.unary_unary().call_args_list
+ )
+ assert len(grpc_call_args) == 1
+ kwargs = grpc_call_args[0][1]
+ request = kwargs["request"]
+ assert request["name"] == "test-instance"
+ assert request["app_profile_id"] == "test-app-profile"
+ metadata = kwargs["metadata"]
+ assert len(metadata) == 1
+ assert metadata[0][0] == "x-goog-request-params"
+ assert (
+ metadata[0][1] == "name=test-instance&app_profile_id=test-app-profile"
+ )
+
+ @pytest.mark.parametrize(
+ "refresh_interval, wait_time, expected_sleep",
+ [(0, 0, 0), (0, 1, 0), (10, 0, 10), (10, 5, 5), (10, 10, 0), (10, 15, 0)],
+ )
+ def test__manage_channel_first_sleep(
+ self, refresh_interval, wait_time, expected_sleep
+ ):
+ import time
+
+ with mock.patch.object(time, "monotonic") as monotonic:
+ monotonic.return_value = 0
+ with mock.patch.object(CrossSync._Sync_Impl, "event_wait") as sleep:
+ sleep.side_effect = asyncio.CancelledError
+ try:
+ client = self._make_client(project="project-id")
+ client._channel_init_time = -wait_time
+ client._manage_channel(refresh_interval, refresh_interval)
+ except asyncio.CancelledError:
+ pass
+ sleep.assert_called_once()
+ call_time = sleep.call_args[0][1]
+ assert (
+ abs(call_time - expected_sleep) < 0.1
+ ), f"refresh_interval: {refresh_interval}, wait_time: {wait_time}, expected_sleep: {expected_sleep}"
+ client.close()
+
+ def test__manage_channel_ping_and_warm(self):
+ """_manage channel should call ping and warm internally"""
+ import time
+ import threading
+
+ client_mock = mock.Mock()
+ client_mock._is_closed.is_set.return_value = False
+ client_mock._channel_init_time = time.monotonic()
+ orig_channel = client_mock.transport.grpc_channel
+ sleep_tuple = (
+ (asyncio, "sleep")
+ if CrossSync._Sync_Impl.is_async
+ else (threading.Event, "wait")
+ )
+ with mock.patch.object(*sleep_tuple):
+ orig_channel.close.side_effect = asyncio.CancelledError
+ ping_and_warm = (
+ client_mock._ping_and_warm_instances
+ ) = CrossSync._Sync_Impl.Mock()
+ try:
+ self._get_target_class()._manage_channel(client_mock, 10)
+ except asyncio.CancelledError:
+ pass
+ assert ping_and_warm.call_count == 2
+ assert client_mock.transport._grpc_channel != orig_channel
+ called_with = [call[1]["channel"] for call in ping_and_warm.call_args_list]
+ assert orig_channel in called_with
+ assert client_mock.transport.grpc_channel in called_with
+
+ @pytest.mark.parametrize(
+ "refresh_interval, num_cycles, expected_sleep",
+ [(None, 1, 60 * 35), (10, 10, 100), (10, 1, 10)],
+ )
+ def test__manage_channel_sleeps(self, refresh_interval, num_cycles, expected_sleep):
+ import time
+ import random
+
+ channel = mock.Mock()
+ channel.close = CrossSync._Sync_Impl.Mock()
+ with mock.patch.object(random, "uniform") as uniform:
+ uniform.side_effect = lambda min_, max_: min_
+ with mock.patch.object(time, "time") as time_mock:
+ time_mock.return_value = 0
+ with mock.patch.object(CrossSync._Sync_Impl, "event_wait") as sleep:
+ sleep.side_effect = [None for i in range(num_cycles - 1)] + [
+ asyncio.CancelledError
+ ]
+ client = self._make_client(project="project-id")
+ client.transport._grpc_channel = channel
+ with mock.patch.object(
+ client.transport, "create_channel", CrossSync._Sync_Impl.Mock
+ ):
+ try:
+ if refresh_interval is not None:
+ client._manage_channel(
+ refresh_interval, refresh_interval, grace_period=0
+ )
+ else:
+ client._manage_channel(grace_period=0)
+ except asyncio.CancelledError:
+ pass
+ assert sleep.call_count == num_cycles
+ total_sleep = sum([call[0][1] for call in sleep.call_args_list])
+ assert (
+ abs(total_sleep - expected_sleep) < 0.1
+ ), f"refresh_interval={refresh_interval}, num_cycles={num_cycles}, expected_sleep={expected_sleep}"
+ client.close()
+
+ def test__manage_channel_random(self):
+ import random
+
+ with mock.patch.object(CrossSync._Sync_Impl, "event_wait") as sleep:
+ with mock.patch.object(random, "uniform") as uniform:
+ uniform.return_value = 0
+ try:
+ uniform.side_effect = asyncio.CancelledError
+ client = self._make_client(project="project-id")
+ except asyncio.CancelledError:
+ uniform.side_effect = None
+ uniform.reset_mock()
+ sleep.reset_mock()
+ with mock.patch.object(client.transport, "create_channel"):
+ min_val = 200
+ max_val = 205
+ uniform.side_effect = lambda min_, max_: min_
+ sleep.side_effect = [None, asyncio.CancelledError]
+ try:
+ client._manage_channel(min_val, max_val, grace_period=0)
+ except asyncio.CancelledError:
+ pass
+ assert uniform.call_count == 2
+ uniform_args = [call[0] for call in uniform.call_args_list]
+ for found_min, found_max in uniform_args:
+ assert found_min == min_val
+ assert found_max == max_val
+
+ @pytest.mark.parametrize("num_cycles", [0, 1, 10, 100])
+ def test__manage_channel_refresh(self, num_cycles):
+ expected_refresh = 0.5
+ grpc_lib = grpc.aio if CrossSync._Sync_Impl.is_async else grpc
+ new_channel = grpc_lib.insecure_channel("localhost:8080")
+ with mock.patch.object(CrossSync._Sync_Impl, "event_wait") as sleep:
+ sleep.side_effect = [None for i in range(num_cycles)] + [RuntimeError]
+ with mock.patch.object(
+ CrossSync._Sync_Impl.grpc_helpers, "create_channel"
+ ) as create_channel:
+ create_channel.return_value = new_channel
+ client = self._make_client(project="project-id")
+ create_channel.reset_mock()
+ try:
+ client._manage_channel(
+ refresh_interval_min=expected_refresh,
+ refresh_interval_max=expected_refresh,
+ grace_period=0,
+ )
+ except RuntimeError:
+ pass
+ assert sleep.call_count == num_cycles + 1
+ assert create_channel.call_count == num_cycles
+ client.close()
+
+ def test__register_instance(self):
+ """test instance registration"""
+ client_mock = mock.Mock()
+ client_mock._gapic_client.instance_path.side_effect = lambda a, b: f"prefix/{b}"
+ active_instances = set()
+ instance_owners = {}
+ client_mock._active_instances = active_instances
+ client_mock._instance_owners = instance_owners
+ client_mock._channel_refresh_task = None
+ client_mock._ping_and_warm_instances = CrossSync._Sync_Impl.Mock()
+ table_mock = mock.Mock()
+ self._get_target_class()._register_instance(
+ client_mock, "instance-1", table_mock
+ )
+ assert client_mock._start_background_channel_refresh.call_count == 1
+ expected_key = (
+ "prefix/instance-1",
+ table_mock.table_name,
+ table_mock.app_profile_id,
+ )
+ assert len(active_instances) == 1
+ assert expected_key == tuple(list(active_instances)[0])
+ assert len(instance_owners) == 1
+ assert expected_key == tuple(list(instance_owners)[0])
+ client_mock._channel_refresh_task = mock.Mock()
+ table_mock2 = mock.Mock()
+ self._get_target_class()._register_instance(
+ client_mock, "instance-2", table_mock2
+ )
+ assert client_mock._start_background_channel_refresh.call_count == 1
+ assert (
+ client_mock._ping_and_warm_instances.call_args[0][0][0]
+ == "prefix/instance-2"
+ )
+ assert client_mock._ping_and_warm_instances.call_count == 1
+ assert len(active_instances) == 2
+ assert len(instance_owners) == 2
+ expected_key2 = (
+ "prefix/instance-2",
+ table_mock2.table_name,
+ table_mock2.app_profile_id,
+ )
+ assert any(
+ [
+ expected_key2 == tuple(list(active_instances)[i])
+ for i in range(len(active_instances))
+ ]
+ )
+ assert any(
+ [
+ expected_key2 == tuple(list(instance_owners)[i])
+ for i in range(len(instance_owners))
+ ]
+ )
+
+ def test__register_instance_duplicate(self):
+ """test double instance registration. Should be no-op"""
+ client_mock = mock.Mock()
+ client_mock._gapic_client.instance_path.side_effect = lambda a, b: f"prefix/{b}"
+ active_instances = set()
+ instance_owners = {}
+ client_mock._active_instances = active_instances
+ client_mock._instance_owners = instance_owners
+ client_mock._channel_refresh_task = object()
+ mock_channels = [mock.Mock()]
+ client_mock.transport.channels = mock_channels
+ client_mock._ping_and_warm_instances = CrossSync._Sync_Impl.Mock()
+ table_mock = mock.Mock()
+ expected_key = (
+ "prefix/instance-1",
+ table_mock.table_name,
+ table_mock.app_profile_id,
+ )
+ self._get_target_class()._register_instance(
+ client_mock, "instance-1", table_mock
+ )
+ assert len(active_instances) == 1
+ assert expected_key == tuple(list(active_instances)[0])
+ assert len(instance_owners) == 1
+ assert expected_key == tuple(list(instance_owners)[0])
+ assert client_mock._ping_and_warm_instances.call_count == 1
+ self._get_target_class()._register_instance(
+ client_mock, "instance-1", table_mock
+ )
+ assert len(active_instances) == 1
+ assert expected_key == tuple(list(active_instances)[0])
+ assert len(instance_owners) == 1
+ assert expected_key == tuple(list(instance_owners)[0])
+ assert client_mock._ping_and_warm_instances.call_count == 1
+
+ @pytest.mark.parametrize(
+ "insert_instances,expected_active,expected_owner_keys",
+ [
+ ([("i", "t", None)], [("i", "t", None)], [("i", "t", None)]),
+ ([("i", "t", "p")], [("i", "t", "p")], [("i", "t", "p")]),
+ ([("1", "t", "p"), ("1", "t", "p")], [("1", "t", "p")], [("1", "t", "p")]),
+ (
+ [("1", "t", "p"), ("2", "t", "p")],
+ [("1", "t", "p"), ("2", "t", "p")],
+ [("1", "t", "p"), ("2", "t", "p")],
+ ),
+ ],
+ )
+ def test__register_instance_state(
+ self, insert_instances, expected_active, expected_owner_keys
+ ):
+ """test that active_instances and instance_owners are updated as expected"""
+ client_mock = mock.Mock()
+ client_mock._gapic_client.instance_path.side_effect = lambda a, b: b
+ active_instances = set()
+ instance_owners = {}
+ client_mock._active_instances = active_instances
+ client_mock._instance_owners = instance_owners
+ client_mock._channel_refresh_task = None
+ client_mock._ping_and_warm_instances = CrossSync._Sync_Impl.Mock()
+ table_mock = mock.Mock()
+ for instance, table, profile in insert_instances:
+ table_mock.table_name = table
+ table_mock.app_profile_id = profile
+ self._get_target_class()._register_instance(
+ client_mock, instance, table_mock
+ )
+ assert len(active_instances) == len(expected_active)
+ assert len(instance_owners) == len(expected_owner_keys)
+ for expected in expected_active:
+ assert any(
+ [
+ expected == tuple(list(active_instances)[i])
+ for i in range(len(active_instances))
+ ]
+ )
+ for expected in expected_owner_keys:
+ assert any(
+ [
+ expected == tuple(list(instance_owners)[i])
+ for i in range(len(instance_owners))
+ ]
+ )
+
+ def test__remove_instance_registration(self):
+ client = self._make_client(project="project-id")
+ table = mock.Mock()
+ client._register_instance("instance-1", table)
+ client._register_instance("instance-2", table)
+ assert len(client._active_instances) == 2
+ assert len(client._instance_owners.keys()) == 2
+ instance_1_path = client._gapic_client.instance_path(
+ client.project, "instance-1"
+ )
+ instance_1_key = (instance_1_path, table.table_name, table.app_profile_id)
+ instance_2_path = client._gapic_client.instance_path(
+ client.project, "instance-2"
+ )
+ instance_2_key = (instance_2_path, table.table_name, table.app_profile_id)
+ assert len(client._instance_owners[instance_1_key]) == 1
+ assert list(client._instance_owners[instance_1_key])[0] == id(table)
+ assert len(client._instance_owners[instance_2_key]) == 1
+ assert list(client._instance_owners[instance_2_key])[0] == id(table)
+ success = client._remove_instance_registration("instance-1", table)
+ assert success
+ assert len(client._active_instances) == 1
+ assert len(client._instance_owners[instance_1_key]) == 0
+ assert len(client._instance_owners[instance_2_key]) == 1
+ assert client._active_instances == {instance_2_key}
+ success = client._remove_instance_registration("fake-key", table)
+ assert not success
+ assert len(client._active_instances) == 1
+ client.close()
+
+ def test__multiple_table_registration(self):
+ """registering with multiple tables with the same key should
+ add multiple owners to instance_owners, but only keep one copy
+ of shared key in active_instances"""
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+
+ with self._make_client(project="project-id") as client:
+ with client.get_table("instance_1", "table_1") as table_1:
+ instance_1_path = client._gapic_client.instance_path(
+ client.project, "instance_1"
+ )
+ instance_1_key = _WarmedInstanceKey(
+ instance_1_path, table_1.table_name, table_1.app_profile_id
+ )
+ assert len(client._instance_owners[instance_1_key]) == 1
+ assert len(client._active_instances) == 1
+ assert id(table_1) in client._instance_owners[instance_1_key]
+ with client.get_table("instance_1", "table_1") as table_2:
+ assert table_2._register_instance_future is not None
+ table_2._register_instance_future.result()
+ assert len(client._instance_owners[instance_1_key]) == 2
+ assert len(client._active_instances) == 1
+ assert id(table_1) in client._instance_owners[instance_1_key]
+ assert id(table_2) in client._instance_owners[instance_1_key]
+ with client.get_table("instance_1", "table_3") as table_3:
+ assert table_3._register_instance_future is not None
+ table_3._register_instance_future.result()
+ instance_3_path = client._gapic_client.instance_path(
+ client.project, "instance_1"
+ )
+ instance_3_key = _WarmedInstanceKey(
+ instance_3_path, table_3.table_name, table_3.app_profile_id
+ )
+ assert len(client._instance_owners[instance_1_key]) == 2
+ assert len(client._instance_owners[instance_3_key]) == 1
+ assert len(client._active_instances) == 2
+ assert id(table_1) in client._instance_owners[instance_1_key]
+ assert id(table_2) in client._instance_owners[instance_1_key]
+ assert id(table_3) in client._instance_owners[instance_3_key]
+ assert len(client._active_instances) == 1
+ assert instance_1_key in client._active_instances
+ assert id(table_2) not in client._instance_owners[instance_1_key]
+ assert len(client._active_instances) == 0
+ assert instance_1_key not in client._active_instances
+ assert len(client._instance_owners[instance_1_key]) == 0
+
+ def test__multiple_instance_registration(self):
+ """registering with multiple instance keys should update the key
+ in instance_owners and active_instances"""
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+
+ with self._make_client(project="project-id") as client:
+ with client.get_table("instance_1", "table_1") as table_1:
+ assert table_1._register_instance_future is not None
+ table_1._register_instance_future.result()
+ with client.get_table("instance_2", "table_2") as table_2:
+ assert table_2._register_instance_future is not None
+ table_2._register_instance_future.result()
+ instance_1_path = client._gapic_client.instance_path(
+ client.project, "instance_1"
+ )
+ instance_1_key = _WarmedInstanceKey(
+ instance_1_path, table_1.table_name, table_1.app_profile_id
+ )
+ instance_2_path = client._gapic_client.instance_path(
+ client.project, "instance_2"
+ )
+ instance_2_key = _WarmedInstanceKey(
+ instance_2_path, table_2.table_name, table_2.app_profile_id
+ )
+ assert len(client._instance_owners[instance_1_key]) == 1
+ assert len(client._instance_owners[instance_2_key]) == 1
+ assert len(client._active_instances) == 2
+ assert id(table_1) in client._instance_owners[instance_1_key]
+ assert id(table_2) in client._instance_owners[instance_2_key]
+ assert len(client._active_instances) == 1
+ assert instance_1_key in client._active_instances
+ assert len(client._instance_owners[instance_2_key]) == 0
+ assert len(client._instance_owners[instance_1_key]) == 1
+ assert id(table_1) in client._instance_owners[instance_1_key]
+ assert len(client._active_instances) == 0
+ assert len(client._instance_owners[instance_1_key]) == 0
+ assert len(client._instance_owners[instance_2_key]) == 0
+
+ def test_get_table(self):
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+
+ client = self._make_client(project="project-id")
+ assert not client._active_instances
+ expected_table_id = "table-id"
+ expected_instance_id = "instance-id"
+ expected_app_profile_id = "app-profile-id"
+ table = client.get_table(
+ expected_instance_id, expected_table_id, expected_app_profile_id
+ )
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert isinstance(table, CrossSync._Sync_Impl.TestTable._get_target_class())
+ assert table.table_id == expected_table_id
+ assert (
+ table.table_name
+ == f"projects/{client.project}/instances/{expected_instance_id}/tables/{expected_table_id}"
+ )
+ assert table.instance_id == expected_instance_id
+ assert (
+ table.instance_name
+ == f"projects/{client.project}/instances/{expected_instance_id}"
+ )
+ assert table.app_profile_id == expected_app_profile_id
+ assert table.client is client
+ instance_key = _WarmedInstanceKey(
+ table.instance_name, table.table_name, table.app_profile_id
+ )
+ assert instance_key in client._active_instances
+ assert client._instance_owners[instance_key] == {id(table)}
+ client.close()
+
+ def test_get_table_arg_passthrough(self):
+ """All arguments passed in get_table should be sent to constructor"""
+ with self._make_client(project="project-id") as client:
+ with mock.patch.object(
+ CrossSync._Sync_Impl.TestTable._get_target_class(), "__init__"
+ ) as mock_constructor:
+ mock_constructor.return_value = None
+ assert not client._active_instances
+ expected_table_id = "table-id"
+ expected_instance_id = "instance-id"
+ expected_app_profile_id = "app-profile-id"
+ expected_args = (1, "test", {"test": 2})
+ expected_kwargs = {"hello": "world", "test": 2}
+ client.get_table(
+ expected_instance_id,
+ expected_table_id,
+ expected_app_profile_id,
+ *expected_args,
+ **expected_kwargs,
+ )
+ mock_constructor.assert_called_once_with(
+ client,
+ expected_instance_id,
+ expected_table_id,
+ expected_app_profile_id,
+ *expected_args,
+ **expected_kwargs,
+ )
+
+ def test_get_table_context_manager(self):
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+
+ expected_table_id = "table-id"
+ expected_instance_id = "instance-id"
+ expected_app_profile_id = "app-profile-id"
+ expected_project_id = "project-id"
+ with mock.patch.object(
+ CrossSync._Sync_Impl.TestTable._get_target_class(), "close"
+ ) as close_mock:
+ with self._make_client(project=expected_project_id) as client:
+ with client.get_table(
+ expected_instance_id, expected_table_id, expected_app_profile_id
+ ) as table:
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert isinstance(
+ table, CrossSync._Sync_Impl.TestTable._get_target_class()
+ )
+ assert table.table_id == expected_table_id
+ assert (
+ table.table_name
+ == f"projects/{expected_project_id}/instances/{expected_instance_id}/tables/{expected_table_id}"
+ )
+ assert table.instance_id == expected_instance_id
+ assert (
+ table.instance_name
+ == f"projects/{expected_project_id}/instances/{expected_instance_id}"
+ )
+ assert table.app_profile_id == expected_app_profile_id
+ assert table.client is client
+ instance_key = _WarmedInstanceKey(
+ table.instance_name, table.table_name, table.app_profile_id
+ )
+ assert instance_key in client._active_instances
+ assert client._instance_owners[instance_key] == {id(table)}
+ assert close_mock.call_count == 1
+
+ def test_close(self):
+ client = self._make_client(project="project-id", use_emulator=False)
+ task = client._channel_refresh_task
+ assert task is not None
+ assert not task.done()
+ with mock.patch.object(
+ client.transport, "close", CrossSync._Sync_Impl.Mock()
+ ) as close_mock:
+ client.close()
+ close_mock.assert_called_once()
+ assert task.done()
+ assert client._channel_refresh_task is None
+
+ def test_close_with_timeout(self):
+ expected_timeout = 19
+ client = self._make_client(project="project-id", use_emulator=False)
+ with mock.patch.object(
+ CrossSync._Sync_Impl, "wait", CrossSync._Sync_Impl.Mock()
+ ) as wait_for_mock:
+ client.close(timeout=expected_timeout)
+ wait_for_mock.assert_called_once()
+ assert wait_for_mock.call_args[1]["timeout"] == expected_timeout
+ client.close()
+
+ def test_context_manager(self):
+ from functools import partial
+
+ close_mock = CrossSync._Sync_Impl.Mock()
+ true_close = None
+ with self._make_client(project="project-id", use_emulator=False) as client:
+ true_close = partial(client.close)
+ client.close = close_mock
+ assert not client._channel_refresh_task.done()
+ assert client.project == "project-id"
+ assert client._active_instances == set()
+ close_mock.assert_not_called()
+ close_mock.assert_called_once()
+ true_close()
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("TestTable")
+class TestTable:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @staticmethod
+ def _get_target_class():
+ return CrossSync._Sync_Impl.Table
+
+ def test_table_ctor(self):
+ from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
+
+ expected_table_id = "table-id"
+ expected_instance_id = "instance-id"
+ expected_app_profile_id = "app-profile-id"
+ expected_operation_timeout = 123
+ expected_attempt_timeout = 12
+ expected_read_rows_operation_timeout = 1.5
+ expected_read_rows_attempt_timeout = 0.5
+ expected_mutate_rows_operation_timeout = 2.5
+ expected_mutate_rows_attempt_timeout = 0.75
+ client = self._make_client()
+ assert not client._active_instances
+ table = self._get_target_class()(
+ client,
+ expected_instance_id,
+ expected_table_id,
+ expected_app_profile_id,
+ default_operation_timeout=expected_operation_timeout,
+ default_attempt_timeout=expected_attempt_timeout,
+ default_read_rows_operation_timeout=expected_read_rows_operation_timeout,
+ default_read_rows_attempt_timeout=expected_read_rows_attempt_timeout,
+ default_mutate_rows_operation_timeout=expected_mutate_rows_operation_timeout,
+ default_mutate_rows_attempt_timeout=expected_mutate_rows_attempt_timeout,
+ )
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert table.table_id == expected_table_id
+ assert table.instance_id == expected_instance_id
+ assert table.app_profile_id == expected_app_profile_id
+ assert table.client is client
+ instance_key = _WarmedInstanceKey(
+ table.instance_name, table.table_name, table.app_profile_id
+ )
+ assert instance_key in client._active_instances
+ assert client._instance_owners[instance_key] == {id(table)}
+ assert table.default_operation_timeout == expected_operation_timeout
+ assert table.default_attempt_timeout == expected_attempt_timeout
+ assert (
+ table.default_read_rows_operation_timeout
+ == expected_read_rows_operation_timeout
+ )
+ assert (
+ table.default_read_rows_attempt_timeout
+ == expected_read_rows_attempt_timeout
+ )
+ assert (
+ table.default_mutate_rows_operation_timeout
+ == expected_mutate_rows_operation_timeout
+ )
+ assert (
+ table.default_mutate_rows_attempt_timeout
+ == expected_mutate_rows_attempt_timeout
+ )
+ table._register_instance_future
+ assert table._register_instance_future.done()
+ assert not table._register_instance_future.cancelled()
+ assert table._register_instance_future.exception() is None
+ client.close()
+
+ def test_table_ctor_defaults(self):
+ """should provide default timeout values and app_profile_id"""
+ expected_table_id = "table-id"
+ expected_instance_id = "instance-id"
+ client = self._make_client()
+ assert not client._active_instances
+ table = self._get_target_class()(
+ client, expected_instance_id, expected_table_id
+ )
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert table.table_id == expected_table_id
+ assert table.instance_id == expected_instance_id
+ assert table.app_profile_id is None
+ assert table.client is client
+ assert table.default_operation_timeout == 60
+ assert table.default_read_rows_operation_timeout == 600
+ assert table.default_mutate_rows_operation_timeout == 600
+ assert table.default_attempt_timeout == 20
+ assert table.default_read_rows_attempt_timeout == 20
+ assert table.default_mutate_rows_attempt_timeout == 60
+ client.close()
+
+ def test_table_ctor_invalid_timeout_values(self):
+ """bad timeout values should raise ValueError"""
+ client = self._make_client()
+ timeout_pairs = [
+ ("default_operation_timeout", "default_attempt_timeout"),
+ (
+ "default_read_rows_operation_timeout",
+ "default_read_rows_attempt_timeout",
+ ),
+ (
+ "default_mutate_rows_operation_timeout",
+ "default_mutate_rows_attempt_timeout",
+ ),
+ ]
+ for operation_timeout, attempt_timeout in timeout_pairs:
+ with pytest.raises(ValueError) as e:
+ self._get_target_class()(client, "", "", **{attempt_timeout: -1})
+ assert "attempt_timeout must be greater than 0" in str(e.value)
+ with pytest.raises(ValueError) as e:
+ self._get_target_class()(client, "", "", **{operation_timeout: -1})
+ assert "operation_timeout must be greater than 0" in str(e.value)
+ client.close()
+
+ @pytest.mark.parametrize(
+ "fn_name,fn_args,is_stream,extra_retryables",
+ [
+ ("read_rows_stream", (ReadRowsQuery(),), True, ()),
+ ("read_rows", (ReadRowsQuery(),), True, ()),
+ ("read_row", (b"row_key",), True, ()),
+ ("read_rows_sharded", ([ReadRowsQuery()],), True, ()),
+ ("row_exists", (b"row_key",), True, ()),
+ ("sample_row_keys", (), False, ()),
+ ("mutate_row", (b"row_key", [mock.Mock()]), False, ()),
+ (
+ "bulk_mutate_rows",
+ ([mutations.RowMutationEntry(b"key", [mutations.DeleteAllFromRow()])],),
+ False,
+ (_MutateRowsIncomplete,),
+ ),
+ ],
+ )
+ @pytest.mark.parametrize(
+ "input_retryables,expected_retryables",
+ [
+ (
+ TABLE_DEFAULT.READ_ROWS,
+ [
+ core_exceptions.DeadlineExceeded,
+ core_exceptions.ServiceUnavailable,
+ core_exceptions.Aborted,
+ ],
+ ),
+ (
+ TABLE_DEFAULT.DEFAULT,
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ ),
+ (
+ TABLE_DEFAULT.MUTATE_ROWS,
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ ),
+ ([], []),
+ ([4], [core_exceptions.DeadlineExceeded]),
+ ],
+ )
+ def test_customizable_retryable_errors(
+ self,
+ input_retryables,
+ expected_retryables,
+ fn_name,
+ fn_args,
+ is_stream,
+ extra_retryables,
+ ):
+ """Test that retryable functions support user-configurable arguments, and that the configured retryables are passed
+ down to the gapic layer."""
+ retry_fn = "retry_target"
+ if is_stream:
+ retry_fn += "_stream"
+ retry_fn = f"CrossSync._Sync_Impl.{retry_fn}"
+ with mock.patch(
+ f"google.cloud.bigtable.data._cross_sync.{retry_fn}"
+ ) as retry_fn_mock:
+ with self._make_client() as client:
+ table = client.get_table("instance-id", "table-id")
+ expected_predicate = expected_retryables.__contains__
+ retry_fn_mock.side_effect = RuntimeError("stop early")
+ with mock.patch(
+ "google.api_core.retry.if_exception_type"
+ ) as predicate_builder_mock:
+ predicate_builder_mock.return_value = expected_predicate
+ with pytest.raises(Exception):
+ test_fn = table.__getattribute__(fn_name)
+ test_fn(*fn_args, retryable_errors=input_retryables)
+ predicate_builder_mock.assert_called_once_with(
+ *expected_retryables, *extra_retryables
+ )
+ retry_call_args = retry_fn_mock.call_args_list[0].args
+ assert retry_call_args[1] is expected_predicate
+
+ @pytest.mark.parametrize(
+ "fn_name,fn_args,gapic_fn",
+ [
+ ("read_rows_stream", (ReadRowsQuery(),), "read_rows"),
+ ("read_rows", (ReadRowsQuery(),), "read_rows"),
+ ("read_row", (b"row_key",), "read_rows"),
+ ("read_rows_sharded", ([ReadRowsQuery()],), "read_rows"),
+ ("row_exists", (b"row_key",), "read_rows"),
+ ("sample_row_keys", (), "sample_row_keys"),
+ ("mutate_row", (b"row_key", [mutations.DeleteAllFromRow()]), "mutate_row"),
+ (
+ "bulk_mutate_rows",
+ ([mutations.RowMutationEntry(b"key", [mutations.DeleteAllFromRow()])],),
+ "mutate_rows",
+ ),
+ ("check_and_mutate_row", (b"row_key", None), "check_and_mutate_row"),
+ (
+ "read_modify_write_row",
+ (b"row_key", IncrementRule("f", "q")),
+ "read_modify_write_row",
+ ),
+ ],
+ )
+ @pytest.mark.parametrize("include_app_profile", [True, False])
+ def test_call_metadata(self, include_app_profile, fn_name, fn_args, gapic_fn):
+ profile = "profile" if include_app_profile else None
+ client = self._make_client()
+ transport_mock = mock.MagicMock()
+ rpc_mock = CrossSync._Sync_Impl.Mock()
+ transport_mock._wrapped_methods.__getitem__.return_value = rpc_mock
+ gapic_client = client._gapic_client
+ gapic_client._transport = transport_mock
+ gapic_client._is_universe_domain_valid = True
+ table = self._get_target_class()(client, "instance-id", "table-id", profile)
+ try:
+ test_fn = table.__getattribute__(fn_name)
+ maybe_stream = test_fn(*fn_args)
+ [i for i in maybe_stream]
+ except Exception:
+ pass
+ assert rpc_mock.call_count == 1
+ kwargs = rpc_mock.call_args_list[0][1]
+ metadata = kwargs["metadata"]
+ assert len(metadata) == 1
+ assert metadata[0][0] == "x-goog-request-params"
+ routing_str = metadata[0][1]
+ assert "table_name=" + table.table_name in routing_str
+ if include_app_profile:
+ assert "app_profile_id=profile" in routing_str
+ else:
+ assert "app_profile_id=" not in routing_str
+
+
+@CrossSync._Sync_Impl.add_mapping_decorator("TestReadRows")
+class TestReadRows:
+ """
+ Tests for table.read_rows and related methods.
+ """
+
+ @staticmethod
+ def _get_operation_class():
+ return CrossSync._Sync_Impl._ReadRowsOperation
+
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ def _make_table(self, *args, **kwargs):
+ client_mock = mock.Mock()
+ client_mock._register_instance.side_effect = (
+ lambda *args, **kwargs: CrossSync._Sync_Impl.yield_to_event_loop()
+ )
+ client_mock._remove_instance_registration.side_effect = (
+ lambda *args, **kwargs: CrossSync._Sync_Impl.yield_to_event_loop()
+ )
+ kwargs["instance_id"] = kwargs.get(
+ "instance_id", args[0] if args else "instance"
+ )
+ kwargs["table_id"] = kwargs.get(
+ "table_id", args[1] if len(args) > 1 else "table"
+ )
+ client_mock._gapic_client.table_path.return_value = kwargs["table_id"]
+ client_mock._gapic_client.instance_path.return_value = kwargs["instance_id"]
+ return CrossSync._Sync_Impl.TestTable._get_target_class()(
+ client_mock, *args, **kwargs
+ )
+
+ def _make_stats(self):
+ from google.cloud.bigtable_v2.types import RequestStats
+ from google.cloud.bigtable_v2.types import FullReadStatsView
+ from google.cloud.bigtable_v2.types import ReadIterationStats
+
+ return RequestStats(
+ full_read_stats_view=FullReadStatsView(
+ read_iteration_stats=ReadIterationStats(
+ rows_seen_count=1,
+ rows_returned_count=2,
+ cells_seen_count=3,
+ cells_returned_count=4,
+ )
+ )
+ )
+
+ @staticmethod
+ def _make_chunk(*args, **kwargs):
+ from google.cloud.bigtable_v2 import ReadRowsResponse
+
+ kwargs["row_key"] = kwargs.get("row_key", b"row_key")
+ kwargs["family_name"] = kwargs.get("family_name", "family_name")
+ kwargs["qualifier"] = kwargs.get("qualifier", b"qualifier")
+ kwargs["value"] = kwargs.get("value", b"value")
+ kwargs["commit_row"] = kwargs.get("commit_row", True)
+ return ReadRowsResponse.CellChunk(*args, **kwargs)
+
+ @staticmethod
+ def _make_gapic_stream(
+ chunk_list: list[ReadRowsResponse.CellChunk | Exception], sleep_time=0
+ ):
+ from google.cloud.bigtable_v2 import ReadRowsResponse
+
+ class mock_stream:
+ def __init__(self, chunk_list, sleep_time):
+ self.chunk_list = chunk_list
+ self.idx = -1
+ self.sleep_time = sleep_time
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ self.idx += 1
+ if len(self.chunk_list) > self.idx:
+ if sleep_time:
+ CrossSync._Sync_Impl.sleep(self.sleep_time)
+ chunk = self.chunk_list[self.idx]
+ if isinstance(chunk, Exception):
+ raise chunk
+ else:
+ return ReadRowsResponse(chunks=[chunk])
+ raise CrossSync._Sync_Impl.StopIteration
+
+ def cancel(self):
+ pass
+
+ return mock_stream(chunk_list, sleep_time)
+
+ def execute_fn(self, table, *args, **kwargs):
+ return table.read_rows(*args, **kwargs)
+
+ def test_read_rows(self):
+ query = ReadRowsQuery()
+ chunks = [
+ self._make_chunk(row_key=b"test_1"),
+ self._make_chunk(row_key=b"test_2"),
+ ]
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ chunks
+ )
+ results = self.execute_fn(table, query, operation_timeout=3)
+ assert len(results) == 2
+ assert results[0].row_key == b"test_1"
+ assert results[1].row_key == b"test_2"
+
+ def test_read_rows_stream(self):
+ query = ReadRowsQuery()
+ chunks = [
+ self._make_chunk(row_key=b"test_1"),
+ self._make_chunk(row_key=b"test_2"),
+ ]
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ chunks
+ )
+ gen = table.read_rows_stream(query, operation_timeout=3)
+ results = [row for row in gen]
+ assert len(results) == 2
+ assert results[0].row_key == b"test_1"
+ assert results[1].row_key == b"test_2"
+
+ @pytest.mark.parametrize("include_app_profile", [True, False])
+ def test_read_rows_query_matches_request(self, include_app_profile):
+ from google.cloud.bigtable.data import RowRange
+ from google.cloud.bigtable.data.row_filters import PassAllFilter
+
+ app_profile_id = "app_profile_id" if include_app_profile else None
+ with self._make_table(app_profile_id=app_profile_id) as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream([])
+ row_keys = [b"test_1", "test_2"]
+ row_ranges = RowRange("1start", "2end")
+ filter_ = PassAllFilter(True)
+ limit = 99
+ query = ReadRowsQuery(
+ row_keys=row_keys,
+ row_ranges=row_ranges,
+ row_filter=filter_,
+ limit=limit,
+ )
+ results = table.read_rows(query, operation_timeout=3)
+ assert len(results) == 0
+ call_request = read_rows.call_args_list[0][0][0]
+ query_pb = query._to_pb(table)
+ assert call_request == query_pb
+
+ @pytest.mark.parametrize("operation_timeout", [0.001, 0.023, 0.1])
+ def test_read_rows_timeout(self, operation_timeout):
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ query = ReadRowsQuery()
+ chunks = [self._make_chunk(row_key=b"test_1")]
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ chunks, sleep_time=0.15
+ )
+ try:
+ table.read_rows(query, operation_timeout=operation_timeout)
+ except core_exceptions.DeadlineExceeded as e:
+ assert (
+ e.message
+ == f"operation_timeout of {operation_timeout:0.1f}s exceeded"
+ )
+
+ @pytest.mark.parametrize(
+ "per_request_t, operation_t, expected_num",
+ [(0.05, 0.08, 2), (0.05, 0.14, 3), (0.05, 0.24, 5)],
+ )
+ def test_read_rows_attempt_timeout(self, per_request_t, operation_t, expected_num):
+ """Ensures that the attempt_timeout is respected and that the number of
+ requests is as expected.
+
+ operation_timeout does not cancel the request, so we expect the number of
+ requests to be the ceiling of operation_timeout / attempt_timeout."""
+ from google.cloud.bigtable.data.exceptions import RetryExceptionGroup
+
+ expected_last_timeout = operation_t - (expected_num - 1) * per_request_t
+ with mock.patch("random.uniform", side_effect=lambda a, b: 0):
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ chunks, sleep_time=per_request_t
+ )
+ query = ReadRowsQuery()
+ chunks = [core_exceptions.DeadlineExceeded("mock deadline")]
+ try:
+ table.read_rows(
+ query,
+ operation_timeout=operation_t,
+ attempt_timeout=per_request_t,
+ )
+ except core_exceptions.DeadlineExceeded as e:
+ retry_exc = e.__cause__
+ if expected_num == 0:
+ assert retry_exc is None
+ else:
+ assert type(retry_exc) is RetryExceptionGroup
+ assert f"{expected_num} failed attempts" in str(retry_exc)
+ assert len(retry_exc.exceptions) == expected_num
+ for sub_exc in retry_exc.exceptions:
+ assert sub_exc.message == "mock deadline"
+ assert read_rows.call_count == expected_num
+ for _, call_kwargs in read_rows.call_args_list[:-1]:
+ assert call_kwargs["timeout"] == per_request_t
+ assert call_kwargs["retry"] is None
+ assert (
+ abs(
+ read_rows.call_args_list[-1][1]["timeout"]
+ - expected_last_timeout
+ )
+ < 0.05
+ )
+
+ @pytest.mark.parametrize(
+ "exc_type",
+ [
+ core_exceptions.Aborted,
+ core_exceptions.DeadlineExceeded,
+ core_exceptions.ServiceUnavailable,
+ ],
+ )
+ def test_read_rows_retryable_error(self, exc_type):
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ [expected_error]
+ )
+ query = ReadRowsQuery()
+ expected_error = exc_type("mock error")
+ try:
+ table.read_rows(query, operation_timeout=0.1)
+ except core_exceptions.DeadlineExceeded as e:
+ retry_exc = e.__cause__
+ root_cause = retry_exc.exceptions[0]
+ assert type(root_cause) is exc_type
+ assert root_cause == expected_error
+
+ @pytest.mark.parametrize(
+ "exc_type",
+ [
+ core_exceptions.Cancelled,
+ core_exceptions.PreconditionFailed,
+ core_exceptions.NotFound,
+ core_exceptions.PermissionDenied,
+ core_exceptions.Conflict,
+ core_exceptions.InternalServerError,
+ core_exceptions.TooManyRequests,
+ core_exceptions.ResourceExhausted,
+ InvalidChunk,
+ ],
+ )
+ def test_read_rows_non_retryable_error(self, exc_type):
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ [expected_error]
+ )
+ query = ReadRowsQuery()
+ expected_error = exc_type("mock error")
+ try:
+ table.read_rows(query, operation_timeout=0.1)
+ except exc_type as e:
+ assert e == expected_error
+
+ def test_read_rows_revise_request(self):
+ """Ensure that _revise_request is called between retries"""
+ from google.cloud.bigtable.data.exceptions import InvalidChunk
+ from google.cloud.bigtable_v2.types import RowSet
+
+ return_val = RowSet()
+ with mock.patch.object(
+ self._get_operation_class(), "_revise_request_rowset"
+ ) as revise_rowset:
+ revise_rowset.return_value = return_val
+ with self._make_table() as table:
+ read_rows = table.client._gapic_client.read_rows
+ read_rows.side_effect = lambda *args, **kwargs: self._make_gapic_stream(
+ chunks
+ )
+ row_keys = [b"test_1", b"test_2", b"test_3"]
+ query = ReadRowsQuery(row_keys=row_keys)
+ chunks = [
+ self._make_chunk(row_key=b"test_1"),
+ core_exceptions.Aborted("mock retryable error"),
+ ]
+ try:
+ table.read_rows(query)
+ except InvalidChunk:
+ revise_rowset.assert_called()
+ first_call_kwargs = revise_rowset.call_args_list[0].kwargs
+ assert first_call_kwargs["row_set"] == query._to_pb(table).rows
+ assert first_call_kwargs["last_seen_row_key"] == b"test_1"
+ revised_call = read_rows.call_args_list[1].args[0]
+ assert revised_call.rows == return_val
+
+ def test_read_rows_default_timeouts(self):
+ """Ensure that the default timeouts are set on the read rows operation when not overridden"""
+ operation_timeout = 8
+ attempt_timeout = 4
+ with mock.patch.object(self._get_operation_class(), "__init__") as mock_op:
+ mock_op.side_effect = RuntimeError("mock error")
+ with self._make_table(
+ default_read_rows_operation_timeout=operation_timeout,
+ default_read_rows_attempt_timeout=attempt_timeout,
+ ) as table:
+ try:
+ table.read_rows(ReadRowsQuery())
+ except RuntimeError:
+ pass
+ kwargs = mock_op.call_args_list[0].kwargs
+ assert kwargs["operation_timeout"] == operation_timeout
+ assert kwargs["attempt_timeout"] == attempt_timeout
+
+ def test_read_rows_default_timeout_override(self):
+ """When timeouts are passed, they overwrite default values"""
+ operation_timeout = 8
+ attempt_timeout = 4
+ with mock.patch.object(self._get_operation_class(), "__init__") as mock_op:
+ mock_op.side_effect = RuntimeError("mock error")
+ with self._make_table(
+ default_operation_timeout=99, default_attempt_timeout=97
+ ) as table:
+ try:
+ table.read_rows(
+ ReadRowsQuery(),
+ operation_timeout=operation_timeout,
+ attempt_timeout=attempt_timeout,
+ )
+ except RuntimeError:
+ pass
+ kwargs = mock_op.call_args_list[0].kwargs
+ assert kwargs["operation_timeout"] == operation_timeout
+ assert kwargs["attempt_timeout"] == attempt_timeout
+
+ def test_read_row(self):
+ """Test reading a single row"""
+ with self._make_client() as client:
+ table = client.get_table("instance", "table")
+ row_key = b"test_1"
+ with mock.patch.object(table, "read_rows") as read_rows:
+ expected_result = object()
+ read_rows.side_effect = lambda *args, **kwargs: [expected_result]
+ expected_op_timeout = 8
+ expected_req_timeout = 4
+ row = table.read_row(
+ row_key,
+ operation_timeout=expected_op_timeout,
+ attempt_timeout=expected_req_timeout,
+ )
+ assert row == expected_result
+ assert read_rows.call_count == 1
+ (args, kwargs) = read_rows.call_args_list[0]
+ assert kwargs["operation_timeout"] == expected_op_timeout
+ assert kwargs["attempt_timeout"] == expected_req_timeout
+ assert len(args) == 1
+ assert isinstance(args[0], ReadRowsQuery)
+ query = args[0]
+ assert query.row_keys == [row_key]
+ assert query.row_ranges == []
+ assert query.limit == 1
+
+ def test_read_row_w_filter(self):
+ """Test reading a single row with an added filter"""
+ with self._make_client() as client:
+ table = client.get_table("instance", "table")
+ row_key = b"test_1"
+ with mock.patch.object(table, "read_rows") as read_rows:
+ expected_result = object()
+ read_rows.side_effect = lambda *args, **kwargs: [expected_result]
+ expected_op_timeout = 8
+ expected_req_timeout = 4
+ mock_filter = mock.Mock()
+ expected_filter = {"filter": "mock filter"}
+ mock_filter._to_dict.return_value = expected_filter
+ row = table.read_row(
+ row_key,
+ operation_timeout=expected_op_timeout,
+ attempt_timeout=expected_req_timeout,
+ row_filter=expected_filter,
+ )
+ assert row == expected_result
+ assert read_rows.call_count == 1
+ (args, kwargs) = read_rows.call_args_list[0]
+ assert kwargs["operation_timeout"] == expected_op_timeout
+ assert kwargs["attempt_timeout"] == expected_req_timeout
+ assert len(args) == 1
+ assert isinstance(args[0], ReadRowsQuery)
+ query = args[0]
+ assert query.row_keys == [row_key]
+ assert query.row_ranges == []
+ assert query.limit == 1
+ assert query.filter == expected_filter
+
+ def test_read_row_no_response(self):
+ """should return None if row does not exist"""
+ with self._make_client() as client:
+ table = client.get_table("instance", "table")
+ row_key = b"test_1"
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = lambda *args, **kwargs: []
+ expected_op_timeout = 8
+ expected_req_timeout = 4
+ result = table.read_row(
+ row_key,
+ operation_timeout=expected_op_timeout,
+ attempt_timeout=expected_req_timeout,
+ )
+ assert result is None
+ assert read_rows.call_count == 1
+ (args, kwargs) = read_rows.call_args_list[0]
+ assert kwargs["operation_timeout"] == expected_op_timeout
+ assert kwargs["attempt_timeout"] == expected_req_timeout
+ assert isinstance(args[0], ReadRowsQuery)
+ query = args[0]
+ assert query.row_keys == [row_key]
+ assert query.row_ranges == []
+ assert query.limit == 1
+
+ @pytest.mark.parametrize(
+ "return_value,expected_result",
+ [([], False), ([object()], True), ([object(), object()], True)],
+ )
+ def test_row_exists(self, return_value, expected_result):
+ """Test checking for row existence"""
+ with self._make_client() as client:
+ table = client.get_table("instance", "table")
+ row_key = b"test_1"
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = lambda *args, **kwargs: return_value
+ expected_op_timeout = 1
+ expected_req_timeout = 2
+ result = table.row_exists(
+ row_key,
+ operation_timeout=expected_op_timeout,
+ attempt_timeout=expected_req_timeout,
+ )
+ assert expected_result == result
+ assert read_rows.call_count == 1
+ (args, kwargs) = read_rows.call_args_list[0]
+ assert kwargs["operation_timeout"] == expected_op_timeout
+ assert kwargs["attempt_timeout"] == expected_req_timeout
+ assert isinstance(args[0], ReadRowsQuery)
+ expected_filter = {
+ "chain": {
+ "filters": [
+ {"cells_per_row_limit_filter": 1},
+ {"strip_value_transformer": True},
+ ]
+ }
+ }
+ query = args[0]
+ assert query.row_keys == [row_key]
+ assert query.row_ranges == []
+ assert query.limit == 1
+ assert query.filter._to_dict() == expected_filter
+
+
+class TestReadRowsSharded:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ def test_read_rows_sharded_empty_query(self):
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with pytest.raises(ValueError) as exc:
+ table.read_rows_sharded([])
+ assert "empty sharded_query" in str(exc.value)
+
+ def test_read_rows_sharded_multiple_queries(self):
+ """Test with multiple queries. Should return results from both"""
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ table.client._gapic_client, "read_rows"
+ ) as read_rows:
+ read_rows.side_effect = lambda *args, **kwargs: CrossSync._Sync_Impl.TestReadRows._make_gapic_stream(
+ [
+ CrossSync._Sync_Impl.TestReadRows._make_chunk(row_key=k)
+ for k in args[0].rows.row_keys
+ ]
+ )
+ query_1 = ReadRowsQuery(b"test_1")
+ query_2 = ReadRowsQuery(b"test_2")
+ result = table.read_rows_sharded([query_1, query_2])
+ assert len(result) == 2
+ assert result[0].row_key == b"test_1"
+ assert result[1].row_key == b"test_2"
+
+ @pytest.mark.parametrize("n_queries", [1, 2, 5, 11, 24])
+ def test_read_rows_sharded_multiple_queries_calls(self, n_queries):
+ """Each query should trigger a separate read_rows call"""
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(table, "read_rows") as read_rows:
+ query_list = [ReadRowsQuery() for _ in range(n_queries)]
+ table.read_rows_sharded(query_list)
+ assert read_rows.call_count == n_queries
+
+ def test_read_rows_sharded_errors(self):
+ """Errors should be exposed as ShardedReadRowsExceptionGroups"""
+ from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
+ from google.cloud.bigtable.data.exceptions import FailedQueryShardError
+
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = RuntimeError("mock error")
+ query_1 = ReadRowsQuery(b"test_1")
+ query_2 = ReadRowsQuery(b"test_2")
+ with pytest.raises(ShardedReadRowsExceptionGroup) as exc:
+ table.read_rows_sharded([query_1, query_2])
+ exc_group = exc.value
+ assert isinstance(exc_group, ShardedReadRowsExceptionGroup)
+ assert len(exc.value.exceptions) == 2
+ assert isinstance(exc.value.exceptions[0], FailedQueryShardError)
+ assert isinstance(exc.value.exceptions[0].__cause__, RuntimeError)
+ assert exc.value.exceptions[0].index == 0
+ assert exc.value.exceptions[0].query == query_1
+ assert isinstance(exc.value.exceptions[1], FailedQueryShardError)
+ assert isinstance(exc.value.exceptions[1].__cause__, RuntimeError)
+ assert exc.value.exceptions[1].index == 1
+ assert exc.value.exceptions[1].query == query_2
+
+ def test_read_rows_sharded_concurrent(self):
+ """Ensure sharded requests are concurrent"""
+ import time
+
+ def mock_call(*args, **kwargs):
+ CrossSync._Sync_Impl.sleep(0.1)
+ return [mock.Mock()]
+
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = mock_call
+ queries = [ReadRowsQuery() for _ in range(10)]
+ start_time = time.monotonic()
+ result = table.read_rows_sharded(queries)
+ call_time = time.monotonic() - start_time
+ assert read_rows.call_count == 10
+ assert len(result) == 10
+ assert call_time < 0.5
+
+ def test_read_rows_sharded_concurrency_limit(self):
+ """Only 10 queries should be processed concurrently. Others should be queued
+
+ Should start a new query as soon as previous finishes"""
+ from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
+
+ assert _CONCURRENCY_LIMIT == 10
+ num_queries = 15
+ increment_time = 0.05
+ max_time = increment_time * (_CONCURRENCY_LIMIT - 1)
+ rpc_times = [min(i * increment_time, max_time) for i in range(num_queries)]
+
+ def mock_call(*args, **kwargs):
+ next_sleep = rpc_times.pop(0)
+ asyncio.sleep(next_sleep)
+ return [mock.Mock()]
+
+ starting_timeout = 10
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = mock_call
+ queries = [ReadRowsQuery() for _ in range(num_queries)]
+ table.read_rows_sharded(queries, operation_timeout=starting_timeout)
+ assert read_rows.call_count == num_queries
+ rpc_start_list = [
+ starting_timeout - kwargs["operation_timeout"]
+ for (_, kwargs) in read_rows.call_args_list
+ ]
+ eps = 0.01
+ assert all(
+ (rpc_start_list[i] < eps for i in range(_CONCURRENCY_LIMIT))
+ )
+ for i in range(num_queries - _CONCURRENCY_LIMIT):
+ idx = i + _CONCURRENCY_LIMIT
+ assert rpc_start_list[idx] - i * increment_time < eps
+
+ def test_read_rows_sharded_expirary(self):
+ """If the operation times out before all shards complete, should raise
+ a ShardedReadRowsExceptionGroup"""
+ from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
+ from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
+ from google.api_core.exceptions import DeadlineExceeded
+
+ operation_timeout = 0.1
+ num_queries = 15
+ sleeps = [0] * _CONCURRENCY_LIMIT + [DeadlineExceeded("times up")] * (
+ num_queries - _CONCURRENCY_LIMIT
+ )
+
+ def mock_call(*args, **kwargs):
+ next_item = sleeps.pop(0)
+ if isinstance(next_item, Exception):
+ raise next_item
+ else:
+ asyncio.sleep(next_item)
+ return [mock.Mock()]
+
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = mock_call
+ queries = [ReadRowsQuery() for _ in range(num_queries)]
+ with pytest.raises(ShardedReadRowsExceptionGroup) as exc:
+ table.read_rows_sharded(
+ queries, operation_timeout=operation_timeout
+ )
+ assert isinstance(exc.value, ShardedReadRowsExceptionGroup)
+ assert len(exc.value.exceptions) == num_queries - _CONCURRENCY_LIMIT
+ assert len(exc.value.successful_rows) == _CONCURRENCY_LIMIT
+
+ def test_read_rows_sharded_negative_batch_timeout(self):
+ """try to run with batch that starts after operation timeout
+
+ They should raise DeadlineExceeded errors"""
+ from google.cloud.bigtable.data.exceptions import ShardedReadRowsExceptionGroup
+ from google.cloud.bigtable.data._helpers import _CONCURRENCY_LIMIT
+ from google.api_core.exceptions import DeadlineExceeded
+
+ def mock_call(*args, **kwargs):
+ CrossSync._Sync_Impl.sleep(0.06)
+ return [mock.Mock()]
+
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(table, "read_rows") as read_rows:
+ read_rows.side_effect = mock_call
+ num_calls = 15
+ queries = [ReadRowsQuery() for _ in range(num_calls)]
+ with pytest.raises(ShardedReadRowsExceptionGroup) as exc:
+ table.read_rows_sharded(queries, operation_timeout=0.05)
+ assert isinstance(exc.value, ShardedReadRowsExceptionGroup)
+ assert len(exc.value.exceptions) >= num_calls - _CONCURRENCY_LIMIT
+ assert all(
+ (
+ isinstance(e.__cause__, DeadlineExceeded)
+ for e in exc.value.exceptions
+ )
+ )
+
+
+class TestSampleRowKeys:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ def _make_gapic_stream(self, sample_list: list[tuple[bytes, int]]):
+ from google.cloud.bigtable_v2.types import SampleRowKeysResponse
+
+ for value in sample_list:
+ yield SampleRowKeysResponse(row_key=value[0], offset_bytes=value[1])
+
+ def test_sample_row_keys(self):
+ """Test that method returns the expected key samples"""
+ samples = [(b"test_1", 0), (b"test_2", 100), (b"test_3", 200)]
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ table.client._gapic_client,
+ "sample_row_keys",
+ CrossSync._Sync_Impl.Mock(),
+ ) as sample_row_keys:
+ sample_row_keys.return_value = self._make_gapic_stream(samples)
+ result = table.sample_row_keys()
+ assert len(result) == 3
+ assert all((isinstance(r, tuple) for r in result))
+ assert all((isinstance(r[0], bytes) for r in result))
+ assert all((isinstance(r[1], int) for r in result))
+ assert result[0] == samples[0]
+ assert result[1] == samples[1]
+ assert result[2] == samples[2]
+
+ def test_sample_row_keys_bad_timeout(self):
+ """should raise error if timeout is negative"""
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with pytest.raises(ValueError) as e:
+ table.sample_row_keys(operation_timeout=-1)
+ assert "operation_timeout must be greater than 0" in str(e.value)
+ with pytest.raises(ValueError) as e:
+ table.sample_row_keys(attempt_timeout=-1)
+ assert "attempt_timeout must be greater than 0" in str(e.value)
+
+ def test_sample_row_keys_default_timeout(self):
+ """Should fallback to using table default operation_timeout"""
+ expected_timeout = 99
+ with self._make_client() as client:
+ with client.get_table(
+ "i",
+ "t",
+ default_operation_timeout=expected_timeout,
+ default_attempt_timeout=expected_timeout,
+ ) as table:
+ with mock.patch.object(
+ table.client._gapic_client,
+ "sample_row_keys",
+ CrossSync._Sync_Impl.Mock(),
+ ) as sample_row_keys:
+ sample_row_keys.return_value = self._make_gapic_stream([])
+ result = table.sample_row_keys()
+ (_, kwargs) = sample_row_keys.call_args
+ assert abs(kwargs["timeout"] - expected_timeout) < 0.1
+ assert result == []
+ assert kwargs["retry"] is None
+
+ def test_sample_row_keys_gapic_params(self):
+ """make sure arguments are propagated to gapic call as expected"""
+ expected_timeout = 10
+ expected_profile = "test1"
+ instance = "instance_name"
+ table_id = "my_table"
+ with self._make_client() as client:
+ with client.get_table(
+ instance, table_id, app_profile_id=expected_profile
+ ) as table:
+ with mock.patch.object(
+ table.client._gapic_client,
+ "sample_row_keys",
+ CrossSync._Sync_Impl.Mock(),
+ ) as sample_row_keys:
+ sample_row_keys.return_value = self._make_gapic_stream([])
+ table.sample_row_keys(attempt_timeout=expected_timeout)
+ (args, kwargs) = sample_row_keys.call_args
+ assert len(args) == 0
+ assert len(kwargs) == 4
+ assert kwargs["timeout"] == expected_timeout
+ assert kwargs["app_profile_id"] == expected_profile
+ assert kwargs["table_name"] == table.table_name
+ assert kwargs["retry"] is None
+
+ @pytest.mark.parametrize(
+ "retryable_exception",
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ )
+ def test_sample_row_keys_retryable_errors(self, retryable_exception):
+ """retryable errors should be retried until timeout"""
+ from google.api_core.exceptions import DeadlineExceeded
+ from google.cloud.bigtable.data.exceptions import RetryExceptionGroup
+
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ table.client._gapic_client,
+ "sample_row_keys",
+ CrossSync._Sync_Impl.Mock(),
+ ) as sample_row_keys:
+ sample_row_keys.side_effect = retryable_exception("mock")
+ with pytest.raises(DeadlineExceeded) as e:
+ table.sample_row_keys(operation_timeout=0.05)
+ cause = e.value.__cause__
+ assert isinstance(cause, RetryExceptionGroup)
+ assert len(cause.exceptions) > 0
+ assert isinstance(cause.exceptions[0], retryable_exception)
+
+ @pytest.mark.parametrize(
+ "non_retryable_exception",
+ [
+ core_exceptions.OutOfRange,
+ core_exceptions.NotFound,
+ core_exceptions.FailedPrecondition,
+ RuntimeError,
+ ValueError,
+ core_exceptions.Aborted,
+ ],
+ )
+ def test_sample_row_keys_non_retryable_errors(self, non_retryable_exception):
+ """non-retryable errors should cause a raise"""
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ table.client._gapic_client,
+ "sample_row_keys",
+ CrossSync._Sync_Impl.Mock(),
+ ) as sample_row_keys:
+ sample_row_keys.side_effect = non_retryable_exception("mock")
+ with pytest.raises(non_retryable_exception):
+ table.sample_row_keys()
+
+
+class TestMutateRow:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @pytest.mark.parametrize(
+ "mutation_arg",
+ [
+ mutations.SetCell("family", b"qualifier", b"value"),
+ mutations.SetCell(
+ "family", b"qualifier", b"value", timestamp_micros=1234567890
+ ),
+ mutations.DeleteRangeFromColumn("family", b"qualifier"),
+ mutations.DeleteAllFromFamily("family"),
+ mutations.DeleteAllFromRow(),
+ [mutations.SetCell("family", b"qualifier", b"value")],
+ [
+ mutations.DeleteRangeFromColumn("family", b"qualifier"),
+ mutations.DeleteAllFromRow(),
+ ],
+ ],
+ )
+ def test_mutate_row(self, mutation_arg):
+ """Test mutations with no errors"""
+ expected_attempt_timeout = 19
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_row"
+ ) as mock_gapic:
+ mock_gapic.return_value = None
+ table.mutate_row(
+ "row_key",
+ mutation_arg,
+ attempt_timeout=expected_attempt_timeout,
+ )
+ assert mock_gapic.call_count == 1
+ kwargs = mock_gapic.call_args_list[0].kwargs
+ assert (
+ kwargs["table_name"]
+ == "projects/project/instances/instance/tables/table"
+ )
+ assert kwargs["row_key"] == b"row_key"
+ formatted_mutations = (
+ [mutation._to_pb() for mutation in mutation_arg]
+ if isinstance(mutation_arg, list)
+ else [mutation_arg._to_pb()]
+ )
+ assert kwargs["mutations"] == formatted_mutations
+ assert kwargs["timeout"] == expected_attempt_timeout
+ assert kwargs["retry"] is None
+
+ @pytest.mark.parametrize(
+ "retryable_exception",
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ )
+ def test_mutate_row_retryable_errors(self, retryable_exception):
+ from google.api_core.exceptions import DeadlineExceeded
+ from google.cloud.bigtable.data.exceptions import RetryExceptionGroup
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_row"
+ ) as mock_gapic:
+ mock_gapic.side_effect = retryable_exception("mock")
+ with pytest.raises(DeadlineExceeded) as e:
+ mutation = mutations.DeleteAllFromRow()
+ assert mutation.is_idempotent() is True
+ table.mutate_row("row_key", mutation, operation_timeout=0.01)
+ cause = e.value.__cause__
+ assert isinstance(cause, RetryExceptionGroup)
+ assert isinstance(cause.exceptions[0], retryable_exception)
+
+ @pytest.mark.parametrize(
+ "retryable_exception",
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ )
+ def test_mutate_row_non_idempotent_retryable_errors(self, retryable_exception):
+ """Non-idempotent mutations should not be retried"""
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_row"
+ ) as mock_gapic:
+ mock_gapic.side_effect = retryable_exception("mock")
+ with pytest.raises(retryable_exception):
+ mutation = mutations.SetCell(
+ "family", b"qualifier", b"value", -1
+ )
+ assert mutation.is_idempotent() is False
+ table.mutate_row("row_key", mutation, operation_timeout=0.2)
+
+ @pytest.mark.parametrize(
+ "non_retryable_exception",
+ [
+ core_exceptions.OutOfRange,
+ core_exceptions.NotFound,
+ core_exceptions.FailedPrecondition,
+ RuntimeError,
+ ValueError,
+ core_exceptions.Aborted,
+ ],
+ )
+ def test_mutate_row_non_retryable_errors(self, non_retryable_exception):
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_row"
+ ) as mock_gapic:
+ mock_gapic.side_effect = non_retryable_exception("mock")
+ with pytest.raises(non_retryable_exception):
+ mutation = mutations.SetCell(
+ "family",
+ b"qualifier",
+ b"value",
+ timestamp_micros=1234567890,
+ )
+ assert mutation.is_idempotent() is True
+ table.mutate_row("row_key", mutation, operation_timeout=0.2)
+
+ @pytest.mark.parametrize("mutations", [[], None])
+ def test_mutate_row_no_mutations(self, mutations):
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with pytest.raises(ValueError) as e:
+ table.mutate_row("key", mutations=mutations)
+ assert e.value.args[0] == "No mutations provided"
+
+
+class TestBulkMutateRows:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ def _mock_response(self, response_list):
+ from google.cloud.bigtable_v2.types import MutateRowsResponse
+ from google.rpc import status_pb2
+
+ statuses = []
+ for response in response_list:
+ if isinstance(response, core_exceptions.GoogleAPICallError):
+ statuses.append(
+ status_pb2.Status(
+ message=str(response), code=response.grpc_status_code.value[0]
+ )
+ )
+ else:
+ statuses.append(status_pb2.Status(code=0))
+ entries = [
+ MutateRowsResponse.Entry(index=i, status=statuses[i])
+ for i in range(len(response_list))
+ ]
+
+ def generator():
+ yield MutateRowsResponse(entries=entries)
+
+ return generator()
+
+ @pytest.mark.parametrize(
+ "mutation_arg",
+ [
+ [mutations.SetCell("family", b"qualifier", b"value")],
+ [
+ mutations.SetCell(
+ "family", b"qualifier", b"value", timestamp_micros=1234567890
+ )
+ ],
+ [mutations.DeleteRangeFromColumn("family", b"qualifier")],
+ [mutations.DeleteAllFromFamily("family")],
+ [mutations.DeleteAllFromRow()],
+ [mutations.SetCell("family", b"qualifier", b"value")],
+ [
+ mutations.DeleteRangeFromColumn("family", b"qualifier"),
+ mutations.DeleteAllFromRow(),
+ ],
+ ],
+ )
+ def test_bulk_mutate_rows(self, mutation_arg):
+ """Test mutations with no errors"""
+ expected_attempt_timeout = 19
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.return_value = self._mock_response([None])
+ bulk_mutation = mutations.RowMutationEntry(b"row_key", mutation_arg)
+ table.bulk_mutate_rows(
+ [bulk_mutation], attempt_timeout=expected_attempt_timeout
+ )
+ assert mock_gapic.call_count == 1
+ kwargs = mock_gapic.call_args[1]
+ assert (
+ kwargs["table_name"]
+ == "projects/project/instances/instance/tables/table"
+ )
+ assert kwargs["entries"] == [bulk_mutation._to_pb()]
+ assert kwargs["timeout"] == expected_attempt_timeout
+ assert kwargs["retry"] is None
+
+ def test_bulk_mutate_rows_multiple_entries(self):
+ """Test mutations with no errors"""
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.return_value = self._mock_response([None, None])
+ mutation_list = [mutations.DeleteAllFromRow()]
+ entry_1 = mutations.RowMutationEntry(b"row_key_1", mutation_list)
+ entry_2 = mutations.RowMutationEntry(b"row_key_2", mutation_list)
+ table.bulk_mutate_rows([entry_1, entry_2])
+ assert mock_gapic.call_count == 1
+ kwargs = mock_gapic.call_args[1]
+ assert (
+ kwargs["table_name"]
+ == "projects/project/instances/instance/tables/table"
+ )
+ assert kwargs["entries"][0] == entry_1._to_pb()
+ assert kwargs["entries"][1] == entry_2._to_pb()
+
+ @pytest.mark.parametrize(
+ "exception",
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ )
+ def test_bulk_mutate_rows_idempotent_mutation_error_retryable(self, exception):
+ """Individual idempotent mutations should be retried if they fail with a retryable error"""
+ from google.cloud.bigtable.data.exceptions import (
+ RetryExceptionGroup,
+ FailedMutationEntryError,
+ MutationsExceptionGroup,
+ )
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.side_effect = lambda *a, **k: self._mock_response(
+ [exception("mock")]
+ )
+ with pytest.raises(MutationsExceptionGroup) as e:
+ mutation = mutations.DeleteAllFromRow()
+ entry = mutations.RowMutationEntry(b"row_key", [mutation])
+ assert mutation.is_idempotent() is True
+ table.bulk_mutate_rows([entry], operation_timeout=0.05)
+ assert len(e.value.exceptions) == 1
+ failed_exception = e.value.exceptions[0]
+ assert "non-idempotent" not in str(failed_exception)
+ assert isinstance(failed_exception, FailedMutationEntryError)
+ cause = failed_exception.__cause__
+ assert isinstance(cause, RetryExceptionGroup)
+ assert isinstance(cause.exceptions[0], exception)
+ assert isinstance(
+ cause.exceptions[-1], core_exceptions.DeadlineExceeded
+ )
+
+ @pytest.mark.parametrize(
+ "exception",
+ [
+ core_exceptions.OutOfRange,
+ core_exceptions.NotFound,
+ core_exceptions.FailedPrecondition,
+ core_exceptions.Aborted,
+ ],
+ )
+ def test_bulk_mutate_rows_idempotent_mutation_error_non_retryable(self, exception):
+ """Individual idempotent mutations should not be retried if they fail with a non-retryable error"""
+ from google.cloud.bigtable.data.exceptions import (
+ FailedMutationEntryError,
+ MutationsExceptionGroup,
+ )
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.side_effect = lambda *a, **k: self._mock_response(
+ [exception("mock")]
+ )
+ with pytest.raises(MutationsExceptionGroup) as e:
+ mutation = mutations.DeleteAllFromRow()
+ entry = mutations.RowMutationEntry(b"row_key", [mutation])
+ assert mutation.is_idempotent() is True
+ table.bulk_mutate_rows([entry], operation_timeout=0.05)
+ assert len(e.value.exceptions) == 1
+ failed_exception = e.value.exceptions[0]
+ assert "non-idempotent" not in str(failed_exception)
+ assert isinstance(failed_exception, FailedMutationEntryError)
+ cause = failed_exception.__cause__
+ assert isinstance(cause, exception)
+
+ @pytest.mark.parametrize(
+ "retryable_exception",
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ )
+ def test_bulk_mutate_idempotent_retryable_request_errors(self, retryable_exception):
+ """Individual idempotent mutations should be retried if the request fails with a retryable error"""
+ from google.cloud.bigtable.data.exceptions import (
+ RetryExceptionGroup,
+ FailedMutationEntryError,
+ MutationsExceptionGroup,
+ )
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.side_effect = retryable_exception("mock")
+ with pytest.raises(MutationsExceptionGroup) as e:
+ mutation = mutations.SetCell(
+ "family", b"qualifier", b"value", timestamp_micros=123
+ )
+ entry = mutations.RowMutationEntry(b"row_key", [mutation])
+ assert mutation.is_idempotent() is True
+ table.bulk_mutate_rows([entry], operation_timeout=0.05)
+ assert len(e.value.exceptions) == 1
+ failed_exception = e.value.exceptions[0]
+ assert isinstance(failed_exception, FailedMutationEntryError)
+ assert "non-idempotent" not in str(failed_exception)
+ cause = failed_exception.__cause__
+ assert isinstance(cause, RetryExceptionGroup)
+ assert isinstance(cause.exceptions[0], retryable_exception)
+
+ @pytest.mark.parametrize(
+ "retryable_exception",
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ )
+ def test_bulk_mutate_rows_non_idempotent_retryable_errors(
+ self, retryable_exception
+ ):
+ """Non-Idempotent mutations should never be retried"""
+ from google.cloud.bigtable.data.exceptions import (
+ FailedMutationEntryError,
+ MutationsExceptionGroup,
+ )
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.side_effect = lambda *a, **k: self._mock_response(
+ [retryable_exception("mock")]
+ )
+ with pytest.raises(MutationsExceptionGroup) as e:
+ mutation = mutations.SetCell(
+ "family", b"qualifier", b"value", -1
+ )
+ entry = mutations.RowMutationEntry(b"row_key", [mutation])
+ assert mutation.is_idempotent() is False
+ table.bulk_mutate_rows([entry], operation_timeout=0.2)
+ assert len(e.value.exceptions) == 1
+ failed_exception = e.value.exceptions[0]
+ assert isinstance(failed_exception, FailedMutationEntryError)
+ assert "non-idempotent" in str(failed_exception)
+ cause = failed_exception.__cause__
+ assert isinstance(cause, retryable_exception)
+
+ @pytest.mark.parametrize(
+ "non_retryable_exception",
+ [
+ core_exceptions.OutOfRange,
+ core_exceptions.NotFound,
+ core_exceptions.FailedPrecondition,
+ RuntimeError,
+ ValueError,
+ ],
+ )
+ def test_bulk_mutate_rows_non_retryable_errors(self, non_retryable_exception):
+ """If the request fails with a non-retryable error, mutations should not be retried"""
+ from google.cloud.bigtable.data.exceptions import (
+ FailedMutationEntryError,
+ MutationsExceptionGroup,
+ )
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.side_effect = non_retryable_exception("mock")
+ with pytest.raises(MutationsExceptionGroup) as e:
+ mutation = mutations.SetCell(
+ "family", b"qualifier", b"value", timestamp_micros=123
+ )
+ entry = mutations.RowMutationEntry(b"row_key", [mutation])
+ assert mutation.is_idempotent() is True
+ table.bulk_mutate_rows([entry], operation_timeout=0.2)
+ assert len(e.value.exceptions) == 1
+ failed_exception = e.value.exceptions[0]
+ assert isinstance(failed_exception, FailedMutationEntryError)
+ assert "non-idempotent" not in str(failed_exception)
+ cause = failed_exception.__cause__
+ assert isinstance(cause, non_retryable_exception)
+
+ def test_bulk_mutate_error_index(self):
+ """Test partial failure, partial success. Errors should be associated with the correct index"""
+ from google.api_core.exceptions import (
+ DeadlineExceeded,
+ ServiceUnavailable,
+ FailedPrecondition,
+ )
+ from google.cloud.bigtable.data.exceptions import (
+ RetryExceptionGroup,
+ FailedMutationEntryError,
+ MutationsExceptionGroup,
+ )
+
+ with self._make_client(project="project") as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "mutate_rows"
+ ) as mock_gapic:
+ mock_gapic.side_effect = [
+ self._mock_response([None, ServiceUnavailable("mock"), None]),
+ self._mock_response([DeadlineExceeded("mock")]),
+ self._mock_response([FailedPrecondition("final")]),
+ ]
+ with pytest.raises(MutationsExceptionGroup) as e:
+ mutation = mutations.SetCell(
+ "family", b"qualifier", b"value", timestamp_micros=123
+ )
+ entries = [
+ mutations.RowMutationEntry(
+ f"row_key_{i}".encode(), [mutation]
+ )
+ for i in range(3)
+ ]
+ assert mutation.is_idempotent() is True
+ table.bulk_mutate_rows(entries, operation_timeout=1000)
+ assert len(e.value.exceptions) == 1
+ failed = e.value.exceptions[0]
+ assert isinstance(failed, FailedMutationEntryError)
+ assert failed.index == 1
+ assert failed.entry == entries[1]
+ cause = failed.__cause__
+ assert isinstance(cause, RetryExceptionGroup)
+ assert len(cause.exceptions) == 3
+ assert isinstance(cause.exceptions[0], ServiceUnavailable)
+ assert isinstance(cause.exceptions[1], DeadlineExceeded)
+ assert isinstance(cause.exceptions[2], FailedPrecondition)
+
+ def test_bulk_mutate_error_recovery(self):
+ """If an error occurs, then resolves, no exception should be raised"""
+ from google.api_core.exceptions import DeadlineExceeded
+
+ with self._make_client(project="project") as client:
+ table = client.get_table("instance", "table")
+ with mock.patch.object(client._gapic_client, "mutate_rows") as mock_gapic:
+ mock_gapic.side_effect = [
+ self._mock_response([DeadlineExceeded("mock")]),
+ self._mock_response([None]),
+ ]
+ mutation = mutations.SetCell(
+ "family", b"qualifier", b"value", timestamp_micros=123
+ )
+ entries = [
+ mutations.RowMutationEntry(f"row_key_{i}".encode(), [mutation])
+ for i in range(3)
+ ]
+ table.bulk_mutate_rows(entries, operation_timeout=1000)
+
+
+class TestCheckAndMutateRow:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @pytest.mark.parametrize("gapic_result", [True, False])
+ def test_check_and_mutate(self, gapic_result):
+ from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
+
+ app_profile = "app_profile_id"
+ with self._make_client() as client:
+ with client.get_table(
+ "instance", "table", app_profile_id=app_profile
+ ) as table:
+ with mock.patch.object(
+ client._gapic_client, "check_and_mutate_row"
+ ) as mock_gapic:
+ mock_gapic.return_value = CheckAndMutateRowResponse(
+ predicate_matched=gapic_result
+ )
+ row_key = b"row_key"
+ predicate = None
+ true_mutations = [mock.Mock()]
+ false_mutations = [mock.Mock(), mock.Mock()]
+ operation_timeout = 0.2
+ found = table.check_and_mutate_row(
+ row_key,
+ predicate,
+ true_case_mutations=true_mutations,
+ false_case_mutations=false_mutations,
+ operation_timeout=operation_timeout,
+ )
+ assert found == gapic_result
+ kwargs = mock_gapic.call_args[1]
+ assert kwargs["table_name"] == table.table_name
+ assert kwargs["row_key"] == row_key
+ assert kwargs["predicate_filter"] == predicate
+ assert kwargs["true_mutations"] == [
+ m._to_pb() for m in true_mutations
+ ]
+ assert kwargs["false_mutations"] == [
+ m._to_pb() for m in false_mutations
+ ]
+ assert kwargs["app_profile_id"] == app_profile
+ assert kwargs["timeout"] == operation_timeout
+ assert kwargs["retry"] is None
+
+ def test_check_and_mutate_bad_timeout(self):
+ """Should raise error if operation_timeout < 0"""
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with pytest.raises(ValueError) as e:
+ table.check_and_mutate_row(
+ b"row_key",
+ None,
+ true_case_mutations=[mock.Mock()],
+ false_case_mutations=[],
+ operation_timeout=-1,
+ )
+ assert str(e.value) == "operation_timeout must be greater than 0"
+
+ def test_check_and_mutate_single_mutations(self):
+ """if single mutations are passed, they should be internally wrapped in a list"""
+ from google.cloud.bigtable.data.mutations import SetCell
+ from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
+
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "check_and_mutate_row"
+ ) as mock_gapic:
+ mock_gapic.return_value = CheckAndMutateRowResponse(
+ predicate_matched=True
+ )
+ true_mutation = SetCell("family", b"qualifier", b"value")
+ false_mutation = SetCell("family", b"qualifier", b"value")
+ table.check_and_mutate_row(
+ b"row_key",
+ None,
+ true_case_mutations=true_mutation,
+ false_case_mutations=false_mutation,
+ )
+ kwargs = mock_gapic.call_args[1]
+ assert kwargs["true_mutations"] == [true_mutation._to_pb()]
+ assert kwargs["false_mutations"] == [false_mutation._to_pb()]
+
+ def test_check_and_mutate_predicate_object(self):
+ """predicate filter should be passed to gapic request"""
+ from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
+
+ mock_predicate = mock.Mock()
+ predicate_pb = {"predicate": "dict"}
+ mock_predicate._to_pb.return_value = predicate_pb
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "check_and_mutate_row"
+ ) as mock_gapic:
+ mock_gapic.return_value = CheckAndMutateRowResponse(
+ predicate_matched=True
+ )
+ table.check_and_mutate_row(
+ b"row_key", mock_predicate, false_case_mutations=[mock.Mock()]
+ )
+ kwargs = mock_gapic.call_args[1]
+ assert kwargs["predicate_filter"] == predicate_pb
+ assert mock_predicate._to_pb.call_count == 1
+ assert kwargs["retry"] is None
+
+ def test_check_and_mutate_mutations_parsing(self):
+ """mutations objects should be converted to protos"""
+ from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
+ from google.cloud.bigtable.data.mutations import DeleteAllFromRow
+
+ mutations = [mock.Mock() for _ in range(5)]
+ for idx, mutation in enumerate(mutations):
+ mutation._to_pb.return_value = f"fake {idx}"
+ mutations.append(DeleteAllFromRow())
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "check_and_mutate_row"
+ ) as mock_gapic:
+ mock_gapic.return_value = CheckAndMutateRowResponse(
+ predicate_matched=True
+ )
+ table.check_and_mutate_row(
+ b"row_key",
+ None,
+ true_case_mutations=mutations[0:2],
+ false_case_mutations=mutations[2:],
+ )
+ kwargs = mock_gapic.call_args[1]
+ assert kwargs["true_mutations"] == ["fake 0", "fake 1"]
+ assert kwargs["false_mutations"] == [
+ "fake 2",
+ "fake 3",
+ "fake 4",
+ DeleteAllFromRow()._to_pb(),
+ ]
+ assert all(
+ (mutation._to_pb.call_count == 1 for mutation in mutations[:5])
+ )
+
+
+class TestReadModifyWriteRow:
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ @pytest.mark.parametrize(
+ "call_rules,expected_rules",
+ [
+ (
+ AppendValueRule("f", "c", b"1"),
+ [AppendValueRule("f", "c", b"1")._to_pb()],
+ ),
+ (
+ [AppendValueRule("f", "c", b"1")],
+ [AppendValueRule("f", "c", b"1")._to_pb()],
+ ),
+ (IncrementRule("f", "c", 1), [IncrementRule("f", "c", 1)._to_pb()]),
+ (
+ [AppendValueRule("f", "c", b"1"), IncrementRule("f", "c", 1)],
+ [
+ AppendValueRule("f", "c", b"1")._to_pb(),
+ IncrementRule("f", "c", 1)._to_pb(),
+ ],
+ ),
+ ],
+ )
+ def test_read_modify_write_call_rule_args(self, call_rules, expected_rules):
+ """Test that the gapic call is called with given rules"""
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with mock.patch.object(
+ client._gapic_client, "read_modify_write_row"
+ ) as mock_gapic:
+ table.read_modify_write_row("key", call_rules)
+ assert mock_gapic.call_count == 1
+ found_kwargs = mock_gapic.call_args_list[0][1]
+ assert found_kwargs["rules"] == expected_rules
+ assert found_kwargs["retry"] is None
+
+ @pytest.mark.parametrize("rules", [[], None])
+ def test_read_modify_write_no_rules(self, rules):
+ with self._make_client() as client:
+ with client.get_table("instance", "table") as table:
+ with pytest.raises(ValueError) as e:
+ table.read_modify_write_row("key", rules=rules)
+ assert e.value.args[0] == "rules must contain at least one item"
+
+ def test_read_modify_write_call_defaults(self):
+ instance = "instance1"
+ table_id = "table1"
+ project = "project1"
+ row_key = "row_key1"
+ with self._make_client(project=project) as client:
+ with client.get_table(instance, table_id) as table:
+ with mock.patch.object(
+ client._gapic_client, "read_modify_write_row"
+ ) as mock_gapic:
+ table.read_modify_write_row(row_key, mock.Mock())
+ assert mock_gapic.call_count == 1
+ kwargs = mock_gapic.call_args_list[0][1]
+ assert (
+ kwargs["table_name"]
+ == f"projects/{project}/instances/{instance}/tables/{table_id}"
+ )
+ assert kwargs["app_profile_id"] is None
+ assert kwargs["row_key"] == row_key.encode()
+ assert kwargs["timeout"] > 1
+
+ def test_read_modify_write_call_overrides(self):
+ row_key = b"row_key1"
+ expected_timeout = 12345
+ profile_id = "profile1"
+ with self._make_client() as client:
+ with client.get_table(
+ "instance", "table_id", app_profile_id=profile_id
+ ) as table:
+ with mock.patch.object(
+ client._gapic_client, "read_modify_write_row"
+ ) as mock_gapic:
+ table.read_modify_write_row(
+ row_key, mock.Mock(), operation_timeout=expected_timeout
+ )
+ assert mock_gapic.call_count == 1
+ kwargs = mock_gapic.call_args_list[0][1]
+ assert kwargs["app_profile_id"] is profile_id
+ assert kwargs["row_key"] == row_key
+ assert kwargs["timeout"] == expected_timeout
+
+ def test_read_modify_write_string_key(self):
+ row_key = "string_row_key1"
+ with self._make_client() as client:
+ with client.get_table("instance", "table_id") as table:
+ with mock.patch.object(
+ client._gapic_client, "read_modify_write_row"
+ ) as mock_gapic:
+ table.read_modify_write_row(row_key, mock.Mock())
+ assert mock_gapic.call_count == 1
+ kwargs = mock_gapic.call_args_list[0][1]
+ assert kwargs["row_key"] == row_key.encode()
+
+ def test_read_modify_write_row_building(self):
+ """results from gapic call should be used to construct row"""
+ from google.cloud.bigtable.data.row import Row
+ from google.cloud.bigtable_v2.types import ReadModifyWriteRowResponse
+ from google.cloud.bigtable_v2.types import Row as RowPB
+
+ mock_response = ReadModifyWriteRowResponse(row=RowPB())
+ with self._make_client() as client:
+ with client.get_table("instance", "table_id") as table:
+ with mock.patch.object(
+ client._gapic_client, "read_modify_write_row"
+ ) as mock_gapic:
+ with mock.patch.object(Row, "_from_pb") as constructor_mock:
+ mock_gapic.return_value = mock_response
+ table.read_modify_write_row("key", mock.Mock())
+ assert constructor_mock.call_count == 1
+ constructor_mock.assert_called_once_with(mock_response.row)
+
+
+class TestExecuteQuery:
+ TABLE_NAME = "TABLE_NAME"
+ INSTANCE_NAME = "INSTANCE_NAME"
+
+ def _make_client(self, *args, **kwargs):
+ return CrossSync._Sync_Impl.TestBigtableDataClient._make_client(*args, **kwargs)
+
+ def _make_gapic_stream(self, sample_list: list["ExecuteQueryResponse" | Exception]):
+ class MockStream:
+ def __init__(self, sample_list):
+ self.sample_list = sample_list
+
+ def __aiter__(self):
+ return self
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ if not self.sample_list:
+ raise CrossSync._Sync_Impl.StopIteration
+ value = self.sample_list.pop(0)
+ if isinstance(value, Exception):
+ raise value
+ return value
+
+ def __anext__(self):
+ return self.__next__()
+
+ return MockStream(sample_list)
+
+ def resonse_with_metadata(self):
+ from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
+
+ schema = {"a": "string_type", "b": "int64_type"}
+ return ExecuteQueryResponse(
+ {
+ "metadata": {
+ "proto_schema": {
+ "columns": [
+ {"name": name, "type_": {_type: {}}}
+ for (name, _type) in schema.items()
+ ]
+ }
+ }
+ }
+ )
+
+ def resonse_with_result(self, *args, resume_token=None):
+ from google.cloud.bigtable_v2.types.data import ProtoRows, Value as PBValue
+ from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
+
+ if resume_token is None:
+ resume_token_dict = {}
+ else:
+ resume_token_dict = {"resume_token": resume_token}
+ values = []
+ for column_value in args:
+ if column_value is None:
+ pb_value = PBValue({})
+ else:
+ pb_value = PBValue(
+ {
+ "int_value"
+ if isinstance(column_value, int)
+ else "string_value": column_value
+ }
+ )
+ values.append(pb_value)
+ rows = ProtoRows(values=values)
+ return ExecuteQueryResponse(
+ {
+ "results": {
+ "proto_rows_batch": {"batch_data": ProtoRows.serialize(rows)},
+ **resume_token_dict,
+ }
+ }
+ )
+
+ def test_execute_query(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r for r in result]
+ assert results[0]["a"] == "test"
+ assert results[0]["b"] == 8
+ assert results[1]["a"] == "test2"
+ assert results[1]["b"] == 9
+ assert results[2]["a"] == "test3"
+ assert results[2]["b"] is None
+ assert execute_query_mock.call_count == 1
+
+ def test_execute_query_with_params(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME} WHERE b=@b",
+ self.INSTANCE_NAME,
+ parameters={"b": 9},
+ )
+ results = [r for r in result]
+ assert len(results) == 1
+ assert results[0]["a"] == "test2"
+ assert results[0]["b"] == 9
+ assert execute_query_mock.call_count == 1
+
+ def test_execute_query_error_before_metadata(self):
+ from google.api_core.exceptions import DeadlineExceeded
+
+ values = [
+ DeadlineExceeded(""),
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r for r in result]
+ assert len(results) == 3
+ assert execute_query_mock.call_count == 2
+
+ def test_execute_query_error_after_metadata(self):
+ from google.api_core.exceptions import DeadlineExceeded
+
+ values = [
+ self.resonse_with_metadata(),
+ DeadlineExceeded(""),
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r for r in result]
+ assert len(results) == 3
+ assert execute_query_mock.call_count == 2
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == []
+
+ def test_execute_query_with_retries(self):
+ from google.api_core.exceptions import DeadlineExceeded
+
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ DeadlineExceeded(""),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ DeadlineExceeded(""),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r for r in result]
+ assert results[0]["a"] == "test"
+ assert results[0]["b"] == 8
+ assert results[1]["a"] == "test2"
+ assert results[1]["b"] == 9
+ assert results[2]["a"] == "test3"
+ assert results[2]["b"] is None
+ assert len(results) == 3
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == [b"r1", b"r2"]
+
+ @pytest.mark.parametrize(
+ "exception",
+ [
+ core_exceptions.DeadlineExceeded(""),
+ core_exceptions.Aborted(""),
+ core_exceptions.ServiceUnavailable(""),
+ ],
+ )
+ def test_execute_query_retryable_error(self, exception):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test", resume_token=b"t1"),
+ exception,
+ self.resonse_with_result(8, resume_token=b"t2"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r for r in result]
+ assert len(results) == 1
+ assert execute_query_mock.call_count == 2
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == [b"t1"]
+
+ def test_execute_query_retry_partial_row(self):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test", resume_token=b"t1"),
+ core_exceptions.DeadlineExceeded(""),
+ self.resonse_with_result(8, resume_token=b"t2"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ results = [r for r in result]
+ assert results[0]["a"] == "test"
+ assert results[0]["b"] == 8
+ assert execute_query_mock.call_count == 2
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == [b"t1"]
+
+ @pytest.mark.parametrize(
+ "ExceptionType",
+ [
+ core_exceptions.InvalidArgument,
+ core_exceptions.FailedPrecondition,
+ core_exceptions.PermissionDenied,
+ core_exceptions.MethodNotImplemented,
+ core_exceptions.Cancelled,
+ core_exceptions.AlreadyExists,
+ core_exceptions.OutOfRange,
+ core_exceptions.DataLoss,
+ core_exceptions.Unauthenticated,
+ core_exceptions.NotFound,
+ core_exceptions.ResourceExhausted,
+ core_exceptions.Unknown,
+ core_exceptions.InternalServerError,
+ ],
+ )
+ def test_execute_query_non_retryable(self, ExceptionType):
+ values = [
+ self.resonse_with_metadata(),
+ self.resonse_with_result("test"),
+ self.resonse_with_result(8, resume_token=b"r1"),
+ ExceptionType(""),
+ self.resonse_with_result("test2"),
+ self.resonse_with_result(9, resume_token=b"r2"),
+ self.resonse_with_result("test3"),
+ self.resonse_with_result(None, resume_token=b"r3"),
+ ]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ result = client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ r = CrossSync._Sync_Impl.next(result)
+ assert r["a"] == "test"
+ assert r["b"] == 8
+ with pytest.raises(ExceptionType):
+ r = CrossSync._Sync_Impl.next(result)
+ assert execute_query_mock.call_count == 1
+ requests = [args[0][0] for args in execute_query_mock.call_args_list]
+ resume_tokens = [r.resume_token for r in requests if r.resume_token]
+ assert resume_tokens == []
+
+ def test_execute_query_metadata_received_multiple_times_detected(self):
+ values = [self.resonse_with_metadata(), self.resonse_with_metadata()]
+ client = self._make_client()
+ with mock.patch.object(
+ client._gapic_client, "execute_query", CrossSync._Sync_Impl.Mock()
+ ) as execute_query_mock:
+ execute_query_mock.return_value = self._make_gapic_stream(values)
+ with pytest.raises(
+ Exception, match="Invalid ExecuteQuery response received"
+ ):
+ [
+ r
+ for r in client.execute_query(
+ f"SELECT a, b FROM {self.TABLE_NAME}", self.INSTANCE_NAME
+ )
+ ]
diff --git a/tests/unit/data/_sync_autogen/test_mutations_batcher.py b/tests/unit/data/_sync_autogen/test_mutations_batcher.py
new file mode 100644
index 000000000..59ea621ac
--- /dev/null
+++ b/tests/unit/data/_sync_autogen/test_mutations_batcher.py
@@ -0,0 +1,1078 @@
+# Copyright 2024 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.
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+import pytest
+import mock
+import asyncio
+import time
+import google.api_core.exceptions as core_exceptions
+import google.api_core.retry
+from google.cloud.bigtable.data.exceptions import _MutateRowsIncomplete
+from google.cloud.bigtable.data import TABLE_DEFAULT
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+
+class Test_FlowControl:
+ @staticmethod
+ def _target_class():
+ return CrossSync._Sync_Impl._FlowControl
+
+ def _make_one(self, max_mutation_count=10, max_mutation_bytes=100):
+ return self._target_class()(max_mutation_count, max_mutation_bytes)
+
+ @staticmethod
+ def _make_mutation(count=1, size=1):
+ mutation = mock.Mock()
+ mutation.size.return_value = size
+ mutation.mutations = [mock.Mock()] * count
+ return mutation
+
+ def test_ctor(self):
+ max_mutation_count = 9
+ max_mutation_bytes = 19
+ instance = self._make_one(max_mutation_count, max_mutation_bytes)
+ assert instance._max_mutation_count == max_mutation_count
+ assert instance._max_mutation_bytes == max_mutation_bytes
+ assert instance._in_flight_mutation_count == 0
+ assert instance._in_flight_mutation_bytes == 0
+ assert isinstance(instance._capacity_condition, CrossSync._Sync_Impl.Condition)
+
+ def test_ctor_invalid_values(self):
+ """Test that values are positive, and fit within expected limits"""
+ with pytest.raises(ValueError) as e:
+ self._make_one(0, 1)
+ assert "max_mutation_count must be greater than 0" in str(e.value)
+ with pytest.raises(ValueError) as e:
+ self._make_one(1, 0)
+ assert "max_mutation_bytes must be greater than 0" in str(e.value)
+
+ @pytest.mark.parametrize(
+ "max_count,max_size,existing_count,existing_size,new_count,new_size,expected",
+ [
+ (1, 1, 0, 0, 0, 0, True),
+ (1, 1, 1, 1, 1, 1, False),
+ (10, 10, 0, 0, 0, 0, True),
+ (10, 10, 0, 0, 9, 9, True),
+ (10, 10, 0, 0, 11, 9, True),
+ (10, 10, 0, 1, 11, 9, True),
+ (10, 10, 1, 0, 11, 9, False),
+ (10, 10, 0, 0, 9, 11, True),
+ (10, 10, 1, 0, 9, 11, True),
+ (10, 10, 0, 1, 9, 11, False),
+ (10, 1, 0, 0, 1, 0, True),
+ (1, 10, 0, 0, 0, 8, True),
+ (float("inf"), float("inf"), 0, 0, 10000000000.0, 10000000000.0, True),
+ (8, 8, 0, 0, 10000000000.0, 10000000000.0, True),
+ (12, 12, 6, 6, 5, 5, True),
+ (12, 12, 5, 5, 6, 6, True),
+ (12, 12, 6, 6, 6, 6, True),
+ (12, 12, 6, 6, 7, 7, False),
+ (12, 12, 0, 0, 13, 13, True),
+ (12, 12, 12, 0, 0, 13, True),
+ (12, 12, 0, 12, 13, 0, True),
+ (12, 12, 1, 1, 13, 13, False),
+ (12, 12, 1, 1, 0, 13, False),
+ (12, 12, 1, 1, 13, 0, False),
+ ],
+ )
+ def test__has_capacity(
+ self,
+ max_count,
+ max_size,
+ existing_count,
+ existing_size,
+ new_count,
+ new_size,
+ expected,
+ ):
+ """_has_capacity should return True if the new mutation will will not exceed the max count or size"""
+ instance = self._make_one(max_count, max_size)
+ instance._in_flight_mutation_count = existing_count
+ instance._in_flight_mutation_bytes = existing_size
+ assert instance._has_capacity(new_count, new_size) == expected
+
+ @pytest.mark.parametrize(
+ "existing_count,existing_size,added_count,added_size,new_count,new_size",
+ [
+ (0, 0, 0, 0, 0, 0),
+ (2, 2, 1, 1, 1, 1),
+ (2, 0, 1, 0, 1, 0),
+ (0, 2, 0, 1, 0, 1),
+ (10, 10, 0, 0, 10, 10),
+ (10, 10, 5, 5, 5, 5),
+ (0, 0, 1, 1, -1, -1),
+ ],
+ )
+ def test_remove_from_flow_value_update(
+ self,
+ existing_count,
+ existing_size,
+ added_count,
+ added_size,
+ new_count,
+ new_size,
+ ):
+ """completed mutations should lower the inflight values"""
+ instance = self._make_one()
+ instance._in_flight_mutation_count = existing_count
+ instance._in_flight_mutation_bytes = existing_size
+ mutation = self._make_mutation(added_count, added_size)
+ instance.remove_from_flow(mutation)
+ assert instance._in_flight_mutation_count == new_count
+ assert instance._in_flight_mutation_bytes == new_size
+
+ def test__remove_from_flow_unlock(self):
+ """capacity condition should notify after mutation is complete"""
+ instance = self._make_one(10, 10)
+ instance._in_flight_mutation_count = 10
+ instance._in_flight_mutation_bytes = 10
+
+ def task_routine():
+ with instance._capacity_condition:
+ instance._capacity_condition.wait_for(
+ lambda: instance._has_capacity(1, 1)
+ )
+
+ import threading
+
+ thread = threading.Thread(target=task_routine)
+ thread.start()
+ task_alive = thread.is_alive
+ CrossSync._Sync_Impl.sleep(0.05)
+ assert task_alive() is True
+ mutation = self._make_mutation(count=0, size=5)
+ instance.remove_from_flow([mutation])
+ CrossSync._Sync_Impl.sleep(0.05)
+ assert instance._in_flight_mutation_count == 10
+ assert instance._in_flight_mutation_bytes == 5
+ assert task_alive() is True
+ instance._in_flight_mutation_bytes = 10
+ mutation = self._make_mutation(count=5, size=0)
+ instance.remove_from_flow([mutation])
+ CrossSync._Sync_Impl.sleep(0.05)
+ assert instance._in_flight_mutation_count == 5
+ assert instance._in_flight_mutation_bytes == 10
+ assert task_alive() is True
+ instance._in_flight_mutation_count = 10
+ mutation = self._make_mutation(count=5, size=5)
+ instance.remove_from_flow([mutation])
+ CrossSync._Sync_Impl.sleep(0.05)
+ assert instance._in_flight_mutation_count == 5
+ assert instance._in_flight_mutation_bytes == 5
+ assert task_alive() is False
+
+ @pytest.mark.parametrize(
+ "mutations,count_cap,size_cap,expected_results",
+ [
+ ([(5, 5), (1, 1), (1, 1)], 10, 10, [[(5, 5), (1, 1), (1, 1)]]),
+ ([(1, 1), (1, 1), (1, 1)], 1, 1, [[(1, 1)], [(1, 1)], [(1, 1)]]),
+ ([(1, 1), (1, 1), (1, 1)], 2, 10, [[(1, 1), (1, 1)], [(1, 1)]]),
+ ([(1, 1), (1, 1), (1, 1)], 10, 2, [[(1, 1), (1, 1)], [(1, 1)]]),
+ (
+ [(1, 1), (5, 5), (4, 1), (1, 4), (1, 1)],
+ 5,
+ 5,
+ [[(1, 1)], [(5, 5)], [(4, 1), (1, 4)], [(1, 1)]],
+ ),
+ ],
+ )
+ def test_add_to_flow(self, mutations, count_cap, size_cap, expected_results):
+ """Test batching with various flow control settings"""
+ mutation_objs = [self._make_mutation(count=m[0], size=m[1]) for m in mutations]
+ instance = self._make_one(count_cap, size_cap)
+ i = 0
+ for batch in instance.add_to_flow(mutation_objs):
+ expected_batch = expected_results[i]
+ assert len(batch) == len(expected_batch)
+ for j in range(len(expected_batch)):
+ assert len(batch[j].mutations) == expected_batch[j][0]
+ assert batch[j].size() == expected_batch[j][1]
+ instance.remove_from_flow(batch)
+ i += 1
+ assert i == len(expected_results)
+
+ @pytest.mark.parametrize(
+ "mutations,max_limit,expected_results",
+ [
+ ([(1, 1)] * 11, 10, [[(1, 1)] * 10, [(1, 1)]]),
+ ([(1, 1)] * 10, 1, [[(1, 1)] for _ in range(10)]),
+ ([(1, 1)] * 10, 2, [[(1, 1), (1, 1)] for _ in range(5)]),
+ ],
+ )
+ def test_add_to_flow_max_mutation_limits(
+ self, mutations, max_limit, expected_results
+ ):
+ """Test flow control running up against the max API limit
+ Should submit request early, even if the flow control has room for more"""
+ subpath = "_async" if CrossSync._Sync_Impl.is_async else "_sync_autogen"
+ path = f"google.cloud.bigtable.data.{subpath}.mutations_batcher._MUTATE_ROWS_REQUEST_MUTATION_LIMIT"
+ with mock.patch(path, max_limit):
+ mutation_objs = [
+ self._make_mutation(count=m[0], size=m[1]) for m in mutations
+ ]
+ instance = self._make_one(float("inf"), float("inf"))
+ i = 0
+ for batch in instance.add_to_flow(mutation_objs):
+ expected_batch = expected_results[i]
+ assert len(batch) == len(expected_batch)
+ for j in range(len(expected_batch)):
+ assert len(batch[j].mutations) == expected_batch[j][0]
+ assert batch[j].size() == expected_batch[j][1]
+ instance.remove_from_flow(batch)
+ i += 1
+ assert i == len(expected_results)
+
+ def test_add_to_flow_oversize(self):
+ """mutations over the flow control limits should still be accepted"""
+ instance = self._make_one(2, 3)
+ large_size_mutation = self._make_mutation(count=1, size=10)
+ large_count_mutation = self._make_mutation(count=10, size=1)
+ results = [out for out in instance.add_to_flow([large_size_mutation])]
+ assert len(results) == 1
+ instance.remove_from_flow(results[0])
+ count_results = [out for out in instance.add_to_flow(large_count_mutation)]
+ assert len(count_results) == 1
+
+
+class TestMutationsBatcher:
+ def _get_target_class(self):
+ return CrossSync._Sync_Impl.MutationsBatcher
+
+ def _make_one(self, table=None, **kwargs):
+ from google.api_core.exceptions import DeadlineExceeded
+ from google.api_core.exceptions import ServiceUnavailable
+
+ if table is None:
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 10
+ table.default_mutate_rows_attempt_timeout = 10
+ table.default_mutate_rows_retryable_errors = (
+ DeadlineExceeded,
+ ServiceUnavailable,
+ )
+ return self._get_target_class()(table, **kwargs)
+
+ @staticmethod
+ def _make_mutation(count=1, size=1):
+ mutation = mock.Mock()
+ mutation.size.return_value = size
+ mutation.mutations = [mock.Mock()] * count
+ return mutation
+
+ def test_ctor_defaults(self):
+ with mock.patch.object(
+ self._get_target_class(),
+ "_timer_routine",
+ return_value=CrossSync._Sync_Impl.Future(),
+ ) as flush_timer_mock:
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 10
+ table.default_mutate_rows_attempt_timeout = 8
+ table.default_mutate_rows_retryable_errors = [Exception]
+ with self._make_one(table) as instance:
+ assert instance._table == table
+ assert instance.closed is False
+ assert instance._flush_jobs == set()
+ assert len(instance._staged_entries) == 0
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert instance._exception_list_limit == 10
+ assert instance._exceptions_since_last_raise == 0
+ assert instance._flow_control._max_mutation_count == 100000
+ assert instance._flow_control._max_mutation_bytes == 104857600
+ assert instance._flow_control._in_flight_mutation_count == 0
+ assert instance._flow_control._in_flight_mutation_bytes == 0
+ assert instance._entries_processed_since_last_raise == 0
+ assert (
+ instance._operation_timeout
+ == table.default_mutate_rows_operation_timeout
+ )
+ assert (
+ instance._attempt_timeout
+ == table.default_mutate_rows_attempt_timeout
+ )
+ assert (
+ instance._retryable_errors
+ == table.default_mutate_rows_retryable_errors
+ )
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert flush_timer_mock.call_count == 1
+ assert flush_timer_mock.call_args[0][0] == 5
+ assert isinstance(instance._flush_timer, CrossSync._Sync_Impl.Future)
+
+ def test_ctor_explicit(self):
+ """Test with explicit parameters"""
+ with mock.patch.object(
+ self._get_target_class(),
+ "_timer_routine",
+ return_value=CrossSync._Sync_Impl.Future(),
+ ) as flush_timer_mock:
+ table = mock.Mock()
+ flush_interval = 20
+ flush_limit_count = 17
+ flush_limit_bytes = 19
+ flow_control_max_mutation_count = 1001
+ flow_control_max_bytes = 12
+ operation_timeout = 11
+ attempt_timeout = 2
+ retryable_errors = [Exception]
+ with self._make_one(
+ table,
+ flush_interval=flush_interval,
+ flush_limit_mutation_count=flush_limit_count,
+ flush_limit_bytes=flush_limit_bytes,
+ flow_control_max_mutation_count=flow_control_max_mutation_count,
+ flow_control_max_bytes=flow_control_max_bytes,
+ batch_operation_timeout=operation_timeout,
+ batch_attempt_timeout=attempt_timeout,
+ batch_retryable_errors=retryable_errors,
+ ) as instance:
+ assert instance._table == table
+ assert instance.closed is False
+ assert instance._flush_jobs == set()
+ assert len(instance._staged_entries) == 0
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert instance._exception_list_limit == 10
+ assert instance._exceptions_since_last_raise == 0
+ assert (
+ instance._flow_control._max_mutation_count
+ == flow_control_max_mutation_count
+ )
+ assert (
+ instance._flow_control._max_mutation_bytes == flow_control_max_bytes
+ )
+ assert instance._flow_control._in_flight_mutation_count == 0
+ assert instance._flow_control._in_flight_mutation_bytes == 0
+ assert instance._entries_processed_since_last_raise == 0
+ assert instance._operation_timeout == operation_timeout
+ assert instance._attempt_timeout == attempt_timeout
+ assert instance._retryable_errors == retryable_errors
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert flush_timer_mock.call_count == 1
+ assert flush_timer_mock.call_args[0][0] == flush_interval
+ assert isinstance(instance._flush_timer, CrossSync._Sync_Impl.Future)
+
+ def test_ctor_no_flush_limits(self):
+ """Test with None for flush limits"""
+ with mock.patch.object(
+ self._get_target_class(),
+ "_timer_routine",
+ return_value=CrossSync._Sync_Impl.Future(),
+ ) as flush_timer_mock:
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 10
+ table.default_mutate_rows_attempt_timeout = 8
+ table.default_mutate_rows_retryable_errors = ()
+ flush_interval = None
+ flush_limit_count = None
+ flush_limit_bytes = None
+ with self._make_one(
+ table,
+ flush_interval=flush_interval,
+ flush_limit_mutation_count=flush_limit_count,
+ flush_limit_bytes=flush_limit_bytes,
+ ) as instance:
+ assert instance._table == table
+ assert instance.closed is False
+ assert instance._staged_entries == []
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert instance._exception_list_limit == 10
+ assert instance._exceptions_since_last_raise == 0
+ assert instance._flow_control._in_flight_mutation_count == 0
+ assert instance._flow_control._in_flight_mutation_bytes == 0
+ assert instance._entries_processed_since_last_raise == 0
+ CrossSync._Sync_Impl.yield_to_event_loop()
+ assert flush_timer_mock.call_count == 1
+ assert flush_timer_mock.call_args[0][0] is None
+ assert isinstance(instance._flush_timer, CrossSync._Sync_Impl.Future)
+
+ def test_ctor_invalid_values(self):
+ """Test that timeout values are positive, and fit within expected limits"""
+ with pytest.raises(ValueError) as e:
+ self._make_one(batch_operation_timeout=-1)
+ assert "operation_timeout must be greater than 0" in str(e.value)
+ with pytest.raises(ValueError) as e:
+ self._make_one(batch_attempt_timeout=-1)
+ assert "attempt_timeout must be greater than 0" in str(e.value)
+
+ def test_default_argument_consistency(self):
+ """We supply default arguments in MutationsBatcherAsync.__init__, and in
+ table.mutations_batcher. Make sure any changes to defaults are applied to
+ both places"""
+ import inspect
+
+ get_batcher_signature = dict(
+ inspect.signature(CrossSync._Sync_Impl.Table.mutations_batcher).parameters
+ )
+ get_batcher_signature.pop("self")
+ batcher_init_signature = dict(
+ inspect.signature(self._get_target_class()).parameters
+ )
+ batcher_init_signature.pop("table")
+ assert len(get_batcher_signature.keys()) == len(batcher_init_signature.keys())
+ assert len(get_batcher_signature) == 8
+ assert set(get_batcher_signature.keys()) == set(batcher_init_signature.keys())
+ for arg_name in get_batcher_signature.keys():
+ assert (
+ get_batcher_signature[arg_name].default
+ == batcher_init_signature[arg_name].default
+ )
+
+ @pytest.mark.parametrize("input_val", [None, 0, -1])
+ def test__start_flush_timer_w_empty_input(self, input_val):
+ """Empty/invalid timer should return immediately"""
+ with mock.patch.object(
+ self._get_target_class(), "_schedule_flush"
+ ) as flush_mock:
+ with self._make_one() as instance:
+ (sleep_obj, sleep_method) = (instance._closed, "wait")
+ with mock.patch.object(sleep_obj, sleep_method) as sleep_mock:
+ result = instance._timer_routine(input_val)
+ assert sleep_mock.call_count == 0
+ assert flush_mock.call_count == 0
+ assert result is None
+
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+ def test__start_flush_timer_call_when_closed(self):
+ """closed batcher's timer should return immediately"""
+ with mock.patch.object(
+ self._get_target_class(), "_schedule_flush"
+ ) as flush_mock:
+ with self._make_one() as instance:
+ instance.close()
+ flush_mock.reset_mock()
+ (sleep_obj, sleep_method) = (instance._closed, "wait")
+ with mock.patch.object(sleep_obj, sleep_method) as sleep_mock:
+ instance._timer_routine(10)
+ assert sleep_mock.call_count == 0
+ assert flush_mock.call_count == 0
+
+ @pytest.mark.parametrize("num_staged", [0, 1, 10])
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+ def test__flush_timer(self, num_staged):
+ """Timer should continue to call _schedule_flush in a loop"""
+ from google.cloud.bigtable.data._cross_sync import CrossSync
+
+ with mock.patch.object(
+ self._get_target_class(), "_schedule_flush"
+ ) as flush_mock:
+ expected_sleep = 12
+ with self._make_one(flush_interval=expected_sleep) as instance:
+ loop_num = 3
+ instance._staged_entries = [mock.Mock()] * num_staged
+ with mock.patch.object(
+ CrossSync._Sync_Impl, "event_wait"
+ ) as sleep_mock:
+ sleep_mock.side_effect = [None] * loop_num + [TabError("expected")]
+ with pytest.raises(TabError):
+ self._get_target_class()._timer_routine(
+ instance, expected_sleep
+ )
+ assert sleep_mock.call_count == loop_num + 1
+ sleep_kwargs = sleep_mock.call_args[1]
+ assert sleep_kwargs["timeout"] == expected_sleep
+ assert flush_mock.call_count == (0 if num_staged == 0 else loop_num)
+
+ def test__flush_timer_close(self):
+ """Timer should continue terminate after close"""
+ with mock.patch.object(self._get_target_class(), "_schedule_flush"):
+ with self._make_one() as instance:
+ assert instance._flush_timer.done() is False
+ instance.close()
+ assert instance._flush_timer.done() is True
+
+ def test_append_closed(self):
+ """Should raise exception"""
+ instance = self._make_one()
+ instance.close()
+ with pytest.raises(RuntimeError):
+ instance.append(mock.Mock())
+
+ def test_append_wrong_mutation(self):
+ """Mutation objects should raise an exception.
+ Only support RowMutationEntry"""
+ from google.cloud.bigtable.data.mutations import DeleteAllFromRow
+
+ with self._make_one() as instance:
+ expected_error = "invalid mutation type: DeleteAllFromRow. Only RowMutationEntry objects are supported by batcher"
+ with pytest.raises(ValueError) as e:
+ instance.append(DeleteAllFromRow())
+ assert str(e.value) == expected_error
+
+ def test_append_outside_flow_limits(self):
+ """entries larger than mutation limits are still processed"""
+ with self._make_one(
+ flow_control_max_mutation_count=1, flow_control_max_bytes=1
+ ) as instance:
+ oversized_entry = self._make_mutation(count=0, size=2)
+ instance.append(oversized_entry)
+ assert instance._staged_entries == [oversized_entry]
+ assert instance._staged_count == 0
+ assert instance._staged_bytes == 2
+ instance._staged_entries = []
+ with self._make_one(
+ flow_control_max_mutation_count=1, flow_control_max_bytes=1
+ ) as instance:
+ overcount_entry = self._make_mutation(count=2, size=0)
+ instance.append(overcount_entry)
+ assert instance._staged_entries == [overcount_entry]
+ assert instance._staged_count == 2
+ assert instance._staged_bytes == 0
+ instance._staged_entries = []
+
+ def test_append_flush_runs_after_limit_hit(self):
+ """If the user appends a bunch of entries above the flush limits back-to-back,
+ it should still flush in a single task"""
+ with mock.patch.object(
+ self._get_target_class(), "_execute_mutate_rows"
+ ) as op_mock:
+ with self._make_one(flush_limit_bytes=100) as instance:
+
+ def mock_call(*args, **kwargs):
+ return []
+
+ op_mock.side_effect = mock_call
+ instance.append(self._make_mutation(size=99))
+ num_entries = 10
+ for _ in range(num_entries):
+ instance.append(self._make_mutation(size=1))
+ instance._wait_for_batch_results(*instance._flush_jobs)
+ assert op_mock.call_count == 1
+ sent_batch = op_mock.call_args[0][0]
+ assert len(sent_batch) == 2
+ assert len(instance._staged_entries) == num_entries - 1
+
+ @pytest.mark.parametrize(
+ "flush_count,flush_bytes,mutation_count,mutation_bytes,expect_flush",
+ [
+ (10, 10, 1, 1, False),
+ (10, 10, 9, 9, False),
+ (10, 10, 10, 1, True),
+ (10, 10, 1, 10, True),
+ (10, 10, 10, 10, True),
+ (1, 1, 10, 10, True),
+ (1, 1, 0, 0, False),
+ ],
+ )
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+ def test_append(
+ self, flush_count, flush_bytes, mutation_count, mutation_bytes, expect_flush
+ ):
+ """test appending different mutations, and checking if it causes a flush"""
+ with self._make_one(
+ flush_limit_mutation_count=flush_count, flush_limit_bytes=flush_bytes
+ ) as instance:
+ assert instance._staged_count == 0
+ assert instance._staged_bytes == 0
+ assert instance._staged_entries == []
+ mutation = self._make_mutation(count=mutation_count, size=mutation_bytes)
+ with mock.patch.object(instance, "_schedule_flush") as flush_mock:
+ instance.append(mutation)
+ assert flush_mock.call_count == bool(expect_flush)
+ assert instance._staged_count == mutation_count
+ assert instance._staged_bytes == mutation_bytes
+ assert instance._staged_entries == [mutation]
+ instance._staged_entries = []
+
+ def test_append_multiple_sequentially(self):
+ """Append multiple mutations"""
+ with self._make_one(
+ flush_limit_mutation_count=8, flush_limit_bytes=8
+ ) as instance:
+ assert instance._staged_count == 0
+ assert instance._staged_bytes == 0
+ assert instance._staged_entries == []
+ mutation = self._make_mutation(count=2, size=3)
+ with mock.patch.object(instance, "_schedule_flush") as flush_mock:
+ instance.append(mutation)
+ assert flush_mock.call_count == 0
+ assert instance._staged_count == 2
+ assert instance._staged_bytes == 3
+ assert len(instance._staged_entries) == 1
+ instance.append(mutation)
+ assert flush_mock.call_count == 0
+ assert instance._staged_count == 4
+ assert instance._staged_bytes == 6
+ assert len(instance._staged_entries) == 2
+ instance.append(mutation)
+ assert flush_mock.call_count == 1
+ assert instance._staged_count == 6
+ assert instance._staged_bytes == 9
+ assert len(instance._staged_entries) == 3
+ instance._staged_entries = []
+
+ def test_flush_flow_control_concurrent_requests(self):
+ """requests should happen in parallel if flow control breaks up single flush into batches"""
+ import time
+
+ num_calls = 10
+ fake_mutations = [self._make_mutation(count=1) for _ in range(num_calls)]
+ with self._make_one(flow_control_max_mutation_count=1) as instance:
+ with mock.patch.object(
+ instance, "_execute_mutate_rows", CrossSync._Sync_Impl.Mock()
+ ) as op_mock:
+
+ def mock_call(*args, **kwargs):
+ CrossSync._Sync_Impl.sleep(0.1)
+ return []
+
+ op_mock.side_effect = mock_call
+ start_time = time.monotonic()
+ instance._staged_entries = fake_mutations
+ instance._schedule_flush()
+ CrossSync._Sync_Impl.sleep(0.01)
+ for i in range(num_calls):
+ instance._flow_control.remove_from_flow(
+ [self._make_mutation(count=1)]
+ )
+ CrossSync._Sync_Impl.sleep(0.01)
+ instance._wait_for_batch_results(*instance._flush_jobs)
+ duration = time.monotonic() - start_time
+ assert len(instance._oldest_exceptions) == 0
+ assert len(instance._newest_exceptions) == 0
+ assert duration < 0.5
+ assert op_mock.call_count == num_calls
+
+ def test_schedule_flush_no_mutations(self):
+ """schedule flush should return None if no staged mutations"""
+ with self._make_one() as instance:
+ with mock.patch.object(instance, "_flush_internal") as flush_mock:
+ for i in range(3):
+ assert instance._schedule_flush() is None
+ assert flush_mock.call_count == 0
+
+ @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+ def test_schedule_flush_with_mutations(self):
+ """if new mutations exist, should add a new flush task to _flush_jobs"""
+ with self._make_one() as instance:
+ with mock.patch.object(instance, "_flush_internal") as flush_mock:
+ flush_mock.side_effect = lambda x: time.sleep(0.1)
+ for i in range(1, 4):
+ mutation = mock.Mock()
+ instance._staged_entries = [mutation]
+ instance._schedule_flush()
+ assert instance._staged_entries == []
+ asyncio.sleep(0)
+ assert instance._staged_entries == []
+ assert instance._staged_count == 0
+ assert instance._staged_bytes == 0
+ assert flush_mock.call_count == 1
+ flush_mock.reset_mock()
+
+ def test__flush_internal(self):
+ """_flush_internal should:
+ - await previous flush call
+ - delegate batching to _flow_control
+ - call _execute_mutate_rows on each batch
+ - update self.exceptions and self._entries_processed_since_last_raise"""
+ num_entries = 10
+ with self._make_one() as instance:
+ with mock.patch.object(instance, "_execute_mutate_rows") as execute_mock:
+ with mock.patch.object(
+ instance._flow_control, "add_to_flow"
+ ) as flow_mock:
+
+ def gen(x):
+ yield x
+
+ flow_mock.side_effect = lambda x: gen(x)
+ mutations = [self._make_mutation(count=1, size=1)] * num_entries
+ instance._flush_internal(mutations)
+ assert instance._entries_processed_since_last_raise == num_entries
+ assert execute_mock.call_count == 1
+ assert flow_mock.call_count == 1
+ instance._oldest_exceptions.clear()
+ instance._newest_exceptions.clear()
+
+ def test_flush_clears_job_list(self):
+ """a job should be added to _flush_jobs when _schedule_flush is called,
+ and removed when it completes"""
+ with self._make_one() as instance:
+ with mock.patch.object(
+ instance, "_flush_internal", CrossSync._Sync_Impl.Mock()
+ ) as flush_mock:
+ flush_mock.side_effect = lambda x: time.sleep(0.1)
+ mutations = [self._make_mutation(count=1, size=1)]
+ instance._staged_entries = mutations
+ assert instance._flush_jobs == set()
+ new_job = instance._schedule_flush()
+ assert instance._flush_jobs == {new_job}
+ new_job.result()
+ assert instance._flush_jobs == set()
+
+ @pytest.mark.parametrize(
+ "num_starting,num_new_errors,expected_total_errors",
+ [
+ (0, 0, 0),
+ (0, 1, 1),
+ (0, 2, 2),
+ (1, 0, 1),
+ (1, 1, 2),
+ (10, 2, 12),
+ (10, 20, 20),
+ ],
+ )
+ def test__flush_internal_with_errors(
+ self, num_starting, num_new_errors, expected_total_errors
+ ):
+ """errors returned from _execute_mutate_rows should be added to internal exceptions"""
+ from google.cloud.bigtable.data import exceptions
+
+ num_entries = 10
+ expected_errors = [
+ exceptions.FailedMutationEntryError(mock.Mock(), mock.Mock(), ValueError())
+ ] * num_new_errors
+ with self._make_one() as instance:
+ instance._oldest_exceptions = [mock.Mock()] * num_starting
+ with mock.patch.object(instance, "_execute_mutate_rows") as execute_mock:
+ execute_mock.return_value = expected_errors
+ with mock.patch.object(
+ instance._flow_control, "add_to_flow"
+ ) as flow_mock:
+
+ def gen(x):
+ yield x
+
+ flow_mock.side_effect = lambda x: gen(x)
+ mutations = [self._make_mutation(count=1, size=1)] * num_entries
+ instance._flush_internal(mutations)
+ assert instance._entries_processed_since_last_raise == num_entries
+ assert execute_mock.call_count == 1
+ assert flow_mock.call_count == 1
+ found_exceptions = instance._oldest_exceptions + list(
+ instance._newest_exceptions
+ )
+ assert len(found_exceptions) == expected_total_errors
+ for i in range(num_starting, expected_total_errors):
+ assert found_exceptions[i] == expected_errors[i - num_starting]
+ assert found_exceptions[i].index is None
+ instance._oldest_exceptions.clear()
+ instance._newest_exceptions.clear()
+
+ def _mock_gapic_return(self, num=5):
+ from google.cloud.bigtable_v2.types import MutateRowsResponse
+ from google.rpc import status_pb2
+
+ def gen(num):
+ for i in range(num):
+ entry = MutateRowsResponse.Entry(
+ index=i, status=status_pb2.Status(code=0)
+ )
+ yield MutateRowsResponse(entries=[entry])
+
+ return gen(num)
+
+ def test_timer_flush_end_to_end(self):
+ """Flush should automatically trigger after flush_interval"""
+ num_mutations = 10
+ mutations = [self._make_mutation(count=2, size=2)] * num_mutations
+ with self._make_one(flush_interval=0.05) as instance:
+ instance._table.default_operation_timeout = 10
+ instance._table.default_attempt_timeout = 9
+ with mock.patch.object(
+ instance._table.client._gapic_client, "mutate_rows"
+ ) as gapic_mock:
+ gapic_mock.side_effect = (
+ lambda *args, **kwargs: self._mock_gapic_return(num_mutations)
+ )
+ for m in mutations:
+ instance.append(m)
+ assert instance._entries_processed_since_last_raise == 0
+ CrossSync._Sync_Impl.sleep(0.1)
+ assert instance._entries_processed_since_last_raise == num_mutations
+
+ def test__execute_mutate_rows(self):
+ with mock.patch.object(
+ CrossSync._Sync_Impl, "_MutateRowsOperation"
+ ) as mutate_rows:
+ mutate_rows.return_value = CrossSync._Sync_Impl.Mock()
+ start_operation = mutate_rows().start
+ table = mock.Mock()
+ table.table_name = "test-table"
+ table.app_profile_id = "test-app-profile"
+ table.default_mutate_rows_operation_timeout = 17
+ table.default_mutate_rows_attempt_timeout = 13
+ table.default_mutate_rows_retryable_errors = ()
+ with self._make_one(table) as instance:
+ batch = [self._make_mutation()]
+ result = instance._execute_mutate_rows(batch)
+ assert start_operation.call_count == 1
+ (args, kwargs) = mutate_rows.call_args
+ assert args[0] == table.client._gapic_client
+ assert args[1] == table
+ assert args[2] == batch
+ kwargs["operation_timeout"] == 17
+ kwargs["attempt_timeout"] == 13
+ assert result == []
+
+ def test__execute_mutate_rows_returns_errors(self):
+ """Errors from operation should be retruned as list"""
+ from google.cloud.bigtable.data.exceptions import (
+ MutationsExceptionGroup,
+ FailedMutationEntryError,
+ )
+
+ with mock.patch.object(
+ CrossSync._Sync_Impl._MutateRowsOperation, "start"
+ ) as mutate_rows:
+ err1 = FailedMutationEntryError(0, mock.Mock(), RuntimeError("test error"))
+ err2 = FailedMutationEntryError(1, mock.Mock(), RuntimeError("test error"))
+ mutate_rows.side_effect = MutationsExceptionGroup([err1, err2], 10)
+ table = mock.Mock()
+ table.default_mutate_rows_operation_timeout = 17
+ table.default_mutate_rows_attempt_timeout = 13
+ table.default_mutate_rows_retryable_errors = ()
+ with self._make_one(table) as instance:
+ batch = [self._make_mutation()]
+ result = instance._execute_mutate_rows(batch)
+ assert len(result) == 2
+ assert result[0] == err1
+ assert result[1] == err2
+ assert result[0].index is None
+ assert result[1].index is None
+
+ def test__raise_exceptions(self):
+ """Raise exceptions and reset error state"""
+ from google.cloud.bigtable.data import exceptions
+
+ expected_total = 1201
+ expected_exceptions = [RuntimeError("mock")] * 3
+ with self._make_one() as instance:
+ instance._oldest_exceptions = expected_exceptions
+ instance._entries_processed_since_last_raise = expected_total
+ try:
+ instance._raise_exceptions()
+ except exceptions.MutationsExceptionGroup as exc:
+ assert list(exc.exceptions) == expected_exceptions
+ assert str(expected_total) in str(exc)
+ assert instance._entries_processed_since_last_raise == 0
+ (instance._oldest_exceptions, instance._newest_exceptions) = ([], [])
+ instance._raise_exceptions()
+
+ def test___enter__(self):
+ """Should return self"""
+ with self._make_one() as instance:
+ assert instance.__enter__() == instance
+
+ def test___exit__(self):
+ """aexit should call close"""
+ with self._make_one() as instance:
+ with mock.patch.object(instance, "close") as close_mock:
+ instance.__exit__(None, None, None)
+ assert close_mock.call_count == 1
+
+ def test_close(self):
+ """Should clean up all resources"""
+ with self._make_one() as instance:
+ with mock.patch.object(instance, "_schedule_flush") as flush_mock:
+ with mock.patch.object(instance, "_raise_exceptions") as raise_mock:
+ instance.close()
+ assert instance.closed is True
+ assert instance._flush_timer.done() is True
+ assert instance._flush_jobs == set()
+ assert flush_mock.call_count == 1
+ assert raise_mock.call_count == 1
+
+ def test_close_w_exceptions(self):
+ """Raise exceptions on close"""
+ from google.cloud.bigtable.data import exceptions
+
+ expected_total = 10
+ expected_exceptions = [RuntimeError("mock")]
+ with self._make_one() as instance:
+ instance._oldest_exceptions = expected_exceptions
+ instance._entries_processed_since_last_raise = expected_total
+ try:
+ instance.close()
+ except exceptions.MutationsExceptionGroup as exc:
+ assert list(exc.exceptions) == expected_exceptions
+ assert str(expected_total) in str(exc)
+ assert instance._entries_processed_since_last_raise == 0
+ (instance._oldest_exceptions, instance._newest_exceptions) = ([], [])
+
+ def test__on_exit(self, recwarn):
+ """Should raise warnings if unflushed mutations exist"""
+ with self._make_one() as instance:
+ instance._on_exit()
+ assert len(recwarn) == 0
+ num_left = 4
+ instance._staged_entries = [mock.Mock()] * num_left
+ with pytest.warns(UserWarning) as w:
+ instance._on_exit()
+ assert len(w) == 1
+ assert "unflushed mutations" in str(w[0].message).lower()
+ assert str(num_left) in str(w[0].message)
+ instance._closed.set()
+ instance._on_exit()
+ assert len(recwarn) == 0
+ instance._staged_entries = []
+
+ def test_atexit_registration(self):
+ """Should run _on_exit on program termination"""
+ import atexit
+
+ with mock.patch.object(atexit, "register") as register_mock:
+ assert register_mock.call_count == 0
+ with self._make_one():
+ assert register_mock.call_count == 1
+
+ def test_timeout_args_passed(self):
+ """batch_operation_timeout and batch_attempt_timeout should be used
+ in api calls"""
+ with mock.patch.object(
+ CrossSync._Sync_Impl,
+ "_MutateRowsOperation",
+ return_value=CrossSync._Sync_Impl.Mock(),
+ ) as mutate_rows:
+ expected_operation_timeout = 17
+ expected_attempt_timeout = 13
+ with self._make_one(
+ batch_operation_timeout=expected_operation_timeout,
+ batch_attempt_timeout=expected_attempt_timeout,
+ ) as instance:
+ assert instance._operation_timeout == expected_operation_timeout
+ assert instance._attempt_timeout == expected_attempt_timeout
+ instance._execute_mutate_rows([self._make_mutation()])
+ assert mutate_rows.call_count == 1
+ kwargs = mutate_rows.call_args[1]
+ assert kwargs["operation_timeout"] == expected_operation_timeout
+ assert kwargs["attempt_timeout"] == expected_attempt_timeout
+
+ @pytest.mark.parametrize(
+ "limit,in_e,start_e,end_e",
+ [
+ (10, 0, (10, 0), (10, 0)),
+ (1, 10, (0, 0), (1, 1)),
+ (10, 1, (0, 0), (1, 0)),
+ (10, 10, (0, 0), (10, 0)),
+ (10, 11, (0, 0), (10, 1)),
+ (3, 20, (0, 0), (3, 3)),
+ (10, 20, (0, 0), (10, 10)),
+ (10, 21, (0, 0), (10, 10)),
+ (2, 1, (2, 0), (2, 1)),
+ (2, 1, (1, 0), (2, 0)),
+ (2, 2, (1, 0), (2, 1)),
+ (3, 1, (3, 1), (3, 2)),
+ (3, 3, (3, 1), (3, 3)),
+ (1000, 5, (999, 0), (1000, 4)),
+ (1000, 5, (0, 0), (5, 0)),
+ (1000, 5, (1000, 0), (1000, 5)),
+ ],
+ )
+ def test__add_exceptions(self, limit, in_e, start_e, end_e):
+ """Test that the _add_exceptions function properly updates the
+ _oldest_exceptions and _newest_exceptions lists
+ Args:
+ - limit: the _exception_list_limit representing the max size of either list
+ - in_e: size of list of exceptions to send to _add_exceptions
+ - start_e: a tuple of ints representing the initial sizes of _oldest_exceptions and _newest_exceptions
+ - end_e: a tuple of ints representing the expected sizes of _oldest_exceptions and _newest_exceptions
+ """
+ from collections import deque
+
+ input_list = [RuntimeError(f"mock {i}") for i in range(in_e)]
+ mock_batcher = mock.Mock()
+ mock_batcher._oldest_exceptions = [
+ RuntimeError(f"starting mock {i}") for i in range(start_e[0])
+ ]
+ mock_batcher._newest_exceptions = deque(
+ [RuntimeError(f"starting mock {i}") for i in range(start_e[1])],
+ maxlen=limit,
+ )
+ mock_batcher._exception_list_limit = limit
+ mock_batcher._exceptions_since_last_raise = 0
+ self._get_target_class()._add_exceptions(mock_batcher, input_list)
+ assert len(mock_batcher._oldest_exceptions) == end_e[0]
+ assert len(mock_batcher._newest_exceptions) == end_e[1]
+ assert mock_batcher._exceptions_since_last_raise == in_e
+ oldest_list_diff = end_e[0] - start_e[0]
+ newest_list_diff = min(max(in_e - oldest_list_diff, 0), limit)
+ for i in range(oldest_list_diff):
+ assert mock_batcher._oldest_exceptions[i + start_e[0]] == input_list[i]
+ for i in range(1, newest_list_diff + 1):
+ assert mock_batcher._newest_exceptions[-i] == input_list[-i]
+
+ @pytest.mark.parametrize(
+ "input_retryables,expected_retryables",
+ [
+ (
+ TABLE_DEFAULT.READ_ROWS,
+ [
+ core_exceptions.DeadlineExceeded,
+ core_exceptions.ServiceUnavailable,
+ core_exceptions.Aborted,
+ ],
+ ),
+ (
+ TABLE_DEFAULT.DEFAULT,
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ ),
+ (
+ TABLE_DEFAULT.MUTATE_ROWS,
+ [core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable],
+ ),
+ ([], []),
+ ([4], [core_exceptions.DeadlineExceeded]),
+ ],
+ )
+ def test_customizable_retryable_errors(self, input_retryables, expected_retryables):
+ """Test that retryable functions support user-configurable arguments, and that the configured retryables are passed
+ down to the gapic layer."""
+ with mock.patch.object(
+ google.api_core.retry, "if_exception_type"
+ ) as predicate_builder_mock:
+ with mock.patch.object(
+ CrossSync._Sync_Impl, "retry_target"
+ ) as retry_fn_mock:
+ table = None
+ with mock.patch("asyncio.create_task"):
+ table = CrossSync._Sync_Impl.Table(mock.Mock(), "instance", "table")
+ with self._make_one(
+ table, batch_retryable_errors=input_retryables
+ ) as instance:
+ assert instance._retryable_errors == expected_retryables
+ expected_predicate = expected_retryables.__contains__
+ predicate_builder_mock.return_value = expected_predicate
+ retry_fn_mock.side_effect = RuntimeError("stop early")
+ mutation = self._make_mutation(count=1, size=1)
+ instance._execute_mutate_rows([mutation])
+ predicate_builder_mock.assert_called_once_with(
+ *expected_retryables, _MutateRowsIncomplete
+ )
+ retry_call_args = retry_fn_mock.call_args_list[0].args
+ assert retry_call_args[1] is expected_predicate
+
+ def test_large_batch_write(self):
+ """Test that a large batch of mutations can be written"""
+ import math
+
+ num_mutations = 10000
+ flush_limit = 1000
+ mutations = [self._make_mutation(count=1, size=1)] * num_mutations
+ with self._make_one(flush_limit_mutation_count=flush_limit) as instance:
+ operation_mock = mock.Mock()
+ rpc_call_mock = CrossSync._Sync_Impl.Mock()
+ operation_mock().start = rpc_call_mock
+ CrossSync._Sync_Impl._MutateRowsOperation = operation_mock
+ for m in mutations:
+ instance.append(m)
+ expected_calls = math.ceil(num_mutations / flush_limit)
+ assert rpc_call_mock.call_count == expected_calls
+ assert instance._entries_processed_since_last_raise == num_mutations
+ assert len(instance._staged_entries) == 0
diff --git a/tests/unit/data/_sync_autogen/test_read_rows_acceptance.py b/tests/unit/data/_sync_autogen/test_read_rows_acceptance.py
new file mode 100644
index 000000000..8ceb0daf7
--- /dev/null
+++ b/tests/unit/data/_sync_autogen/test_read_rows_acceptance.py
@@ -0,0 +1,328 @@
+# Copyright 2024 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.
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+from __future__ import annotations
+import os
+import warnings
+import pytest
+import mock
+from itertools import zip_longest
+from google.cloud.bigtable_v2 import ReadRowsResponse
+from google.cloud.bigtable.data.exceptions import InvalidChunk
+from google.cloud.bigtable.data.row import Row
+from ...v2_client.test_row_merger import ReadRowsTest, TestFile
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+
+class TestReadRowsAcceptance:
+ @staticmethod
+ def _get_operation_class():
+ return CrossSync._Sync_Impl._ReadRowsOperation
+
+ @staticmethod
+ def _get_client_class():
+ return CrossSync._Sync_Impl.DataClient
+
+ def parse_readrows_acceptance_tests():
+ dirname = os.path.dirname(__file__)
+ filename = os.path.join(dirname, "../read-rows-acceptance-test.json")
+ with open(filename) as json_file:
+ test_json = TestFile.from_json(json_file.read())
+ return test_json.read_rows_tests
+
+ @staticmethod
+ def extract_results_from_row(row: Row):
+ results = []
+ for family, col, cells in row.items():
+ for cell in cells:
+ results.append(
+ ReadRowsTest.Result(
+ row_key=row.row_key,
+ family_name=family,
+ qualifier=col,
+ timestamp_micros=cell.timestamp_ns // 1000,
+ value=cell.value,
+ label=cell.labels[0] if cell.labels else "",
+ )
+ )
+ return results
+
+ @staticmethod
+ def _coro_wrapper(stream):
+ return stream
+
+ def _process_chunks(self, *chunks):
+ def _row_stream():
+ yield ReadRowsResponse(chunks=chunks)
+
+ instance = mock.Mock()
+ instance._remaining_count = None
+ instance._last_yielded_row_key = None
+ chunker = self._get_operation_class().chunk_stream(
+ instance, self._coro_wrapper(_row_stream())
+ )
+ merger = self._get_operation_class().merge_rows(chunker)
+ results = []
+ for row in merger:
+ results.append(row)
+ return results
+
+ @pytest.mark.parametrize(
+ "test_case", parse_readrows_acceptance_tests(), ids=lambda t: t.description
+ )
+ def test_row_merger_scenario(self, test_case: ReadRowsTest):
+ def _scenerio_stream():
+ for chunk in test_case.chunks:
+ yield ReadRowsResponse(chunks=[chunk])
+
+ try:
+ results = []
+ instance = mock.Mock()
+ instance._last_yielded_row_key = None
+ instance._remaining_count = None
+ chunker = self._get_operation_class().chunk_stream(
+ instance, self._coro_wrapper(_scenerio_stream())
+ )
+ merger = self._get_operation_class().merge_rows(chunker)
+ for row in merger:
+ for cell in row:
+ cell_result = ReadRowsTest.Result(
+ row_key=cell.row_key,
+ family_name=cell.family,
+ qualifier=cell.qualifier,
+ timestamp_micros=cell.timestamp_micros,
+ value=cell.value,
+ label=cell.labels[0] if cell.labels else "",
+ )
+ results.append(cell_result)
+ except InvalidChunk:
+ results.append(ReadRowsTest.Result(error=True))
+ for expected, actual in zip_longest(test_case.results, results):
+ assert actual == expected
+
+ @pytest.mark.parametrize(
+ "test_case", parse_readrows_acceptance_tests(), ids=lambda t: t.description
+ )
+ def test_read_rows_scenario(self, test_case: ReadRowsTest):
+ def _make_gapic_stream(chunk_list: list[ReadRowsResponse]):
+ from google.cloud.bigtable_v2 import ReadRowsResponse
+
+ class mock_stream:
+ def __init__(self, chunk_list):
+ self.chunk_list = chunk_list
+ self.idx = -1
+
+ def __aiter__(self):
+ return self
+
+ def __iter__(self):
+ return self
+
+ def __anext__(self):
+ self.idx += 1
+ if len(self.chunk_list) > self.idx:
+ chunk = self.chunk_list[self.idx]
+ return ReadRowsResponse(chunks=[chunk])
+ raise CrossSync._Sync_Impl.StopIteration
+
+ def __next__(self):
+ return self.__anext__()
+
+ def cancel(self):
+ pass
+
+ return mock_stream(chunk_list)
+
+ with mock.patch.dict(os.environ, {"BIGTABLE_EMULATOR_HOST": "localhost"}):
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ client = self._get_client_class()()
+ try:
+ table = client.get_table("instance", "table")
+ results = []
+ with mock.patch.object(
+ table.client._gapic_client, "read_rows"
+ ) as read_rows:
+ read_rows.return_value = _make_gapic_stream(test_case.chunks)
+ for row in table.read_rows_stream(query={}):
+ for cell in row:
+ cell_result = ReadRowsTest.Result(
+ row_key=cell.row_key,
+ family_name=cell.family,
+ qualifier=cell.qualifier,
+ timestamp_micros=cell.timestamp_micros,
+ value=cell.value,
+ label=cell.labels[0] if cell.labels else "",
+ )
+ results.append(cell_result)
+ except InvalidChunk:
+ results.append(ReadRowsTest.Result(error=True))
+ finally:
+ client.close()
+ for expected, actual in zip_longest(test_case.results, results):
+ assert actual == expected
+
+ def test_out_of_order_rows(self):
+ def _row_stream():
+ yield ReadRowsResponse(last_scanned_row_key=b"a")
+
+ instance = mock.Mock()
+ instance._remaining_count = None
+ instance._last_yielded_row_key = b"b"
+ chunker = self._get_operation_class().chunk_stream(
+ instance, self._coro_wrapper(_row_stream())
+ )
+ merger = self._get_operation_class().merge_rows(chunker)
+ with pytest.raises(InvalidChunk):
+ for _ in merger:
+ pass
+
+ def test_bare_reset(self):
+ first_chunk = ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a", family_name="f", qualifier=b"q", value=b"v"
+ )
+ )
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, row_key=b"a")
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, family_name="f")
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, qualifier=b"q")
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, timestamp_micros=1000)
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, labels=["a"])
+ ),
+ )
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ first_chunk,
+ ReadRowsResponse.CellChunk(
+ ReadRowsResponse.CellChunk(reset_row=True, value=b"v")
+ ),
+ )
+
+ def test_missing_family(self):
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value=b"v",
+ commit_row=True,
+ )
+ )
+
+ def test_mid_cell_row_key_change(self):
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(row_key=b"b", value=b"v", commit_row=True),
+ )
+
+ def test_mid_cell_family_change(self):
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(
+ family_name="f2", value=b"v", commit_row=True
+ ),
+ )
+
+ def test_mid_cell_qualifier_change(self):
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(
+ qualifier=b"q2", value=b"v", commit_row=True
+ ),
+ )
+
+ def test_mid_cell_timestamp_change(self):
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(
+ timestamp_micros=2000, value=b"v", commit_row=True
+ ),
+ )
+
+ def test_mid_cell_labels_change(self):
+ with pytest.raises(InvalidChunk):
+ self._process_chunks(
+ ReadRowsResponse.CellChunk(
+ row_key=b"a",
+ family_name="f",
+ qualifier=b"q",
+ timestamp_micros=1000,
+ value_size=2,
+ value=b"v",
+ ),
+ ReadRowsResponse.CellChunk(labels=["b"], value=b"v", commit_row=True),
+ )
diff --git a/tests/unit/data/execute_query/_async/_testing.py b/tests/unit/data/execute_query/_async/_testing.py
deleted file mode 100644
index 5a7acbdd9..000000000
--- a/tests/unit/data/execute_query/_async/_testing.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# Copyright 2024 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.
-
-# flake8: noqa
-from .._testing import TYPE_INT, split_bytes_into_chunks, proto_rows_bytes
-
-
-try:
- # async mock for python3.7-10
- from unittest.mock import Mock
- from asyncio import coroutine
-
- def async_mock(return_value=None):
- coro = Mock(name="CoroutineResult")
- corofunc = Mock(name="CoroutineFunction", side_effect=coroutine(coro))
- corofunc.coro = coro
- corofunc.coro.return_value = return_value
- return corofunc
-
-except ImportError:
- # async mock for python3.11 or later
- from unittest.mock import AsyncMock
-
- def async_mock(return_value=None):
- return AsyncMock(return_value=return_value)
diff --git a/tests/unit/data/execute_query/_async/test_query_iterator.py b/tests/unit/data/execute_query/_async/test_query_iterator.py
index 5c577ed74..ea93fed55 100644
--- a/tests/unit/data/execute_query/_async/test_query_iterator.py
+++ b/tests/unit/data/execute_query/_async/test_query_iterator.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,144 +12,171 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import asyncio
-from unittest.mock import Mock
-from mock import patch
import pytest
-from google.cloud.bigtable.data.execute_query._async.execute_query_iterator import (
- ExecuteQueryIteratorAsync,
-)
+import concurrent.futures
from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
-from ._testing import TYPE_INT, proto_rows_bytes, split_bytes_into_chunks, async_mock
+from .._testing import TYPE_INT, split_bytes_into_chunks, proto_rows_bytes
+
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+# try/except added for compatibility with python < 3.8
+try:
+ from unittest import mock
+except ImportError: # pragma: NO COVER
+ import mock # type: ignore
-class MockIteratorAsync:
+__CROSS_SYNC_OUTPUT__ = (
+ "tests.unit.data.execute_query._sync_autogen.test_query_iterator"
+)
+
+
+@CrossSync.convert_class(sync_name="MockIterator")
+class MockIterator:
def __init__(self, values, delay=None):
self._values = values
self.idx = 0
self._delay = delay
+ @CrossSync.convert(sync_name="__iter__")
def __aiter__(self):
return self
+ @CrossSync.convert(sync_name="__next__")
async def __anext__(self):
if self.idx >= len(self._values):
- raise StopAsyncIteration
+ raise CrossSync.StopIteration
if self._delay is not None:
- await asyncio.sleep(self._delay)
+ await CrossSync.sleep(self._delay)
value = self._values[self.idx]
self.idx += 1
return value
-@pytest.fixture
-def proto_byte_stream():
- proto_rows = [
- proto_rows_bytes({"int_value": 1}, {"int_value": 2}),
- proto_rows_bytes({"int_value": 3}, {"int_value": 4}),
- proto_rows_bytes({"int_value": 5}, {"int_value": 6}),
- ]
-
- messages = [
- *split_bytes_into_chunks(proto_rows[0], num_chunks=2),
- *split_bytes_into_chunks(proto_rows[1], num_chunks=3),
- proto_rows[2],
- ]
-
- stream = [
- ExecuteQueryResponse(
- metadata={
- "proto_schema": {
- "columns": [
- {"name": "test1", "type_": TYPE_INT},
- {"name": "test2", "type_": TYPE_INT},
- ]
+@CrossSync.convert_class(sync_name="TestQueryIterator")
+class TestQueryIteratorAsync:
+ @staticmethod
+ def _target_class():
+ return CrossSync.ExecuteQueryIterator
+
+ def _make_one(self, *args, **kwargs):
+ return self._target_class()(*args, **kwargs)
+
+ @pytest.fixture
+ def proto_byte_stream(self):
+ proto_rows = [
+ proto_rows_bytes({"int_value": 1}, {"int_value": 2}),
+ proto_rows_bytes({"int_value": 3}, {"int_value": 4}),
+ proto_rows_bytes({"int_value": 5}, {"int_value": 6}),
+ ]
+
+ messages = [
+ *split_bytes_into_chunks(proto_rows[0], num_chunks=2),
+ *split_bytes_into_chunks(proto_rows[1], num_chunks=3),
+ proto_rows[2],
+ ]
+
+ stream = [
+ ExecuteQueryResponse(
+ metadata={
+ "proto_schema": {
+ "columns": [
+ {"name": "test1", "type_": TYPE_INT},
+ {"name": "test2", "type_": TYPE_INT},
+ ]
+ }
+ }
+ ),
+ ExecuteQueryResponse(
+ results={"proto_rows_batch": {"batch_data": messages[0]}}
+ ),
+ ExecuteQueryResponse(
+ results={
+ "proto_rows_batch": {"batch_data": messages[1]},
+ "resume_token": b"token1",
+ }
+ ),
+ ExecuteQueryResponse(
+ results={"proto_rows_batch": {"batch_data": messages[2]}}
+ ),
+ ExecuteQueryResponse(
+ results={"proto_rows_batch": {"batch_data": messages[3]}}
+ ),
+ ExecuteQueryResponse(
+ results={
+ "proto_rows_batch": {"batch_data": messages[4]},
+ "resume_token": b"token2",
+ }
+ ),
+ ExecuteQueryResponse(
+ results={
+ "proto_rows_batch": {"batch_data": messages[5]},
+ "resume_token": b"token3",
}
- }
- ),
- ExecuteQueryResponse(results={"proto_rows_batch": {"batch_data": messages[0]}}),
- ExecuteQueryResponse(
- results={
- "proto_rows_batch": {"batch_data": messages[1]},
- "resume_token": b"token1",
- }
- ),
- ExecuteQueryResponse(results={"proto_rows_batch": {"batch_data": messages[2]}}),
- ExecuteQueryResponse(results={"proto_rows_batch": {"batch_data": messages[3]}}),
- ExecuteQueryResponse(
- results={
- "proto_rows_batch": {"batch_data": messages[4]},
- "resume_token": b"token2",
- }
- ),
- ExecuteQueryResponse(
- results={
- "proto_rows_batch": {"batch_data": messages[5]},
- "resume_token": b"token3",
- }
- ),
- ]
- return stream
-
-
-@pytest.mark.asyncio
-async def test_iterator(proto_byte_stream):
- client_mock = Mock()
-
- client_mock._register_instance = async_mock()
- client_mock._remove_instance_registration = async_mock()
- mock_async_iterator = MockIteratorAsync(proto_byte_stream)
- iterator = None
-
- with patch(
- "google.api_core.retry.retry_target_stream_async",
- return_value=mock_async_iterator,
- ):
- iterator = ExecuteQueryIteratorAsync(
- client=client_mock,
- instance_id="test-instance",
- app_profile_id="test_profile",
- request_body={},
- attempt_timeout=10,
- operation_timeout=10,
- req_metadata=(),
- retryable_excs=[],
- )
- result = []
- async for value in iterator:
- result.append(tuple(value))
- assert result == [(1, 2), (3, 4), (5, 6)]
-
- assert iterator.is_closed
- client_mock._register_instance.assert_called_once()
- client_mock._remove_instance_registration.assert_called_once()
-
- assert mock_async_iterator.idx == len(proto_byte_stream)
-
-
-@pytest.mark.asyncio
-async def test_iterator_awaits_metadata(proto_byte_stream):
- client_mock = Mock()
-
- client_mock._register_instance = async_mock()
- client_mock._remove_instance_registration = async_mock()
- mock_async_iterator = MockIteratorAsync(proto_byte_stream)
- iterator = None
- with patch(
- "google.api_core.retry.retry_target_stream_async",
- return_value=mock_async_iterator,
- ):
- iterator = ExecuteQueryIteratorAsync(
- client=client_mock,
- instance_id="test-instance",
- app_profile_id="test_profile",
- request_body={},
- attempt_timeout=10,
- operation_timeout=10,
- req_metadata=(),
- retryable_excs=[],
- )
-
- await iterator.metadata()
-
- assert mock_async_iterator.idx == 1
+ ),
+ ]
+ return stream
+
+ @CrossSync.pytest
+ async def test_iterator(self, proto_byte_stream):
+ client_mock = mock.Mock()
+
+ client_mock._register_instance = CrossSync.Mock()
+ client_mock._remove_instance_registration = CrossSync.Mock()
+ client_mock._executor = concurrent.futures.ThreadPoolExecutor()
+ mock_async_iterator = MockIterator(proto_byte_stream)
+ iterator = None
+
+ with mock.patch.object(
+ CrossSync,
+ "retry_target_stream",
+ return_value=mock_async_iterator,
+ ):
+ iterator = self._make_one(
+ client=client_mock,
+ instance_id="test-instance",
+ app_profile_id="test_profile",
+ request_body={},
+ attempt_timeout=10,
+ operation_timeout=10,
+ req_metadata=(),
+ retryable_excs=[],
+ )
+ result = []
+ async for value in iterator:
+ result.append(tuple(value))
+ assert result == [(1, 2), (3, 4), (5, 6)]
+
+ assert iterator.is_closed
+ client_mock._register_instance.assert_called_once()
+ client_mock._remove_instance_registration.assert_called_once()
+
+ assert mock_async_iterator.idx == len(proto_byte_stream)
+
+ @CrossSync.pytest
+ async def test_iterator_awaits_metadata(self, proto_byte_stream):
+ client_mock = mock.Mock()
+
+ client_mock._register_instance = CrossSync.Mock()
+ client_mock._remove_instance_registration = CrossSync.Mock()
+ mock_async_iterator = MockIterator(proto_byte_stream)
+ iterator = None
+ with mock.patch.object(
+ CrossSync,
+ "retry_target_stream",
+ return_value=mock_async_iterator,
+ ):
+ iterator = self._make_one(
+ client=client_mock,
+ instance_id="test-instance",
+ app_profile_id="test_profile",
+ request_body={},
+ attempt_timeout=10,
+ operation_timeout=10,
+ req_metadata=(),
+ retryable_excs=[],
+ )
+
+ await iterator.metadata()
+
+ assert mock_async_iterator.idx == 1
diff --git a/tests/unit/data/execute_query/_sync_autogen/__init__.py b/tests/unit/data/execute_query/_sync_autogen/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/data/execute_query/_sync_autogen/test_query_iterator.py b/tests/unit/data/execute_query/_sync_autogen/test_query_iterator.py
new file mode 100644
index 000000000..77a28ea92
--- /dev/null
+++ b/tests/unit/data/execute_query/_sync_autogen/test_query_iterator.py
@@ -0,0 +1,163 @@
+# Copyright 2024 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.
+
+
+# This file is automatically generated by CrossSync. Do not edit manually.
+
+import pytest
+import concurrent.futures
+from google.cloud.bigtable_v2.types.bigtable import ExecuteQueryResponse
+from .._testing import TYPE_INT, split_bytes_into_chunks, proto_rows_bytes
+from google.cloud.bigtable.data._cross_sync import CrossSync
+
+try:
+ from unittest import mock
+except ImportError:
+ import mock
+
+
+class MockIterator:
+ def __init__(self, values, delay=None):
+ self._values = values
+ self.idx = 0
+ self._delay = delay
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ if self.idx >= len(self._values):
+ raise CrossSync._Sync_Impl.StopIteration
+ if self._delay is not None:
+ CrossSync._Sync_Impl.sleep(self._delay)
+ value = self._values[self.idx]
+ self.idx += 1
+ return value
+
+
+class TestQueryIterator:
+ @staticmethod
+ def _target_class():
+ return CrossSync._Sync_Impl.ExecuteQueryIterator
+
+ def _make_one(self, *args, **kwargs):
+ return self._target_class()(*args, **kwargs)
+
+ @pytest.fixture
+ def proto_byte_stream(self):
+ proto_rows = [
+ proto_rows_bytes({"int_value": 1}, {"int_value": 2}),
+ proto_rows_bytes({"int_value": 3}, {"int_value": 4}),
+ proto_rows_bytes({"int_value": 5}, {"int_value": 6}),
+ ]
+ messages = [
+ *split_bytes_into_chunks(proto_rows[0], num_chunks=2),
+ *split_bytes_into_chunks(proto_rows[1], num_chunks=3),
+ proto_rows[2],
+ ]
+ stream = [
+ ExecuteQueryResponse(
+ metadata={
+ "proto_schema": {
+ "columns": [
+ {"name": "test1", "type_": TYPE_INT},
+ {"name": "test2", "type_": TYPE_INT},
+ ]
+ }
+ }
+ ),
+ ExecuteQueryResponse(
+ results={"proto_rows_batch": {"batch_data": messages[0]}}
+ ),
+ ExecuteQueryResponse(
+ results={
+ "proto_rows_batch": {"batch_data": messages[1]},
+ "resume_token": b"token1",
+ }
+ ),
+ ExecuteQueryResponse(
+ results={"proto_rows_batch": {"batch_data": messages[2]}}
+ ),
+ ExecuteQueryResponse(
+ results={"proto_rows_batch": {"batch_data": messages[3]}}
+ ),
+ ExecuteQueryResponse(
+ results={
+ "proto_rows_batch": {"batch_data": messages[4]},
+ "resume_token": b"token2",
+ }
+ ),
+ ExecuteQueryResponse(
+ results={
+ "proto_rows_batch": {"batch_data": messages[5]},
+ "resume_token": b"token3",
+ }
+ ),
+ ]
+ return stream
+
+ def test_iterator(self, proto_byte_stream):
+ client_mock = mock.Mock()
+ client_mock._register_instance = CrossSync._Sync_Impl.Mock()
+ client_mock._remove_instance_registration = CrossSync._Sync_Impl.Mock()
+ client_mock._executor = concurrent.futures.ThreadPoolExecutor()
+ mock_async_iterator = MockIterator(proto_byte_stream)
+ iterator = None
+ with mock.patch.object(
+ CrossSync._Sync_Impl,
+ "retry_target_stream",
+ return_value=mock_async_iterator,
+ ):
+ iterator = self._make_one(
+ client=client_mock,
+ instance_id="test-instance",
+ app_profile_id="test_profile",
+ request_body={},
+ attempt_timeout=10,
+ operation_timeout=10,
+ req_metadata=(),
+ retryable_excs=[],
+ )
+ result = []
+ for value in iterator:
+ result.append(tuple(value))
+ assert result == [(1, 2), (3, 4), (5, 6)]
+ assert iterator.is_closed
+ client_mock._register_instance.assert_called_once()
+ client_mock._remove_instance_registration.assert_called_once()
+ assert mock_async_iterator.idx == len(proto_byte_stream)
+
+ def test_iterator_awaits_metadata(self, proto_byte_stream):
+ client_mock = mock.Mock()
+ client_mock._register_instance = CrossSync._Sync_Impl.Mock()
+ client_mock._remove_instance_registration = CrossSync._Sync_Impl.Mock()
+ mock_async_iterator = MockIterator(proto_byte_stream)
+ iterator = None
+ with mock.patch.object(
+ CrossSync._Sync_Impl,
+ "retry_target_stream",
+ return_value=mock_async_iterator,
+ ):
+ iterator = self._make_one(
+ client=client_mock,
+ instance_id="test-instance",
+ app_profile_id="test_profile",
+ request_body={},
+ attempt_timeout=10,
+ operation_timeout=10,
+ req_metadata=(),
+ retryable_excs=[],
+ )
+ iterator.metadata()
+ assert mock_async_iterator.idx == 1
diff --git a/tests/unit/data/execute_query/test_execute_query_parameters_parsing.py b/tests/unit/data/execute_query/test_execute_query_parameters_parsing.py
index 914a0920a..f7159fb71 100644
--- a/tests/unit/data/execute_query/test_execute_query_parameters_parsing.py
+++ b/tests/unit/data/execute_query/test_execute_query_parameters_parsing.py
@@ -47,7 +47,7 @@
(b"3", "bytes_value", "bytes_type", b"3"),
(True, "bool_value", "bool_type", True),
(
- datetime.datetime.fromtimestamp(timestamp),
+ datetime.datetime.fromtimestamp(timestamp, tz=datetime.timezone.utc),
"timestamp_value",
"timestamp_type",
dt_nanos_zero,
diff --git a/tests/unit/data/test__helpers.py b/tests/unit/data/test__helpers.py
index 12ab3181e..39db06689 100644
--- a/tests/unit/data/test__helpers.py
+++ b/tests/unit/data/test__helpers.py
@@ -21,34 +21,6 @@
import mock
-class TestMakeMetadata:
- @pytest.mark.parametrize(
- "table,profile,instance,expected",
- [
- ("table", "profile", None, "table_name=table&app_profile_id=profile"),
- ("table", None, None, "table_name=table"),
- (None, None, "instance", "name=instance"),
- (None, "profile", None, "app_profile_id=profile"),
- (None, "profile", "instance", "name=instance&app_profile_id=profile"),
- ],
- )
- def test__make_metadata(self, table, profile, instance, expected):
- metadata = _helpers._make_metadata(table, profile, instance)
- assert metadata == [("x-goog-request-params", expected)]
-
- @pytest.mark.parametrize(
- "table,profile,instance",
- [
- ("table", None, "instance"),
- ("table", "profile", "instance"),
- (None, None, None),
- ],
- )
- def test__make_metadata_invalid_params(self, table, profile, instance):
- with pytest.raises(ValueError):
- _helpers._make_metadata(table, profile, instance)
-
-
class TestAttemptTimeoutGenerator:
@pytest.mark.parametrize(
"request_t,operation_t,expected_list",
@@ -109,7 +81,7 @@ def test_attempt_timeout_w_sleeps(self):
sleep_time = 0.1
for i in range(3):
found_value = next(generator)
- assert abs(found_value - expected_value) < 0.001
+ assert abs(found_value - expected_value) < 0.1
sleep(sleep_time)
expected_value -= sleep_time
diff --git a/tests/unit/data/test_read_rows_acceptance.py b/tests/unit/data/test_read_rows_acceptance.py
deleted file mode 100644
index 7cb3c08dc..000000000
--- a/tests/unit/data/test_read_rows_acceptance.py
+++ /dev/null
@@ -1,331 +0,0 @@
-# Copyright 2023 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.
-from __future__ import annotations
-
-import os
-from itertools import zip_longest
-
-import pytest
-import mock
-
-from google.cloud.bigtable_v2 import ReadRowsResponse
-
-from google.cloud.bigtable.data._async.client import BigtableDataClientAsync
-from google.cloud.bigtable.data.exceptions import InvalidChunk
-from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
-from google.cloud.bigtable.data.row import Row
-
-from ..v2_client.test_row_merger import ReadRowsTest, TestFile
-
-
-def parse_readrows_acceptance_tests():
- dirname = os.path.dirname(__file__)
- filename = os.path.join(dirname, "./read-rows-acceptance-test.json")
-
- with open(filename) as json_file:
- test_json = TestFile.from_json(json_file.read())
- return test_json.read_rows_tests
-
-
-def extract_results_from_row(row: Row):
- results = []
- for family, col, cells in row.items():
- for cell in cells:
- results.append(
- ReadRowsTest.Result(
- row_key=row.row_key,
- family_name=family,
- qualifier=col,
- timestamp_micros=cell.timestamp_ns // 1000,
- value=cell.value,
- label=(cell.labels[0] if cell.labels else ""),
- )
- )
- return results
-
-
-@pytest.mark.parametrize(
- "test_case", parse_readrows_acceptance_tests(), ids=lambda t: t.description
-)
-@pytest.mark.asyncio
-async def test_row_merger_scenario(test_case: ReadRowsTest):
- async def _scenerio_stream():
- for chunk in test_case.chunks:
- yield ReadRowsResponse(chunks=[chunk])
-
- try:
- results = []
- instance = mock.Mock()
- instance._last_yielded_row_key = None
- instance._remaining_count = None
- chunker = _ReadRowsOperationAsync.chunk_stream(
- instance, _coro_wrapper(_scenerio_stream())
- )
- merger = _ReadRowsOperationAsync.merge_rows(chunker)
- async for row in merger:
- for cell in row:
- cell_result = ReadRowsTest.Result(
- row_key=cell.row_key,
- family_name=cell.family,
- qualifier=cell.qualifier,
- timestamp_micros=cell.timestamp_micros,
- value=cell.value,
- label=cell.labels[0] if cell.labels else "",
- )
- results.append(cell_result)
- except InvalidChunk:
- results.append(ReadRowsTest.Result(error=True))
- for expected, actual in zip_longest(test_case.results, results):
- assert actual == expected
-
-
-@pytest.mark.parametrize(
- "test_case", parse_readrows_acceptance_tests(), ids=lambda t: t.description
-)
-@pytest.mark.asyncio
-async def test_read_rows_scenario(test_case: ReadRowsTest):
- async def _make_gapic_stream(chunk_list: list[ReadRowsResponse]):
- from google.cloud.bigtable_v2 import ReadRowsResponse
-
- class mock_stream:
- def __init__(self, chunk_list):
- self.chunk_list = chunk_list
- self.idx = -1
-
- def __aiter__(self):
- return self
-
- async def __anext__(self):
- self.idx += 1
- if len(self.chunk_list) > self.idx:
- chunk = self.chunk_list[self.idx]
- return ReadRowsResponse(chunks=[chunk])
- raise StopAsyncIteration
-
- def cancel(self):
- pass
-
- return mock_stream(chunk_list)
-
- try:
- with mock.patch.dict(os.environ, {"BIGTABLE_EMULATOR_HOST": "localhost"}):
- # use emulator mode to avoid auth issues in CI
- client = BigtableDataClientAsync()
- table = client.get_table("instance", "table")
- results = []
- with mock.patch.object(table.client._gapic_client, "read_rows") as read_rows:
- # run once, then return error on retry
- read_rows.return_value = _make_gapic_stream(test_case.chunks)
- async for row in await table.read_rows_stream(query={}):
- for cell in row:
- cell_result = ReadRowsTest.Result(
- row_key=cell.row_key,
- family_name=cell.family,
- qualifier=cell.qualifier,
- timestamp_micros=cell.timestamp_micros,
- value=cell.value,
- label=cell.labels[0] if cell.labels else "",
- )
- results.append(cell_result)
- except InvalidChunk:
- results.append(ReadRowsTest.Result(error=True))
- finally:
- await client.close()
- for expected, actual in zip_longest(test_case.results, results):
- assert actual == expected
-
-
-@pytest.mark.asyncio
-async def test_out_of_order_rows():
- async def _row_stream():
- yield ReadRowsResponse(last_scanned_row_key=b"a")
-
- instance = mock.Mock()
- instance._remaining_count = None
- instance._last_yielded_row_key = b"b"
- chunker = _ReadRowsOperationAsync.chunk_stream(
- instance, _coro_wrapper(_row_stream())
- )
- merger = _ReadRowsOperationAsync.merge_rows(chunker)
- with pytest.raises(InvalidChunk):
- async for _ in merger:
- pass
-
-
-@pytest.mark.asyncio
-async def test_bare_reset():
- first_chunk = ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(
- row_key=b"a", family_name="f", qualifier=b"q", value=b"v"
- )
- )
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- first_chunk,
- ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(reset_row=True, row_key=b"a")
- ),
- )
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- first_chunk,
- ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(reset_row=True, family_name="f")
- ),
- )
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- first_chunk,
- ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(reset_row=True, qualifier=b"q")
- ),
- )
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- first_chunk,
- ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(reset_row=True, timestamp_micros=1000)
- ),
- )
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- first_chunk,
- ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(reset_row=True, labels=["a"])
- ),
- )
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- first_chunk,
- ReadRowsResponse.CellChunk(
- ReadRowsResponse.CellChunk(reset_row=True, value=b"v")
- ),
- )
-
-
-@pytest.mark.asyncio
-async def test_missing_family():
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- ReadRowsResponse.CellChunk(
- row_key=b"a",
- qualifier=b"q",
- timestamp_micros=1000,
- value=b"v",
- commit_row=True,
- )
- )
-
-
-@pytest.mark.asyncio
-async def test_mid_cell_row_key_change():
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- ReadRowsResponse.CellChunk(
- row_key=b"a",
- family_name="f",
- qualifier=b"q",
- timestamp_micros=1000,
- value_size=2,
- value=b"v",
- ),
- ReadRowsResponse.CellChunk(row_key=b"b", value=b"v", commit_row=True),
- )
-
-
-@pytest.mark.asyncio
-async def test_mid_cell_family_change():
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- ReadRowsResponse.CellChunk(
- row_key=b"a",
- family_name="f",
- qualifier=b"q",
- timestamp_micros=1000,
- value_size=2,
- value=b"v",
- ),
- ReadRowsResponse.CellChunk(family_name="f2", value=b"v", commit_row=True),
- )
-
-
-@pytest.mark.asyncio
-async def test_mid_cell_qualifier_change():
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- ReadRowsResponse.CellChunk(
- row_key=b"a",
- family_name="f",
- qualifier=b"q",
- timestamp_micros=1000,
- value_size=2,
- value=b"v",
- ),
- ReadRowsResponse.CellChunk(qualifier=b"q2", value=b"v", commit_row=True),
- )
-
-
-@pytest.mark.asyncio
-async def test_mid_cell_timestamp_change():
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- ReadRowsResponse.CellChunk(
- row_key=b"a",
- family_name="f",
- qualifier=b"q",
- timestamp_micros=1000,
- value_size=2,
- value=b"v",
- ),
- ReadRowsResponse.CellChunk(
- timestamp_micros=2000, value=b"v", commit_row=True
- ),
- )
-
-
-@pytest.mark.asyncio
-async def test_mid_cell_labels_change():
- with pytest.raises(InvalidChunk):
- await _process_chunks(
- ReadRowsResponse.CellChunk(
- row_key=b"a",
- family_name="f",
- qualifier=b"q",
- timestamp_micros=1000,
- value_size=2,
- value=b"v",
- ),
- ReadRowsResponse.CellChunk(labels=["b"], value=b"v", commit_row=True),
- )
-
-
-async def _coro_wrapper(stream):
- return stream
-
-
-async def _process_chunks(*chunks):
- async def _row_stream():
- yield ReadRowsResponse(chunks=chunks)
-
- instance = mock.Mock()
- instance._remaining_count = None
- instance._last_yielded_row_key = None
- chunker = _ReadRowsOperationAsync.chunk_stream(
- instance, _coro_wrapper(_row_stream())
- )
- merger = _ReadRowsOperationAsync.merge_rows(chunker)
- results = []
- async for row in merger:
- results.append(row)
- return results
diff --git a/tests/unit/data/test_sync_up_to_date.py b/tests/unit/data/test_sync_up_to_date.py
new file mode 100644
index 000000000..492d35ddf
--- /dev/null
+++ b/tests/unit/data/test_sync_up_to_date.py
@@ -0,0 +1,99 @@
+# Copyright 2024 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 os
+import sys
+import hashlib
+import pytest
+import ast
+import re
+from difflib import unified_diff
+
+# add cross_sync to path
+test_dir_name = os.path.dirname(__file__)
+repo_root = os.path.join(test_dir_name, "..", "..", "..")
+cross_sync_path = os.path.join(repo_root, ".cross_sync")
+sys.path.append(cross_sync_path)
+
+from generate import convert_files_in_dir, CrossSyncOutputFile # noqa: E402
+
+sync_files = list(convert_files_in_dir(repo_root))
+
+
+def test_found_files():
+ """
+ Make sure sync_test is populated with some of the files we expect to see,
+ to ensure that later tests are actually running.
+ """
+ assert len(sync_files) > 0, "No sync files found"
+ assert len(sync_files) > 10, "Unexpectedly few sync files found"
+ # test for key files
+ outputs = [os.path.basename(f.output_path) for f in sync_files]
+ assert "client.py" in outputs
+ assert "execute_query_iterator.py" in outputs
+ assert "test_client.py" in outputs
+ assert "test_system_autogen.py" in outputs, "system tests not found"
+ assert (
+ "client_handler_data_sync_autogen.py" in outputs
+ ), "test proxy handler not found"
+
+
+@pytest.mark.skipif(
+ sys.version_info < (3, 9), reason="ast.unparse is only available in 3.9+"
+)
+@pytest.mark.parametrize("sync_file", sync_files, ids=lambda f: f.output_path)
+def test_sync_up_to_date(sync_file):
+ """
+ Generate a fresh copy of each cross_sync file, and compare hashes with the existing file.
+
+ If this test fails, run `nox -s generate_sync` to update the sync files.
+ """
+ path = sync_file.output_path
+ new_render = sync_file.render(with_formatter=True, save_to_disk=False)
+ found_render = CrossSyncOutputFile(
+ output_path="", ast_tree=ast.parse(open(path).read()), header=sync_file.header
+ ).render(with_formatter=True, save_to_disk=False)
+ # compare by content
+ diff = unified_diff(found_render.splitlines(), new_render.splitlines(), lineterm="")
+ diff_str = "\n".join(diff)
+ assert (
+ not diff_str
+ ), f"Found differences. Run `nox -s generate_sync` to update:\n{diff_str}"
+ # compare by hash
+ new_hash = hashlib.md5(new_render.encode()).hexdigest()
+ found_hash = hashlib.md5(found_render.encode()).hexdigest()
+ assert new_hash == found_hash, f"md5 mismatch for {path}"
+
+
+@pytest.mark.parametrize("sync_file", sync_files, ids=lambda f: f.output_path)
+def test_verify_headers(sync_file):
+ license_regex = r"""
+ \#\ Copyright\ \d{4}\ Google\ LLC\n
+ \#\n
+ \#\ Licensed\ under\ the\ Apache\ License,\ Version\ 2\.0\ \(the\ \"License\"\);\n
+ \#\ you\ may\ not\ use\ this\ file\ except\ in\ compliance\ with\ the\ License\.\n
+ \#\ You\ may\ obtain\ a\ copy\ of\ the\ License\ at\
+ \#\n
+ \#\s+http:\/\/www\.apache\.org\/licenses\/LICENSE-2\.0\n
+ \#\n
+ \#\ Unless\ required\ by\ applicable\ law\ or\ agreed\ to\ in\ writing,\ software\n
+ \#\ distributed\ under\ the\ License\ is\ distributed\ on\ an\ \"AS\ IS\"\ BASIS,\n
+ \#\ WITHOUT\ WARRANTIES\ OR\ CONDITIONS\ OF\ ANY\ KIND,\ either\ express\ or\ implied\.\n
+ \#\ See\ the\ License\ for\ the\ specific\ language\ governing\ permissions\ and\n
+ \#\ limitations\ under\ the\ License\.
+ """
+ pattern = re.compile(license_regex, re.VERBOSE)
+
+ with open(sync_file.output_path, "r") as f:
+ content = f.read()
+ assert pattern.search(content), "Missing license header"
diff --git a/tests/unit/gapic/bigtable_admin_v2/test_bigtable_instance_admin.py b/tests/unit/gapic/bigtable_admin_v2/test_bigtable_instance_admin.py
index 961183b71..3f79e11a4 100644
--- a/tests/unit/gapic/bigtable_admin_v2/test_bigtable_instance_admin.py
+++ b/tests/unit/gapic/bigtable_admin_v2/test_bigtable_instance_admin.py
@@ -24,7 +24,7 @@
import grpc
from grpc.experimental import aio
-from collections.abc import Iterable
+from collections.abc import Iterable, AsyncIterable
from google.protobuf import json_format
import json
import math
@@ -37,6 +37,13 @@
from requests.sessions import Session
from google.protobuf import json_format
+try:
+ from google.auth.aio import credentials as ga_credentials_async
+
+ HAS_GOOGLE_AUTH_AIO = True
+except ImportError: # pragma: NO COVER
+ HAS_GOOGLE_AUTH_AIO = False
+
from google.api_core import client_options
from google.api_core import exceptions as core_exceptions
from google.api_core import future
@@ -73,10 +80,24 @@
import google.auth
+async def mock_async_gen(data, chunk_size=1):
+ for i in range(0, len(data)): # pragma: NO COVER
+ chunk = data[i : i + chunk_size]
+ yield chunk.encode("utf-8")
+
+
def client_cert_source_callback():
return b"cert bytes", b"key bytes"
+# TODO: use async auth anon credentials by default once the minimum version of google-auth is upgraded.
+# See related issue: https://github.com/googleapis/gapic-generator-python/issues/2107.
+def async_anonymous_credentials():
+ if HAS_GOOGLE_AUTH_AIO:
+ return ga_credentials_async.AnonymousCredentials()
+ return ga_credentials.AnonymousCredentials()
+
+
# If default endpoint is localhost, then default mtls endpoint will be the same.
# This method modifies the default endpoint so the client can produce a different
# mtls endpoint for endpoint testing purposes.
@@ -333,94 +354,6 @@ def test__get_universe_domain():
assert str(excinfo.value) == "Universe Domain cannot be an empty string."
-@pytest.mark.parametrize(
- "client_class,transport_class,transport_name",
- [
- (
- BigtableInstanceAdminClient,
- transports.BigtableInstanceAdminGrpcTransport,
- "grpc",
- ),
- (
- BigtableInstanceAdminClient,
- transports.BigtableInstanceAdminRestTransport,
- "rest",
- ),
- ],
-)
-def test__validate_universe_domain(client_class, transport_class, transport_name):
- client = client_class(
- transport=transport_class(credentials=ga_credentials.AnonymousCredentials())
- )
- assert client._validate_universe_domain() == True
-
- # Test the case when universe is already validated.
- assert client._validate_universe_domain() == True
-
- if transport_name == "grpc":
- # Test the case where credentials are provided by the
- # `local_channel_credentials`. The default universes in both match.
- channel = grpc.secure_channel(
- "http://localhost/", grpc.local_channel_credentials()
- )
- client = client_class(transport=transport_class(channel=channel))
- assert client._validate_universe_domain() == True
-
- # Test the case where credentials do not exist: e.g. a transport is provided
- # with no credentials. Validation should still succeed because there is no
- # mismatch with non-existent credentials.
- channel = grpc.secure_channel(
- "http://localhost/", grpc.local_channel_credentials()
- )
- transport = transport_class(channel=channel)
- transport._credentials = None
- client = client_class(transport=transport)
- assert client._validate_universe_domain() == True
-
- # TODO: This is needed to cater for older versions of google-auth
- # Make this test unconditional once the minimum supported version of
- # google-auth becomes 2.23.0 or higher.
- google_auth_major, google_auth_minor = [
- int(part) for part in google.auth.__version__.split(".")[0:2]
- ]
- if google_auth_major > 2 or (google_auth_major == 2 and google_auth_minor >= 23):
- credentials = ga_credentials.AnonymousCredentials()
- credentials._universe_domain = "foo.com"
- # Test the case when there is a universe mismatch from the credentials.
- client = client_class(transport=transport_class(credentials=credentials))
- with pytest.raises(ValueError) as excinfo:
- client._validate_universe_domain()
- assert (
- str(excinfo.value)
- == "The configured universe domain (googleapis.com) does not match the universe domain found in the credentials (foo.com). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
- )
-
- # Test the case when there is a universe mismatch from the client.
- #
- # TODO: Make this test unconditional once the minimum supported version of
- # google-api-core becomes 2.15.0 or higher.
- api_core_major, api_core_minor = [
- int(part) for part in api_core_version.__version__.split(".")[0:2]
- ]
- if api_core_major > 2 or (api_core_major == 2 and api_core_minor >= 15):
- client = client_class(
- client_options={"universe_domain": "bar.com"},
- transport=transport_class(
- credentials=ga_credentials.AnonymousCredentials(),
- ),
- )
- with pytest.raises(ValueError) as excinfo:
- client._validate_universe_domain()
- assert (
- str(excinfo.value)
- == "The configured universe domain (bar.com) does not match the universe domain found in the credentials (googleapis.com). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
- )
-
- # Test that ValueError is raised if universe_domain is provided via client options and credentials is None
- with pytest.raises(ValueError):
- client._compare_universes("foo.bar", None)
-
-
@pytest.mark.parametrize(
"client_class,transport_name",
[
@@ -1249,25 +1182,6 @@ def test_create_instance(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_create_instance_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_instance), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.CreateInstanceRequest()
-
-
def test_create_instance_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1338,27 +1252,6 @@ def test_create_instance_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_instance_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_instance), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.create_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.CreateInstanceRequest()
-
-
@pytest.mark.asyncio
async def test_create_instance_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -1367,7 +1260,7 @@ async def test_create_instance_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1412,7 +1305,7 @@ async def test_create_instance_async(
request_type=bigtable_instance_admin.CreateInstanceRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1475,7 +1368,7 @@ def test_create_instance_field_headers():
@pytest.mark.asyncio
async def test_create_instance_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -1560,7 +1453,7 @@ def test_create_instance_flattened_error():
@pytest.mark.asyncio
async def test_create_instance_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -1601,7 +1494,7 @@ async def test_create_instance_flattened_async():
@pytest.mark.asyncio
async def test_create_instance_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -1660,25 +1553,6 @@ def test_get_instance(request_type, transport: str = "grpc"):
assert response.satisfies_pzs is True
-def test_get_instance_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_instance), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.GetInstanceRequest()
-
-
def test_get_instance_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1742,33 +1616,6 @@ def test_get_instance_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_instance_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_instance), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- instance.Instance(
- name="name_value",
- display_name="display_name_value",
- state=instance.Instance.State.READY,
- type_=instance.Instance.Type.PRODUCTION,
- satisfies_pzs=True,
- )
- )
- response = await client.get_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.GetInstanceRequest()
-
-
@pytest.mark.asyncio
async def test_get_instance_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -1777,7 +1624,7 @@ async def test_get_instance_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1817,7 +1664,7 @@ async def test_get_instance_async(
request_type=bigtable_instance_admin.GetInstanceRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1891,7 +1738,7 @@ def test_get_instance_field_headers():
@pytest.mark.asyncio
async def test_get_instance_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -1959,7 +1806,7 @@ def test_get_instance_flattened_error():
@pytest.mark.asyncio
async def test_get_instance_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -1986,7 +1833,7 @@ async def test_get_instance_flattened_async():
@pytest.mark.asyncio
async def test_get_instance_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2037,25 +1884,6 @@ def test_list_instances(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_instances_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_instances), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_instances()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListInstancesRequest()
-
-
def test_list_instances_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2121,30 +1949,6 @@ def test_list_instances_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_instances_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_instances), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_instance_admin.ListInstancesResponse(
- failed_locations=["failed_locations_value"],
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_instances()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListInstancesRequest()
-
-
@pytest.mark.asyncio
async def test_list_instances_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -2153,7 +1957,7 @@ async def test_list_instances_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2193,7 +1997,7 @@ async def test_list_instances_async(
request_type=bigtable_instance_admin.ListInstancesRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2261,7 +2065,7 @@ def test_list_instances_field_headers():
@pytest.mark.asyncio
async def test_list_instances_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -2331,7 +2135,7 @@ def test_list_instances_flattened_error():
@pytest.mark.asyncio
async def test_list_instances_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2360,7 +2164,7 @@ async def test_list_instances_flattened_async():
@pytest.mark.asyncio
async def test_list_instances_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2416,25 +2220,6 @@ def test_update_instance(request_type, transport: str = "grpc"):
assert response.satisfies_pzs is True
-def test_update_instance_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_instance), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.update_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == instance.Instance()
-
-
def test_update_instance_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2500,33 +2285,6 @@ def test_update_instance_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_update_instance_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_instance), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- instance.Instance(
- name="name_value",
- display_name="display_name_value",
- state=instance.Instance.State.READY,
- type_=instance.Instance.Type.PRODUCTION,
- satisfies_pzs=True,
- )
- )
- response = await client.update_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == instance.Instance()
-
-
@pytest.mark.asyncio
async def test_update_instance_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -2535,7 +2293,7 @@ async def test_update_instance_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2574,7 +2332,7 @@ async def test_update_instance_async(
transport: str = "grpc_asyncio", request_type=instance.Instance
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2648,7 +2406,7 @@ def test_update_instance_field_headers():
@pytest.mark.asyncio
async def test_update_instance_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -2710,27 +2468,6 @@ def test_partial_update_instance(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_partial_update_instance_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.partial_update_instance), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.partial_update_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.PartialUpdateInstanceRequest()
-
-
def test_partial_update_instance_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2802,29 +2539,6 @@ def test_partial_update_instance_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_partial_update_instance_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.partial_update_instance), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.partial_update_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.PartialUpdateInstanceRequest()
-
-
@pytest.mark.asyncio
async def test_partial_update_instance_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -2833,7 +2547,7 @@ async def test_partial_update_instance_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2878,7 +2592,7 @@ async def test_partial_update_instance_async(
request_type=bigtable_instance_admin.PartialUpdateInstanceRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2945,7 +2659,7 @@ def test_partial_update_instance_field_headers():
@pytest.mark.asyncio
async def test_partial_update_instance_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -3024,7 +2738,7 @@ def test_partial_update_instance_flattened_error():
@pytest.mark.asyncio
async def test_partial_update_instance_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3059,7 +2773,7 @@ async def test_partial_update_instance_flattened_async():
@pytest.mark.asyncio
async def test_partial_update_instance_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3105,25 +2819,6 @@ def test_delete_instance(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_instance_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_instance), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.DeleteInstanceRequest()
-
-
def test_delete_instance_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3187,25 +2882,6 @@ def test_delete_instance_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_instance_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_instance), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_instance()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.DeleteInstanceRequest()
-
-
@pytest.mark.asyncio
async def test_delete_instance_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3214,7 +2890,7 @@ async def test_delete_instance_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3254,7 +2930,7 @@ async def test_delete_instance_async(
request_type=bigtable_instance_admin.DeleteInstanceRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3315,7 +2991,7 @@ def test_delete_instance_field_headers():
@pytest.mark.asyncio
async def test_delete_instance_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -3383,7 +3059,7 @@ def test_delete_instance_flattened_error():
@pytest.mark.asyncio
async def test_delete_instance_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3410,7 +3086,7 @@ async def test_delete_instance_flattened_async():
@pytest.mark.asyncio
async def test_delete_instance_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3455,25 +3131,6 @@ def test_create_cluster(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_create_cluster_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_cluster), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.CreateClusterRequest()
-
-
def test_create_cluster_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3544,27 +3201,6 @@ def test_create_cluster_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_cluster_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_cluster), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.create_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.CreateClusterRequest()
-
-
@pytest.mark.asyncio
async def test_create_cluster_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3573,7 +3209,7 @@ async def test_create_cluster_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3618,7 +3254,7 @@ async def test_create_cluster_async(
request_type=bigtable_instance_admin.CreateClusterRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3681,7 +3317,7 @@ def test_create_cluster_field_headers():
@pytest.mark.asyncio
async def test_create_cluster_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -3761,7 +3397,7 @@ def test_create_cluster_flattened_error():
@pytest.mark.asyncio
async def test_create_cluster_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3798,7 +3434,7 @@ async def test_create_cluster_flattened_async():
@pytest.mark.asyncio
async def test_create_cluster_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3861,25 +3497,6 @@ def test_get_cluster(request_type, transport: str = "grpc"):
assert response.default_storage_type == common.StorageType.SSD
-def test_get_cluster_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_cluster), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.GetClusterRequest()
-
-
def test_get_cluster_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3943,34 +3560,6 @@ def test_get_cluster_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_cluster_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_cluster), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- instance.Cluster(
- name="name_value",
- location="location_value",
- state=instance.Cluster.State.READY,
- serve_nodes=1181,
- node_scaling_factor=instance.Cluster.NodeScalingFactor.NODE_SCALING_FACTOR_1X,
- default_storage_type=common.StorageType.SSD,
- )
- )
- response = await client.get_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.GetClusterRequest()
-
-
@pytest.mark.asyncio
async def test_get_cluster_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3979,7 +3568,7 @@ async def test_get_cluster_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4019,7 +3608,7 @@ async def test_get_cluster_async(
request_type=bigtable_instance_admin.GetClusterRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4098,7 +3687,7 @@ def test_get_cluster_field_headers():
@pytest.mark.asyncio
async def test_get_cluster_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4166,7 +3755,7 @@ def test_get_cluster_flattened_error():
@pytest.mark.asyncio
async def test_get_cluster_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4193,7 +3782,7 @@ async def test_get_cluster_flattened_async():
@pytest.mark.asyncio
async def test_get_cluster_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4244,25 +3833,6 @@ def test_list_clusters(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_clusters_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_clusters), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_clusters()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListClustersRequest()
-
-
def test_list_clusters_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4328,30 +3898,6 @@ def test_list_clusters_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_clusters_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_clusters), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_instance_admin.ListClustersResponse(
- failed_locations=["failed_locations_value"],
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_clusters()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListClustersRequest()
-
-
@pytest.mark.asyncio
async def test_list_clusters_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4360,7 +3906,7 @@ async def test_list_clusters_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4400,7 +3946,7 @@ async def test_list_clusters_async(
request_type=bigtable_instance_admin.ListClustersRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4468,7 +4014,7 @@ def test_list_clusters_field_headers():
@pytest.mark.asyncio
async def test_list_clusters_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4538,7 +4084,7 @@ def test_list_clusters_flattened_error():
@pytest.mark.asyncio
async def test_list_clusters_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4567,7 +4113,7 @@ async def test_list_clusters_flattened_async():
@pytest.mark.asyncio
async def test_list_clusters_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4612,25 +4158,6 @@ def test_update_cluster(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_update_cluster_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_cluster), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.update_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == instance.Cluster()
-
-
def test_update_cluster_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4701,27 +4228,6 @@ def test_update_cluster_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_update_cluster_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_cluster), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.update_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == instance.Cluster()
-
-
@pytest.mark.asyncio
async def test_update_cluster_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4730,7 +4236,7 @@ async def test_update_cluster_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4774,7 +4280,7 @@ async def test_update_cluster_async(
transport: str = "grpc_asyncio", request_type=instance.Cluster
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4837,7 +4343,7 @@ def test_update_cluster_field_headers():
@pytest.mark.asyncio
async def test_update_cluster_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4901,27 +4407,6 @@ def test_partial_update_cluster(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_partial_update_cluster_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.partial_update_cluster), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.partial_update_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.PartialUpdateClusterRequest()
-
-
def test_partial_update_cluster_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4993,29 +4478,6 @@ def test_partial_update_cluster_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_partial_update_cluster_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.partial_update_cluster), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.partial_update_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.PartialUpdateClusterRequest()
-
-
@pytest.mark.asyncio
async def test_partial_update_cluster_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -5024,7 +4486,7 @@ async def test_partial_update_cluster_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5069,7 +4531,7 @@ async def test_partial_update_cluster_async(
request_type=bigtable_instance_admin.PartialUpdateClusterRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5136,7 +4598,7 @@ def test_partial_update_cluster_field_headers():
@pytest.mark.asyncio
async def test_partial_update_cluster_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -5215,7 +4677,7 @@ def test_partial_update_cluster_flattened_error():
@pytest.mark.asyncio
async def test_partial_update_cluster_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -5250,7 +4712,7 @@ async def test_partial_update_cluster_flattened_async():
@pytest.mark.asyncio
async def test_partial_update_cluster_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -5296,25 +4758,6 @@ def test_delete_cluster(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_cluster_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_cluster), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.DeleteClusterRequest()
-
-
def test_delete_cluster_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -5378,25 +4821,6 @@ def test_delete_cluster_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_cluster_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_cluster), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_cluster()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.DeleteClusterRequest()
-
-
@pytest.mark.asyncio
async def test_delete_cluster_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -5405,7 +4829,7 @@ async def test_delete_cluster_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5445,7 +4869,7 @@ async def test_delete_cluster_async(
request_type=bigtable_instance_admin.DeleteClusterRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5506,7 +4930,7 @@ def test_delete_cluster_field_headers():
@pytest.mark.asyncio
async def test_delete_cluster_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -5574,7 +4998,7 @@ def test_delete_cluster_flattened_error():
@pytest.mark.asyncio
async def test_delete_cluster_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -5601,7 +5025,7 @@ async def test_delete_cluster_flattened_async():
@pytest.mark.asyncio
async def test_delete_cluster_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -5656,27 +5080,6 @@ def test_create_app_profile(request_type, transport: str = "grpc"):
assert response.description == "description_value"
-def test_create_app_profile_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.create_app_profile), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.CreateAppProfileRequest()
-
-
def test_create_app_profile_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -5748,33 +5151,6 @@ def test_create_app_profile_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_app_profile_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.create_app_profile), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- instance.AppProfile(
- name="name_value",
- etag="etag_value",
- description="description_value",
- )
- )
- response = await client.create_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.CreateAppProfileRequest()
-
-
@pytest.mark.asyncio
async def test_create_app_profile_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -5783,7 +5159,7 @@ async def test_create_app_profile_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5823,7 +5199,7 @@ async def test_create_app_profile_async(
request_type=bigtable_instance_admin.CreateAppProfileRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5897,7 +5273,7 @@ def test_create_app_profile_field_headers():
@pytest.mark.asyncio
async def test_create_app_profile_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -5979,7 +5355,7 @@ def test_create_app_profile_flattened_error():
@pytest.mark.asyncio
async def test_create_app_profile_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -6016,7 +5392,7 @@ async def test_create_app_profile_flattened_async():
@pytest.mark.asyncio
async def test_create_app_profile_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -6071,25 +5447,6 @@ def test_get_app_profile(request_type, transport: str = "grpc"):
assert response.description == "description_value"
-def test_get_app_profile_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_app_profile), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.GetAppProfileRequest()
-
-
def test_get_app_profile_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -6153,31 +5510,6 @@ def test_get_app_profile_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_app_profile_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_app_profile), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- instance.AppProfile(
- name="name_value",
- etag="etag_value",
- description="description_value",
- )
- )
- response = await client.get_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.GetAppProfileRequest()
-
-
@pytest.mark.asyncio
async def test_get_app_profile_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -6186,7 +5518,7 @@ async def test_get_app_profile_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6226,7 +5558,7 @@ async def test_get_app_profile_async(
request_type=bigtable_instance_admin.GetAppProfileRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6296,7 +5628,7 @@ def test_get_app_profile_field_headers():
@pytest.mark.asyncio
async def test_get_app_profile_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -6364,7 +5696,7 @@ def test_get_app_profile_flattened_error():
@pytest.mark.asyncio
async def test_get_app_profile_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -6391,7 +5723,7 @@ async def test_get_app_profile_flattened_async():
@pytest.mark.asyncio
async def test_get_app_profile_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -6443,27 +5775,6 @@ def test_list_app_profiles(request_type, transport: str = "grpc"):
assert response.failed_locations == ["failed_locations_value"]
-def test_list_app_profiles_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.list_app_profiles), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_app_profiles()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListAppProfilesRequest()
-
-
def test_list_app_profiles_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -6533,32 +5844,6 @@ def test_list_app_profiles_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_app_profiles_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.list_app_profiles), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_instance_admin.ListAppProfilesResponse(
- next_page_token="next_page_token_value",
- failed_locations=["failed_locations_value"],
- )
- )
- response = await client.list_app_profiles()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListAppProfilesRequest()
-
-
@pytest.mark.asyncio
async def test_list_app_profiles_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -6567,7 +5852,7 @@ async def test_list_app_profiles_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6607,7 +5892,7 @@ async def test_list_app_profiles_async(
request_type=bigtable_instance_admin.ListAppProfilesRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6679,7 +5964,7 @@ def test_list_app_profiles_field_headers():
@pytest.mark.asyncio
async def test_list_app_profiles_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -6753,7 +6038,7 @@ def test_list_app_profiles_flattened_error():
@pytest.mark.asyncio
async def test_list_app_profiles_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -6784,7 +6069,7 @@ async def test_list_app_profiles_flattened_async():
@pytest.mark.asyncio
async def test_list_app_profiles_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -6898,7 +6183,7 @@ def test_list_app_profiles_pages(transport_name: str = "grpc"):
@pytest.mark.asyncio
async def test_list_app_profiles_async_pager():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -6950,7 +6235,7 @@ async def test_list_app_profiles_async_pager():
@pytest.mark.asyncio
async def test_list_app_profiles_async_pages():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -7033,27 +6318,6 @@ def test_update_app_profile(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_update_app_profile_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.update_app_profile), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.update_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.UpdateAppProfileRequest()
-
-
def test_update_app_profile_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -7124,29 +6388,6 @@ def test_update_app_profile_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_update_app_profile_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.update_app_profile), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.update_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.UpdateAppProfileRequest()
-
-
@pytest.mark.asyncio
async def test_update_app_profile_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -7155,7 +6396,7 @@ async def test_update_app_profile_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7200,7 +6441,7 @@ async def test_update_app_profile_async(
request_type=bigtable_instance_admin.UpdateAppProfileRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7267,7 +6508,7 @@ def test_update_app_profile_field_headers():
@pytest.mark.asyncio
async def test_update_app_profile_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -7346,7 +6587,7 @@ def test_update_app_profile_flattened_error():
@pytest.mark.asyncio
async def test_update_app_profile_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -7381,7 +6622,7 @@ async def test_update_app_profile_flattened_async():
@pytest.mark.asyncio
async def test_update_app_profile_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -7429,27 +6670,6 @@ def test_delete_app_profile(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_app_profile_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.delete_app_profile), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.DeleteAppProfileRequest()
-
-
def test_delete_app_profile_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -7519,27 +6739,6 @@ def test_delete_app_profile_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_app_profile_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.delete_app_profile), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_app_profile()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.DeleteAppProfileRequest()
-
-
@pytest.mark.asyncio
async def test_delete_app_profile_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -7548,7 +6747,7 @@ async def test_delete_app_profile_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7588,7 +6787,7 @@ async def test_delete_app_profile_async(
request_type=bigtable_instance_admin.DeleteAppProfileRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7653,7 +6852,7 @@ def test_delete_app_profile_field_headers():
@pytest.mark.asyncio
async def test_delete_app_profile_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -7725,7 +6924,7 @@ def test_delete_app_profile_flattened_error():
@pytest.mark.asyncio
async def test_delete_app_profile_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -7754,7 +6953,7 @@ async def test_delete_app_profile_flattened_async():
@pytest.mark.asyncio
async def test_delete_app_profile_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -7804,25 +7003,6 @@ def test_get_iam_policy(request_type, transport: str = "grpc"):
assert response.etag == b"etag_blob"
-def test_get_iam_policy_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.GetIamPolicyRequest()
-
-
def test_get_iam_policy_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -7886,30 +7066,6 @@ def test_get_iam_policy_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_iam_policy_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
- )
- response = await client.get_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.GetIamPolicyRequest()
-
-
@pytest.mark.asyncio
async def test_get_iam_policy_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -7918,7 +7074,7 @@ async def test_get_iam_policy_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7957,7 +7113,7 @@ async def test_get_iam_policy_async(
transport: str = "grpc_asyncio", request_type=iam_policy_pb2.GetIamPolicyRequest
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8025,7 +7181,7 @@ def test_get_iam_policy_field_headers():
@pytest.mark.asyncio
async def test_get_iam_policy_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -8110,7 +7266,7 @@ def test_get_iam_policy_flattened_error():
@pytest.mark.asyncio
async def test_get_iam_policy_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8137,7 +7293,7 @@ async def test_get_iam_policy_flattened_async():
@pytest.mark.asyncio
async def test_get_iam_policy_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -8187,25 +7343,6 @@ def test_set_iam_policy(request_type, transport: str = "grpc"):
assert response.etag == b"etag_blob"
-def test_set_iam_policy_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.set_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.SetIamPolicyRequest()
-
-
def test_set_iam_policy_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -8270,40 +7407,16 @@ def test_set_iam_policy_use_cached_wrapped_rpc():
@pytest.mark.asyncio
-async def test_set_iam_policy_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
- )
- response = await client.set_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.SetIamPolicyRequest()
-
-
-@pytest.mark.asyncio
-async def test_set_iam_policy_async_use_cached_wrapped_rpc(
- transport: str = "grpc_asyncio",
-):
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
+async def test_set_iam_policy_async_use_cached_wrapped_rpc(
+ transport: str = "grpc_asyncio",
+):
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport=transport,
+ )
# Should wrap all calls on client creation
assert wrapper_fn.call_count > 0
@@ -8340,7 +7453,7 @@ async def test_set_iam_policy_async(
transport: str = "grpc_asyncio", request_type=iam_policy_pb2.SetIamPolicyRequest
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8408,7 +7521,7 @@ def test_set_iam_policy_field_headers():
@pytest.mark.asyncio
async def test_set_iam_policy_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -8494,7 +7607,7 @@ def test_set_iam_policy_flattened_error():
@pytest.mark.asyncio
async def test_set_iam_policy_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8521,7 +7634,7 @@ async def test_set_iam_policy_flattened_async():
@pytest.mark.asyncio
async def test_set_iam_policy_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -8571,27 +7684,6 @@ def test_test_iam_permissions(request_type, transport: str = "grpc"):
assert response.permissions == ["permissions_value"]
-def test_test_iam_permissions_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.test_iam_permissions), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.test_iam_permissions()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.TestIamPermissionsRequest()
-
-
def test_test_iam_permissions_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -8661,31 +7753,6 @@ def test_test_iam_permissions_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_test_iam_permissions_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.test_iam_permissions), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- iam_policy_pb2.TestIamPermissionsResponse(
- permissions=["permissions_value"],
- )
- )
- response = await client.test_iam_permissions()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.TestIamPermissionsRequest()
-
-
@pytest.mark.asyncio
async def test_test_iam_permissions_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -8694,7 +7761,7 @@ async def test_test_iam_permissions_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8734,7 +7801,7 @@ async def test_test_iam_permissions_async(
request_type=iam_policy_pb2.TestIamPermissionsRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8804,7 +7871,7 @@ def test_test_iam_permissions_field_headers():
@pytest.mark.asyncio
async def test_test_iam_permissions_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -8902,7 +7969,7 @@ def test_test_iam_permissions_flattened_error():
@pytest.mark.asyncio
async def test_test_iam_permissions_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8937,7 +8004,7 @@ async def test_test_iam_permissions_flattened_async():
@pytest.mark.asyncio
async def test_test_iam_permissions_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -8986,25 +8053,6 @@ def test_list_hot_tablets(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_hot_tablets_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_hot_tablets), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_hot_tablets()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListHotTabletsRequest()
-
-
def test_list_hot_tablets_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -9072,29 +8120,6 @@ def test_list_hot_tablets_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_hot_tablets_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_hot_tablets), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_instance_admin.ListHotTabletsResponse(
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_hot_tablets()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_instance_admin.ListHotTabletsRequest()
-
-
@pytest.mark.asyncio
async def test_list_hot_tablets_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -9103,7 +8128,7 @@ async def test_list_hot_tablets_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9143,7 +8168,7 @@ async def test_list_hot_tablets_async(
request_type=bigtable_instance_admin.ListHotTabletsRequest,
):
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9209,7 +8234,7 @@ def test_list_hot_tablets_field_headers():
@pytest.mark.asyncio
async def test_list_hot_tablets_field_headers_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -9279,7 +8304,7 @@ def test_list_hot_tablets_flattened_error():
@pytest.mark.asyncio
async def test_list_hot_tablets_flattened_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -9308,7 +8333,7 @@ async def test_list_hot_tablets_flattened_async():
@pytest.mark.asyncio
async def test_list_hot_tablets_flattened_error_async():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -9418,7 +8443,7 @@ def test_list_hot_tablets_pages(transport_name: str = "grpc"):
@pytest.mark.asyncio
async def test_list_hot_tablets_async_pager():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -9468,7 +8493,7 @@ async def test_list_hot_tablets_async_pager():
@pytest.mark.asyncio
async def test_list_hot_tablets_async_pages():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -9514,41 +8539,6 @@ async def test_list_hot_tablets_async_pages():
assert page_.raw_page.next_page_token == token
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.CreateInstanceRequest,
- dict,
- ],
-)
-def test_create_instance_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_instance(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
def test_create_instance_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -9684,89 +8674,6 @@ def test_create_instance_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_instance_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_create_instance"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_create_instance"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.CreateInstanceRequest.pb(
- bigtable_instance_admin.CreateInstanceRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_instance_admin.CreateInstanceRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.create_instance(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_instance_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.CreateInstanceRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_instance(request)
-
-
def test_create_instance_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -9826,82 +8733,28 @@ def test_create_instance_rest_flattened_error(transport: str = "rest"):
)
-def test_create_instance_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+def test_get_instance_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.GetInstanceRequest,
- dict,
- ],
-)
-def test_get_instance_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+ # Ensure method has been cached
+ assert client._transport.get_instance in client._transport._wrapped_methods
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = instance.Instance(
- name="name_value",
- display_name="display_name_value",
- state=instance.Instance.State.READY,
- type_=instance.Instance.Type.PRODUCTION,
- satisfies_pzs=True,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = instance.Instance.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_instance(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, instance.Instance)
- assert response.name == "name_value"
- assert response.display_name == "display_name_value"
- assert response.state == instance.Instance.State.READY
- assert response.type_ == instance.Instance.Type.PRODUCTION
- assert response.satisfies_pzs is True
-
-
-def test_get_instance_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert client._transport.get_instance in client._transport._wrapped_methods
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[client._transport.get_instance] = mock_rpc
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[client._transport.get_instance] = mock_rpc
request = {}
client.get_instance(request)
@@ -9999,85 +8852,6 @@ def test_get_instance_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_instance_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_get_instance"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_get_instance"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.GetInstanceRequest.pb(
- bigtable_instance_admin.GetInstanceRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = instance.Instance.to_json(instance.Instance())
-
- request = bigtable_instance_admin.GetInstanceRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = instance.Instance()
-
- client.get_instance(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_instance_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.GetInstanceRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_instance(request)
-
-
def test_get_instance_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -10133,56 +8907,6 @@ def test_get_instance_rest_flattened_error(transport: str = "rest"):
)
-def test_get_instance_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.ListInstancesRequest,
- dict,
- ],
-)
-def test_list_instances_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_instance_admin.ListInstancesResponse(
- failed_locations=["failed_locations_value"],
- next_page_token="next_page_token_value",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_instance_admin.ListInstancesResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_instances(request)
-
- assert response.raw_page is response
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable_instance_admin.ListInstancesResponse)
- assert response.failed_locations == ["failed_locations_value"]
- assert response.next_page_token == "next_page_token_value"
-
-
def test_list_instances_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -10306,89 +9030,6 @@ def test_list_instances_rest_unset_required_fields():
assert set(unset_fields) == (set(("pageToken",)) & set(("parent",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_instances_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_list_instances"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_list_instances"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.ListInstancesRequest.pb(
- bigtable_instance_admin.ListInstancesRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_instance_admin.ListInstancesResponse.to_json(
- bigtable_instance_admin.ListInstancesResponse()
- )
- )
-
- request = bigtable_instance_admin.ListInstancesRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_instance_admin.ListInstancesResponse()
-
- client.list_instances(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_instances_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.ListInstancesRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_instances(request)
-
-
def test_list_instances_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -10444,60 +9085,6 @@ def test_list_instances_rest_flattened_error(transport: str = "rest"):
)
-def test_list_instances_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- instance.Instance,
- dict,
- ],
-)
-def test_update_instance_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = instance.Instance(
- name="name_value",
- display_name="display_name_value",
- state=instance.Instance.State.READY,
- type_=instance.Instance.Type.PRODUCTION,
- satisfies_pzs=True,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = instance.Instance.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.update_instance(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, instance.Instance)
- assert response.name == "name_value"
- assert response.display_name == "display_name_value"
- assert response.state == instance.Instance.State.READY
- assert response.type_ == instance.Instance.Type.PRODUCTION
- assert response.satisfies_pzs is True
-
-
def test_update_instance_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -10616,202 +9203,6 @@ def test_update_instance_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("displayName",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_update_instance_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_update_instance"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_update_instance"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = instance.Instance.pb(instance.Instance())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = instance.Instance.to_json(instance.Instance())
-
- request = instance.Instance()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = instance.Instance()
-
- client.update_instance(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_update_instance_rest_bad_request(
- transport: str = "rest", request_type=instance.Instance
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.update_instance(request)
-
-
-def test_update_instance_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.PartialUpdateInstanceRequest,
- dict,
- ],
-)
-def test_partial_update_instance_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"instance": {"name": "projects/sample1/instances/sample2"}}
- request_init["instance"] = {
- "name": "projects/sample1/instances/sample2",
- "display_name": "display_name_value",
- "state": 1,
- "type_": 1,
- "labels": {},
- "create_time": {"seconds": 751, "nanos": 543},
- "satisfies_pzs": True,
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
-
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_instance_admin.PartialUpdateInstanceRequest.meta.fields[
- "instance"
- ]
-
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
-
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["instance"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["instance"][field])):
- del request_init["instance"][field][i][subfield]
- else:
- del request_init["instance"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.partial_update_instance(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
def test_partial_update_instance_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -10943,94 +9334,10 @@ def test_partial_update_instance_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_partial_update_instance_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_partial_update_instance_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_partial_update_instance"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_partial_update_instance"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.PartialUpdateInstanceRequest.pb(
- bigtable_instance_admin.PartialUpdateInstanceRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_instance_admin.PartialUpdateInstanceRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.partial_update_instance(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_partial_update_instance_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_instance_admin.PartialUpdateInstanceRequest,
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"instance": {"name": "projects/sample1/instances/sample2"}}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.partial_update_instance(request)
-
-
-def test_partial_update_instance_rest_flattened():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
@@ -11083,47 +9390,6 @@ def test_partial_update_instance_rest_flattened_error(transport: str = "rest"):
)
-def test_partial_update_instance_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.DeleteInstanceRequest,
- dict,
- ],
-)
-def test_delete_instance_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_instance(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
def test_delete_instance_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -11240,79 +9506,6 @@ def test_delete_instance_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_instance_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_delete_instance"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_instance_admin.DeleteInstanceRequest.pb(
- bigtable_instance_admin.DeleteInstanceRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_instance_admin.DeleteInstanceRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.delete_instance(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
-
-
-def test_delete_instance_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.DeleteInstanceRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_instance(request)
-
-
def test_delete_instance_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -11366,169 +9559,40 @@ def test_delete_instance_rest_flattened_error(transport: str = "rest"):
)
-def test_delete_instance_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
+def test_create_cluster_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.CreateClusterRequest,
- dict,
- ],
-)
-def test_create_cluster_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request_init["cluster"] = {
- "name": "name_value",
- "location": "location_value",
- "state": 1,
- "serve_nodes": 1181,
- "node_scaling_factor": 1,
- "cluster_config": {
- "cluster_autoscaling_config": {
- "autoscaling_limits": {
- "min_serve_nodes": 1600,
- "max_serve_nodes": 1602,
- },
- "autoscaling_targets": {
- "cpu_utilization_percent": 2483,
- "storage_utilization_gib_per_node": 3404,
- },
- }
- },
- "default_storage_type": 1,
- "encryption_config": {"kms_key_name": "kms_key_name_value"},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
+ # Ensure method has been cached
+ assert client._transport.create_cluster in client._transport._wrapped_methods
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_instance_admin.CreateClusterRequest.meta.fields["cluster"]
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[client._transport.create_cluster] = mock_rpc
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
+ request = {}
+ client.create_cluster(request)
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+ # Establish that the underlying gRPC stub method was called.
+ assert mock_rpc.call_count == 1
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["cluster"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["cluster"][field])):
- del request_init["cluster"][field][i][subfield]
- else:
- del request_init["cluster"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_cluster(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_create_cluster_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert client._transport.create_cluster in client._transport._wrapped_methods
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[client._transport.create_cluster] = mock_rpc
-
- request = {}
- client.create_cluster(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert mock_rpc.call_count == 1
-
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.create_cluster(request)
+ client.create_cluster(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
@@ -11640,89 +9704,6 @@ def test_create_cluster_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_cluster_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_create_cluster"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_create_cluster"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.CreateClusterRequest.pb(
- bigtable_instance_admin.CreateClusterRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_instance_admin.CreateClusterRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.create_cluster(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_cluster_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.CreateClusterRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_cluster(request)
-
-
def test_create_cluster_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -11781,65 +9762,6 @@ def test_create_cluster_rest_flattened_error(transport: str = "rest"):
)
-def test_create_cluster_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.GetClusterRequest,
- dict,
- ],
-)
-def test_get_cluster_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = instance.Cluster(
- name="name_value",
- location="location_value",
- state=instance.Cluster.State.READY,
- serve_nodes=1181,
- node_scaling_factor=instance.Cluster.NodeScalingFactor.NODE_SCALING_FACTOR_1X,
- default_storage_type=common.StorageType.SSD,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = instance.Cluster.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_cluster(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, instance.Cluster)
- assert response.name == "name_value"
- assert response.location == "location_value"
- assert response.state == instance.Cluster.State.READY
- assert response.serve_nodes == 1181
- assert (
- response.node_scaling_factor
- == instance.Cluster.NodeScalingFactor.NODE_SCALING_FACTOR_1X
- )
- assert response.default_storage_type == common.StorageType.SSD
-
-
def test_get_cluster_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -11959,89 +9881,10 @@ def test_get_cluster_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_cluster_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_get_cluster_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_get_cluster"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_get_cluster"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.GetClusterRequest.pb(
- bigtable_instance_admin.GetClusterRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = instance.Cluster.to_json(instance.Cluster())
-
- request = bigtable_instance_admin.GetClusterRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = instance.Cluster()
-
- client.get_cluster(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_cluster_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.GetClusterRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_cluster(request)
-
-
-def test_get_cluster_rest_flattened():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
@@ -12094,56 +9937,6 @@ def test_get_cluster_rest_flattened_error(transport: str = "rest"):
)
-def test_get_cluster_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.ListClustersRequest,
- dict,
- ],
-)
-def test_list_clusters_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_instance_admin.ListClustersResponse(
- failed_locations=["failed_locations_value"],
- next_page_token="next_page_token_value",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_instance_admin.ListClustersResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_clusters(request)
-
- assert response.raw_page is response
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable_instance_admin.ListClustersResponse)
- assert response.failed_locations == ["failed_locations_value"]
- assert response.next_page_token == "next_page_token_value"
-
-
def test_list_clusters_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -12265,89 +10058,6 @@ def test_list_clusters_rest_unset_required_fields():
assert set(unset_fields) == (set(("pageToken",)) & set(("parent",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_clusters_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_list_clusters"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_list_clusters"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.ListClustersRequest.pb(
- bigtable_instance_admin.ListClustersRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_instance_admin.ListClustersResponse.to_json(
- bigtable_instance_admin.ListClustersResponse()
- )
- )
-
- request = bigtable_instance_admin.ListClustersRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_instance_admin.ListClustersResponse()
-
- client.list_clusters(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_clusters_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.ListClustersRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_clusters(request)
-
-
def test_list_clusters_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -12404,48 +10114,47 @@ def test_list_clusters_rest_flattened_error(transport: str = "rest"):
)
-def test_list_clusters_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+def test_update_cluster_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
-@pytest.mark.parametrize(
- "request_type",
- [
- instance.Cluster,
- dict,
- ],
-)
-def test_update_cluster_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+ # Ensure method has been cached
+ assert client._transport.update_cluster in client._transport._wrapped_methods
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[client._transport.update_cluster] = mock_rpc
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ request = {}
+ client.update_cluster(request)
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
+ # Establish that the underlying gRPC stub method was called.
+ assert mock_rpc.call_count == 1
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.update_cluster(request)
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
+ client.update_cluster(request)
+
+ # Establish that a new wrapper was not created for this call
+ assert wrapper_fn.call_count == 0
+ assert mock_rpc.call_count == 2
-def test_update_cluster_rest_use_cached_wrapped_rpc():
+def test_partial_update_cluster_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -12459,17 +10168,22 @@ def test_update_cluster_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.update_cluster in client._transport._wrapped_methods
+ assert (
+ client._transport.partial_update_cluster
+ in client._transport._wrapped_methods
+ )
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.update_cluster] = mock_rpc
+ client._transport._wrapped_methods[
+ client._transport.partial_update_cluster
+ ] = mock_rpc
request = {}
- client.update_cluster(request)
+ client.partial_update_cluster(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
@@ -12478,266 +10192,7 @@ def test_update_cluster_rest_use_cached_wrapped_rpc():
# subsequent calls should use the cached wrapper
wrapper_fn.reset_mock()
- client.update_cluster(request)
-
- # Establish that a new wrapper was not created for this call
- assert wrapper_fn.call_count == 0
- assert mock_rpc.call_count == 2
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_update_cluster_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_update_cluster"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_update_cluster"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = instance.Cluster.pb(instance.Cluster())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = instance.Cluster()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.update_cluster(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_update_cluster_rest_bad_request(
- transport: str = "rest", request_type=instance.Cluster
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.update_cluster(request)
-
-
-def test_update_cluster_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.PartialUpdateClusterRequest,
- dict,
- ],
-)
-def test_partial_update_cluster_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "cluster": {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- }
- request_init["cluster"] = {
- "name": "projects/sample1/instances/sample2/clusters/sample3",
- "location": "location_value",
- "state": 1,
- "serve_nodes": 1181,
- "node_scaling_factor": 1,
- "cluster_config": {
- "cluster_autoscaling_config": {
- "autoscaling_limits": {
- "min_serve_nodes": 1600,
- "max_serve_nodes": 1602,
- },
- "autoscaling_targets": {
- "cpu_utilization_percent": 2483,
- "storage_utilization_gib_per_node": 3404,
- },
- }
- },
- "default_storage_type": 1,
- "encryption_config": {"kms_key_name": "kms_key_name_value"},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
-
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_instance_admin.PartialUpdateClusterRequest.meta.fields[
- "cluster"
- ]
-
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
-
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["cluster"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["cluster"][field])):
- del request_init["cluster"][field][i][subfield]
- else:
- del request_init["cluster"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.partial_update_cluster(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_partial_update_cluster_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert (
- client._transport.partial_update_cluster
- in client._transport._wrapped_methods
- )
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[
- client._transport.partial_update_cluster
- ] = mock_rpc
-
- request = {}
- client.partial_update_cluster(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert mock_rpc.call_count == 1
-
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.partial_update_cluster(request)
+ client.partial_update_cluster(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
@@ -12830,96 +10285,10 @@ def test_partial_update_cluster_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_partial_update_cluster_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_partial_update_cluster_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_partial_update_cluster"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_partial_update_cluster"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.PartialUpdateClusterRequest.pb(
- bigtable_instance_admin.PartialUpdateClusterRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_instance_admin.PartialUpdateClusterRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.partial_update_cluster(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_partial_update_cluster_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_instance_admin.PartialUpdateClusterRequest,
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "cluster": {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.partial_update_cluster(request)
-
-
-def test_partial_update_cluster_rest_flattened():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
@@ -12975,47 +10344,6 @@ def test_partial_update_cluster_rest_flattened_error(transport: str = "rest"):
)
-def test_partial_update_cluster_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.DeleteClusterRequest,
- dict,
- ],
-)
-def test_delete_cluster_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_cluster(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
def test_delete_cluster_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -13132,79 +10460,6 @@ def test_delete_cluster_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_cluster_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_delete_cluster"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_instance_admin.DeleteClusterRequest.pb(
- bigtable_instance_admin.DeleteClusterRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_instance_admin.DeleteClusterRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.delete_cluster(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
-
-
-def test_delete_cluster_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.DeleteClusterRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_cluster(request)
-
-
def test_delete_cluster_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -13259,176 +10514,40 @@ def test_delete_cluster_rest_flattened_error(transport: str = "rest"):
)
-def test_delete_cluster_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+def test_create_app_profile_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.CreateAppProfileRequest,
- dict,
- ],
-)
-def test_create_app_profile_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+ # Ensure method has been cached
+ assert (
+ client._transport.create_app_profile in client._transport._wrapped_methods
+ )
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request_init["app_profile"] = {
- "name": "name_value",
- "etag": "etag_value",
- "description": "description_value",
- "multi_cluster_routing_use_any": {
- "cluster_ids": ["cluster_ids_value1", "cluster_ids_value2"],
- "row_affinity": {},
- },
- "single_cluster_routing": {
- "cluster_id": "cluster_id_value",
- "allow_transactional_writes": True,
- },
- "priority": 1,
- "standard_isolation": {"priority": 1},
- "data_boost_isolation_read_only": {"compute_billing_owner": 1},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[
+ client._transport.create_app_profile
+ ] = mock_rpc
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_instance_admin.CreateAppProfileRequest.meta.fields[
- "app_profile"
- ]
+ request = {}
+ client.create_app_profile(request)
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
+ # Establish that the underlying gRPC stub method was called.
+ assert mock_rpc.call_count == 1
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["app_profile"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["app_profile"][field])):
- del request_init["app_profile"][field][i][subfield]
- else:
- del request_init["app_profile"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = instance.AppProfile(
- name="name_value",
- etag="etag_value",
- description="description_value",
- priority=instance.AppProfile.Priority.PRIORITY_LOW,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = instance.AppProfile.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_app_profile(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, instance.AppProfile)
- assert response.name == "name_value"
- assert response.etag == "etag_value"
- assert response.description == "description_value"
-
-
-def test_create_app_profile_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert (
- client._transport.create_app_profile in client._transport._wrapped_methods
- )
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[
- client._transport.create_app_profile
- ] = mock_rpc
-
- request = {}
- client.create_app_profile(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert mock_rpc.call_count == 1
-
- client.create_app_profile(request)
+ client.create_app_profile(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
@@ -13553,86 +10672,6 @@ def test_create_app_profile_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_app_profile_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_create_app_profile"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_create_app_profile"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.CreateAppProfileRequest.pb(
- bigtable_instance_admin.CreateAppProfileRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = instance.AppProfile.to_json(instance.AppProfile())
-
- request = bigtable_instance_admin.CreateAppProfileRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = instance.AppProfile()
-
- client.create_app_profile(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_app_profile_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_instance_admin.CreateAppProfileRequest,
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_app_profile(request)
-
-
def test_create_app_profile_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -13694,57 +10733,6 @@ def test_create_app_profile_rest_flattened_error(transport: str = "rest"):
)
-def test_create_app_profile_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.GetAppProfileRequest,
- dict,
- ],
-)
-def test_get_app_profile_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = instance.AppProfile(
- name="name_value",
- etag="etag_value",
- description="description_value",
- priority=instance.AppProfile.Priority.PRIORITY_LOW,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = instance.AppProfile.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_app_profile(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, instance.AppProfile)
- assert response.name == "name_value"
- assert response.etag == "etag_value"
- assert response.description == "description_value"
-
-
def test_get_app_profile_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -13864,89 +10852,10 @@ def test_get_app_profile_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_app_profile_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_get_app_profile_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_get_app_profile"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_get_app_profile"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.GetAppProfileRequest.pb(
- bigtable_instance_admin.GetAppProfileRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = instance.AppProfile.to_json(instance.AppProfile())
-
- request = bigtable_instance_admin.GetAppProfileRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = instance.AppProfile()
-
- client.get_app_profile(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_app_profile_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.GetAppProfileRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_app_profile(request)
-
-
-def test_get_app_profile_rest_flattened():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
@@ -14002,54 +10911,6 @@ def test_get_app_profile_rest_flattened_error(transport: str = "rest"):
)
-def test_get_app_profile_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.ListAppProfilesRequest,
- dict,
- ],
-)
-def test_list_app_profiles_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_instance_admin.ListAppProfilesResponse(
- next_page_token="next_page_token_value",
- failed_locations=["failed_locations_value"],
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_instance_admin.ListAppProfilesResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_app_profiles(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, pagers.ListAppProfilesPager)
- assert response.next_page_token == "next_page_token_value"
- assert response.failed_locations == ["failed_locations_value"]
-
-
def test_list_app_profiles_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -14188,89 +11049,6 @@ def test_list_app_profiles_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_app_profiles_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_list_app_profiles"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_list_app_profiles"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.ListAppProfilesRequest.pb(
- bigtable_instance_admin.ListAppProfilesRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_instance_admin.ListAppProfilesResponse.to_json(
- bigtable_instance_admin.ListAppProfilesResponse()
- )
- )
-
- request = bigtable_instance_admin.ListAppProfilesRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_instance_admin.ListAppProfilesResponse()
-
- client.list_app_profiles(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_app_profiles_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.ListAppProfilesRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_app_profiles(request)
-
-
def test_list_app_profiles_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -14391,159 +11169,35 @@ def test_list_app_profiles_rest_pager(transport: str = "rest"):
assert page_.raw_page.next_page_token == token
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.UpdateAppProfileRequest,
- dict,
- ],
-)
-def test_update_app_profile_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+def test_update_app_profile_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- # send a request that will satisfy transcoding
- request_init = {
- "app_profile": {
- "name": "projects/sample1/instances/sample2/appProfiles/sample3"
- }
- }
- request_init["app_profile"] = {
- "name": "projects/sample1/instances/sample2/appProfiles/sample3",
- "etag": "etag_value",
- "description": "description_value",
- "multi_cluster_routing_use_any": {
- "cluster_ids": ["cluster_ids_value1", "cluster_ids_value2"],
- "row_affinity": {},
- },
- "single_cluster_routing": {
- "cluster_id": "cluster_id_value",
- "allow_transactional_writes": True,
- },
- "priority": 1,
- "standard_isolation": {"priority": 1},
- "data_boost_isolation_read_only": {"compute_billing_owner": 1},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_instance_admin.UpdateAppProfileRequest.meta.fields[
- "app_profile"
- ]
+ # Ensure method has been cached
+ assert (
+ client._transport.update_app_profile in client._transport._wrapped_methods
+ )
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[
+ client._transport.update_app_profile
+ ] = mock_rpc
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["app_profile"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["app_profile"][field])):
- del request_init["app_profile"][field][i][subfield]
- else:
- del request_init["app_profile"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.update_app_profile(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_update_app_profile_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert (
- client._transport.update_app_profile in client._transport._wrapped_methods
- )
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[
- client._transport.update_app_profile
- ] = mock_rpc
-
- request = {}
- client.update_app_profile(request)
+ request = {}
+ client.update_app_profile(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
@@ -14655,94 +11309,6 @@ def test_update_app_profile_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_update_app_profile_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_update_app_profile"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_update_app_profile"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.UpdateAppProfileRequest.pb(
- bigtable_instance_admin.UpdateAppProfileRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_instance_admin.UpdateAppProfileRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.update_app_profile(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_update_app_profile_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_instance_admin.UpdateAppProfileRequest,
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "app_profile": {
- "name": "projects/sample1/instances/sample2/appProfiles/sample3"
- }
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.update_app_profile(request)
-
-
def test_update_app_profile_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -14804,47 +11370,6 @@ def test_update_app_profile_rest_flattened_error(transport: str = "rest"):
)
-def test_update_app_profile_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.DeleteAppProfileRequest,
- dict,
- ],
-)
-def test_delete_app_profile_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_app_profile(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
def test_delete_app_profile_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -14988,90 +11513,16 @@ def test_delete_app_profile_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_app_profile_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_delete_app_profile_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_delete_app_profile"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_instance_admin.DeleteAppProfileRequest.pb(
- bigtable_instance_admin.DeleteAppProfileRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_instance_admin.DeleteAppProfileRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.delete_app_profile(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
-
-
-def test_delete_app_profile_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_instance_admin.DeleteAppProfileRequest,
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_app_profile(request)
-
-
-def test_delete_app_profile_rest_flattened():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
# get arguments that satisfy an http rule for this method
sample_request = {
@@ -15119,52 +11570,6 @@ def test_delete_app_profile_rest_flattened_error(transport: str = "rest"):
)
-def test_delete_app_profile_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- iam_policy_pb2.GetIamPolicyRequest,
- dict,
- ],
-)
-def test_get_iam_policy_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_iam_policy(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, policy_pb2.Policy)
- assert response.version == 774
- assert response.etag == b"etag_blob"
-
-
def test_get_iam_policy_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -15283,83 +11688,6 @@ def test_get_iam_policy_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("resource",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_iam_policy_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_get_iam_policy"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_get_iam_policy"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = iam_policy_pb2.GetIamPolicyRequest()
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(policy_pb2.Policy())
-
- request = iam_policy_pb2.GetIamPolicyRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = policy_pb2.Policy()
-
- client.get_iam_policy(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_iam_policy_rest_bad_request(
- transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_iam_policy(request)
-
-
def test_get_iam_policy_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -15415,52 +11743,6 @@ def test_get_iam_policy_rest_flattened_error(transport: str = "rest"):
)
-def test_get_iam_policy_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- iam_policy_pb2.SetIamPolicyRequest,
- dict,
- ],
-)
-def test_set_iam_policy_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.set_iam_policy(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, policy_pb2.Policy)
- assert response.version == 774
- assert response.etag == b"etag_blob"
-
-
def test_set_iam_policy_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -15587,96 +11869,19 @@ def test_set_iam_policy_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_set_iam_policy_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_set_iam_policy_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_set_iam_policy"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_set_iam_policy"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = iam_policy_pb2.SetIamPolicyRequest()
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(policy_pb2.Policy())
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = policy_pb2.Policy()
- request = iam_policy_pb2.SetIamPolicyRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = policy_pb2.Policy()
-
- client.set_iam_policy(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_set_iam_policy_rest_bad_request(
- transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.set_iam_policy(request)
-
-
-def test_set_iam_policy_rest_flattened():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {"resource": "projects/sample1/instances/sample2"}
+ # get arguments that satisfy an http rule for this method
+ sample_request = {"resource": "projects/sample1/instances/sample2"}
# get truthy value for each flattened field
mock_args = dict(
@@ -15719,50 +11924,6 @@ def test_set_iam_policy_rest_flattened_error(transport: str = "rest"):
)
-def test_set_iam_policy_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- iam_policy_pb2.TestIamPermissionsRequest,
- dict,
- ],
-)
-def test_test_iam_permissions_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = iam_policy_pb2.TestIamPermissionsResponse(
- permissions=["permissions_value"],
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.test_iam_permissions(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
- assert response.permissions == ["permissions_value"]
-
-
def test_test_iam_permissions_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -15897,85 +12058,6 @@ def test_test_iam_permissions_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_test_iam_permissions_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
- )
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_test_iam_permissions"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_test_iam_permissions"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = iam_policy_pb2.TestIamPermissionsRequest()
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- iam_policy_pb2.TestIamPermissionsResponse()
- )
-
- request = iam_policy_pb2.TestIamPermissionsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = iam_policy_pb2.TestIamPermissionsResponse()
-
- client.test_iam_permissions(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_test_iam_permissions_rest_bad_request(
- transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
-):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.test_iam_permissions(request)
-
-
def test_test_iam_permissions_rest_flattened():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -16033,52 +12115,6 @@ def test_test_iam_permissions_rest_flattened_error(transport: str = "rest"):
)
-def test_test_iam_permissions_rest_error():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_instance_admin.ListHotTabletsRequest,
- dict,
- ],
-)
-def test_list_hot_tablets_rest(request_type):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_instance_admin.ListHotTabletsResponse(
- next_page_token="next_page_token_value",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_instance_admin.ListHotTabletsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_hot_tablets(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, pagers.ListHotTabletsPager)
- assert response.next_page_token == "next_page_token_value"
-
-
def test_list_hot_tablets_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -16221,55 +12257,4195 @@ def test_list_hot_tablets_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_hot_tablets_rest_interceptors(null_interceptor):
- transport = transports.BigtableInstanceAdminRestTransport(
+def test_list_hot_tablets_rest_flattened():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableInstanceAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableInstanceAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "post_list_hot_tablets"
- ) as post, mock.patch.object(
- transports.BigtableInstanceAdminRestInterceptor, "pre_list_hot_tablets"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_instance_admin.ListHotTabletsRequest.pb(
- bigtable_instance_admin.ListHotTabletsRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_instance_admin.ListHotTabletsResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
}
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_instance_admin.ListHotTabletsResponse.to_json(
- bigtable_instance_admin.ListHotTabletsResponse()
- )
+ # get truthy value for each flattened field
+ mock_args = dict(
+ parent="parent_value",
)
+ mock_args.update(sample_request)
- request = bigtable_instance_admin.ListHotTabletsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_instance_admin.ListHotTabletsResponse()
-
- client.list_hot_tablets(
- request,
+ # Wrap the value into a proper Response obj
+ response_value = Response()
+ response_value.status_code = 200
+ # Convert return value to protobuf type
+ return_value = bigtable_instance_admin.ListHotTabletsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+
+ client.list_hot_tablets(**mock_args)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(req.mock_calls) == 1
+ _, args, _ = req.mock_calls[0]
+ assert path_template.validate(
+ "%s/v2/{parent=projects/*/instances/*/clusters/*}/hotTablets"
+ % client.transport._host,
+ args[1],
+ )
+
+
+def test_list_hot_tablets_rest_flattened_error(transport: str = "rest"):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.list_hot_tablets(
+ bigtable_instance_admin.ListHotTabletsRequest(),
+ parent="parent_value",
+ )
+
+
+def test_list_hot_tablets_rest_pager(transport: str = "rest"):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(Session, "request") as req:
+ # TODO(kbandes): remove this mock unless there's a good reason for it.
+ # with mock.patch.object(path_template, 'transcode') as transcode:
+ # Set the response as a series of pages
+ response = (
+ bigtable_instance_admin.ListHotTabletsResponse(
+ hot_tablets=[
+ instance.HotTablet(),
+ instance.HotTablet(),
+ instance.HotTablet(),
+ ],
+ next_page_token="abc",
+ ),
+ bigtable_instance_admin.ListHotTabletsResponse(
+ hot_tablets=[],
+ next_page_token="def",
+ ),
+ bigtable_instance_admin.ListHotTabletsResponse(
+ hot_tablets=[
+ instance.HotTablet(),
+ ],
+ next_page_token="ghi",
+ ),
+ bigtable_instance_admin.ListHotTabletsResponse(
+ hot_tablets=[
+ instance.HotTablet(),
+ instance.HotTablet(),
+ ],
+ ),
+ )
+ # Two responses for two calls
+ response = response + response
+
+ # Wrap the values into proper Response objs
+ response = tuple(
+ bigtable_instance_admin.ListHotTabletsResponse.to_json(x) for x in response
+ )
+ return_values = tuple(Response() for i in response)
+ for return_val, response_val in zip(return_values, response):
+ return_val._content = response_val.encode("UTF-8")
+ return_val.status_code = 200
+ req.side_effect = return_values
+
+ sample_request = {
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
+ }
+
+ pager = client.list_hot_tablets(request=sample_request)
+
+ results = list(pager)
+ assert len(results) == 6
+ assert all(isinstance(i, instance.HotTablet) for i in results)
+
+ pages = list(client.list_hot_tablets(request=sample_request).pages)
+ for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
+ assert page_.raw_page.next_page_token == token
+
+
+def test_credentials_transport_error():
+ # It is an error to provide credentials and a transport instance.
+ transport = transports.BigtableInstanceAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # It is an error to provide a credentials file and a transport instance.
+ transport = transports.BigtableInstanceAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = BigtableInstanceAdminClient(
+ client_options={"credentials_file": "credentials.json"},
+ transport=transport,
+ )
+
+ # It is an error to provide an api_key and a transport instance.
+ transport = transports.BigtableInstanceAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ options = client_options.ClientOptions()
+ options.api_key = "api_key"
+ with pytest.raises(ValueError):
+ client = BigtableInstanceAdminClient(
+ client_options=options,
+ transport=transport,
+ )
+
+ # It is an error to provide an api_key and a credential.
+ options = client_options.ClientOptions()
+ options.api_key = "api_key"
+ with pytest.raises(ValueError):
+ client = BigtableInstanceAdminClient(
+ client_options=options, credentials=ga_credentials.AnonymousCredentials()
+ )
+
+ # It is an error to provide scopes and a transport instance.
+ transport = transports.BigtableInstanceAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = BigtableInstanceAdminClient(
+ client_options={"scopes": ["1", "2"]},
+ transport=transport,
+ )
+
+
+def test_transport_instance():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.BigtableInstanceAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+ assert client.transport is transport
+
+
+def test_transport_get_channel():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.BigtableInstanceAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
+
+ transport = transports.BigtableInstanceAdminGrpcAsyncIOTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
+
+
+@pytest.mark.parametrize(
+ "transport_class",
+ [
+ transports.BigtableInstanceAdminGrpcTransport,
+ transports.BigtableInstanceAdminGrpcAsyncIOTransport,
+ transports.BigtableInstanceAdminRestTransport,
+ ],
+)
+def test_transport_adc(transport_class):
+ # Test default credentials are used if not provided.
+ with mock.patch.object(google.auth, "default") as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport_class()
+ adc.assert_called_once()
+
+
+def test_transport_kind_grpc():
+ transport = BigtableInstanceAdminClient.get_transport_class("grpc")(
+ credentials=ga_credentials.AnonymousCredentials()
+ )
+ assert transport.kind == "grpc"
+
+
+def test_initialize_client_w_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_instance_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_instance), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.create_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_instance_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_instance), "__call__") as call:
+ call.return_value = instance.Instance()
+ client.get_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_instances_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_instances), "__call__") as call:
+ call.return_value = bigtable_instance_admin.ListInstancesResponse()
+ client.list_instances(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListInstancesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_instance_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_instance), "__call__") as call:
+ call.return_value = instance.Instance()
+ client.update_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = instance.Instance()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_partial_update_instance_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.partial_update_instance), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.partial_update_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.PartialUpdateInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_instance_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_instance), "__call__") as call:
+ call.return_value = None
+ client.delete_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_cluster_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_cluster), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.create_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_cluster_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_cluster), "__call__") as call:
+ call.return_value = instance.Cluster()
+ client.get_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_clusters_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_clusters), "__call__") as call:
+ call.return_value = bigtable_instance_admin.ListClustersResponse()
+ client.list_clusters(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListClustersRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_cluster_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_cluster), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.update_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = instance.Cluster()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_partial_update_cluster_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.partial_update_cluster), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.partial_update_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.PartialUpdateClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_cluster_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_cluster), "__call__") as call:
+ call.return_value = None
+ client.delete_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_app_profile_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_app_profile), "__call__"
+ ) as call:
+ call.return_value = instance.AppProfile()
+ client.create_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_app_profile_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_app_profile), "__call__") as call:
+ call.return_value = instance.AppProfile()
+ client.get_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_app_profiles_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_app_profiles), "__call__"
+ ) as call:
+ call.return_value = bigtable_instance_admin.ListAppProfilesResponse()
+ client.list_app_profiles(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListAppProfilesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_app_profile_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_app_profile), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.update_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.UpdateAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_app_profile_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_app_profile), "__call__"
+ ) as call:
+ call.return_value = None
+ client.delete_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_iam_policy_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+ call.return_value = policy_pb2.Policy()
+ client.get_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.GetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_set_iam_policy_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+ call.return_value = policy_pb2.Policy()
+ client.set_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.SetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_test_iam_permissions_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.test_iam_permissions), "__call__"
+ ) as call:
+ call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+ client.test_iam_permissions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.TestIamPermissionsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_hot_tablets_empty_call_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_hot_tablets), "__call__") as call:
+ call.return_value = bigtable_instance_admin.ListHotTabletsResponse()
+ client.list_hot_tablets(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListHotTabletsRequest()
+
+ assert args[0] == request_msg
+
+
+def test_transport_kind_grpc_asyncio():
+ transport = BigtableInstanceAdminAsyncClient.get_transport_class("grpc_asyncio")(
+ credentials=async_anonymous_credentials()
+ )
+ assert transport.kind == "grpc_asyncio"
+
+
+def test_initialize_client_w_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(), transport="grpc_asyncio"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_instance_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_instance), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.create_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_instance_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_instance), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ instance.Instance(
+ name="name_value",
+ display_name="display_name_value",
+ state=instance.Instance.State.READY,
+ type_=instance.Instance.Type.PRODUCTION,
+ satisfies_pzs=True,
+ )
+ )
+ await client.get_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_instances_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_instances), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_instance_admin.ListInstancesResponse(
+ failed_locations=["failed_locations_value"],
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_instances(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListInstancesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_update_instance_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_instance), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ instance.Instance(
+ name="name_value",
+ display_name="display_name_value",
+ state=instance.Instance.State.READY,
+ type_=instance.Instance.Type.PRODUCTION,
+ satisfies_pzs=True,
+ )
+ )
+ await client.update_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = instance.Instance()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_partial_update_instance_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.partial_update_instance), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.partial_update_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.PartialUpdateInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_instance_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_instance), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_cluster_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_cluster), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.create_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_cluster_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_cluster), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ instance.Cluster(
+ name="name_value",
+ location="location_value",
+ state=instance.Cluster.State.READY,
+ serve_nodes=1181,
+ node_scaling_factor=instance.Cluster.NodeScalingFactor.NODE_SCALING_FACTOR_1X,
+ default_storage_type=common.StorageType.SSD,
+ )
+ )
+ await client.get_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_clusters_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_clusters), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_instance_admin.ListClustersResponse(
+ failed_locations=["failed_locations_value"],
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_clusters(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListClustersRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_update_cluster_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_cluster), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.update_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = instance.Cluster()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_partial_update_cluster_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.partial_update_cluster), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.partial_update_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.PartialUpdateClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_cluster_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_cluster), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_app_profile_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_app_profile), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ instance.AppProfile(
+ name="name_value",
+ etag="etag_value",
+ description="description_value",
+ )
+ )
+ await client.create_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_app_profile_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_app_profile), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ instance.AppProfile(
+ name="name_value",
+ etag="etag_value",
+ description="description_value",
+ )
+ )
+ await client.get_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_app_profiles_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_app_profiles), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_instance_admin.ListAppProfilesResponse(
+ next_page_token="next_page_token_value",
+ failed_locations=["failed_locations_value"],
+ )
+ )
+ await client.list_app_profiles(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListAppProfilesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_update_app_profile_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_app_profile), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.update_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.UpdateAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_app_profile_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_app_profile), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_iam_policy_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
+ )
+ await client.get_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.GetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_set_iam_policy_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
+ )
+ await client.set_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.SetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_test_iam_permissions_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.test_iam_permissions), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ iam_policy_pb2.TestIamPermissionsResponse(
+ permissions=["permissions_value"],
+ )
+ )
+ await client.test_iam_permissions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.TestIamPermissionsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_hot_tablets_empty_call_grpc_asyncio():
+ client = BigtableInstanceAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_hot_tablets), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_instance_admin.ListHotTabletsResponse(
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_hot_tablets(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListHotTabletsRequest()
+
+ assert args[0] == request_msg
+
+
+def test_transport_kind_rest():
+ transport = BigtableInstanceAdminClient.get_transport_class("rest")(
+ credentials=ga_credentials.AnonymousCredentials()
+ )
+ assert transport.kind == "rest"
+
+
+def test_create_instance_rest_bad_request(
+ request_type=bigtable_instance_admin.CreateInstanceRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_instance(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.CreateInstanceRequest,
+ dict,
+ ],
+)
+def test_create_instance_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_instance(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_instance_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_create_instance"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_create_instance"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.CreateInstanceRequest.pb(
+ bigtable_instance_admin.CreateInstanceRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.CreateInstanceRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.create_instance(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_instance_rest_bad_request(
+ request_type=bigtable_instance_admin.GetInstanceRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_instance(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.GetInstanceRequest,
+ dict,
+ ],
+)
+def test_get_instance_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = instance.Instance(
+ name="name_value",
+ display_name="display_name_value",
+ state=instance.Instance.State.READY,
+ type_=instance.Instance.Type.PRODUCTION,
+ satisfies_pzs=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = instance.Instance.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_instance(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, instance.Instance)
+ assert response.name == "name_value"
+ assert response.display_name == "display_name_value"
+ assert response.state == instance.Instance.State.READY
+ assert response.type_ == instance.Instance.Type.PRODUCTION
+ assert response.satisfies_pzs is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_instance_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_get_instance"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_get_instance"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.GetInstanceRequest.pb(
+ bigtable_instance_admin.GetInstanceRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = instance.Instance.to_json(instance.Instance())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.GetInstanceRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = instance.Instance()
+
+ client.get_instance(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_instances_rest_bad_request(
+ request_type=bigtable_instance_admin.ListInstancesRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_instances(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.ListInstancesRequest,
+ dict,
+ ],
+)
+def test_list_instances_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_instance_admin.ListInstancesResponse(
+ failed_locations=["failed_locations_value"],
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_instance_admin.ListInstancesResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_instances(request)
+
+ assert response.raw_page is response
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable_instance_admin.ListInstancesResponse)
+ assert response.failed_locations == ["failed_locations_value"]
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_instances_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_list_instances"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_list_instances"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.ListInstancesRequest.pb(
+ bigtable_instance_admin.ListInstancesRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_instance_admin.ListInstancesResponse.to_json(
+ bigtable_instance_admin.ListInstancesResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.ListInstancesRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_instance_admin.ListInstancesResponse()
+
+ client.list_instances(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_update_instance_rest_bad_request(request_type=instance.Instance):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.update_instance(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ instance.Instance,
+ dict,
+ ],
+)
+def test_update_instance_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = instance.Instance(
+ name="name_value",
+ display_name="display_name_value",
+ state=instance.Instance.State.READY,
+ type_=instance.Instance.Type.PRODUCTION,
+ satisfies_pzs=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = instance.Instance.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.update_instance(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, instance.Instance)
+ assert response.name == "name_value"
+ assert response.display_name == "display_name_value"
+ assert response.state == instance.Instance.State.READY
+ assert response.type_ == instance.Instance.Type.PRODUCTION
+ assert response.satisfies_pzs is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_update_instance_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_update_instance"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_update_instance"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = instance.Instance.pb(instance.Instance())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = instance.Instance.to_json(instance.Instance())
+ req.return_value.content = return_value
+
+ request = instance.Instance()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = instance.Instance()
+
+ client.update_instance(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_partial_update_instance_rest_bad_request(
+ request_type=bigtable_instance_admin.PartialUpdateInstanceRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"instance": {"name": "projects/sample1/instances/sample2"}}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.partial_update_instance(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.PartialUpdateInstanceRequest,
+ dict,
+ ],
+)
+def test_partial_update_instance_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"instance": {"name": "projects/sample1/instances/sample2"}}
+ request_init["instance"] = {
+ "name": "projects/sample1/instances/sample2",
+ "display_name": "display_name_value",
+ "state": 1,
+ "type_": 1,
+ "labels": {},
+ "create_time": {"seconds": 751, "nanos": 543},
+ "satisfies_pzs": True,
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_instance_admin.PartialUpdateInstanceRequest.meta.fields[
+ "instance"
+ ]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["instance"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["instance"][field])):
+ del request_init["instance"][field][i][subfield]
+ else:
+ del request_init["instance"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.partial_update_instance(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_partial_update_instance_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_partial_update_instance"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_partial_update_instance"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.PartialUpdateInstanceRequest.pb(
+ bigtable_instance_admin.PartialUpdateInstanceRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.PartialUpdateInstanceRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.partial_update_instance(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_instance_rest_bad_request(
+ request_type=bigtable_instance_admin.DeleteInstanceRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_instance(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.DeleteInstanceRequest,
+ dict,
+ ],
+)
+def test_delete_instance_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_instance(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_instance_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_delete_instance"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_instance_admin.DeleteInstanceRequest.pb(
+ bigtable_instance_admin.DeleteInstanceRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_instance_admin.DeleteInstanceRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_instance(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_create_cluster_rest_bad_request(
+ request_type=bigtable_instance_admin.CreateClusterRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_cluster(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.CreateClusterRequest,
+ dict,
+ ],
+)
+def test_create_cluster_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request_init["cluster"] = {
+ "name": "name_value",
+ "location": "location_value",
+ "state": 1,
+ "serve_nodes": 1181,
+ "node_scaling_factor": 1,
+ "cluster_config": {
+ "cluster_autoscaling_config": {
+ "autoscaling_limits": {
+ "min_serve_nodes": 1600,
+ "max_serve_nodes": 1602,
+ },
+ "autoscaling_targets": {
+ "cpu_utilization_percent": 2483,
+ "storage_utilization_gib_per_node": 3404,
+ },
+ }
+ },
+ "default_storage_type": 1,
+ "encryption_config": {"kms_key_name": "kms_key_name_value"},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_instance_admin.CreateClusterRequest.meta.fields["cluster"]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["cluster"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["cluster"][field])):
+ del request_init["cluster"][field][i][subfield]
+ else:
+ del request_init["cluster"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_cluster(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_cluster_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_create_cluster"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_create_cluster"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.CreateClusterRequest.pb(
+ bigtable_instance_admin.CreateClusterRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.CreateClusterRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.create_cluster(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_cluster_rest_bad_request(
+ request_type=bigtable_instance_admin.GetClusterRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_cluster(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.GetClusterRequest,
+ dict,
+ ],
+)
+def test_get_cluster_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = instance.Cluster(
+ name="name_value",
+ location="location_value",
+ state=instance.Cluster.State.READY,
+ serve_nodes=1181,
+ node_scaling_factor=instance.Cluster.NodeScalingFactor.NODE_SCALING_FACTOR_1X,
+ default_storage_type=common.StorageType.SSD,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = instance.Cluster.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_cluster(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, instance.Cluster)
+ assert response.name == "name_value"
+ assert response.location == "location_value"
+ assert response.state == instance.Cluster.State.READY
+ assert response.serve_nodes == 1181
+ assert (
+ response.node_scaling_factor
+ == instance.Cluster.NodeScalingFactor.NODE_SCALING_FACTOR_1X
+ )
+ assert response.default_storage_type == common.StorageType.SSD
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_cluster_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_get_cluster"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_get_cluster"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.GetClusterRequest.pb(
+ bigtable_instance_admin.GetClusterRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = instance.Cluster.to_json(instance.Cluster())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.GetClusterRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = instance.Cluster()
+
+ client.get_cluster(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_clusters_rest_bad_request(
+ request_type=bigtable_instance_admin.ListClustersRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_clusters(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.ListClustersRequest,
+ dict,
+ ],
+)
+def test_list_clusters_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_instance_admin.ListClustersResponse(
+ failed_locations=["failed_locations_value"],
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_instance_admin.ListClustersResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_clusters(request)
+
+ assert response.raw_page is response
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable_instance_admin.ListClustersResponse)
+ assert response.failed_locations == ["failed_locations_value"]
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_clusters_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_list_clusters"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_list_clusters"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.ListClustersRequest.pb(
+ bigtable_instance_admin.ListClustersRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_instance_admin.ListClustersResponse.to_json(
+ bigtable_instance_admin.ListClustersResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.ListClustersRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_instance_admin.ListClustersResponse()
+
+ client.list_clusters(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_update_cluster_rest_bad_request(request_type=instance.Cluster):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.update_cluster(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ instance.Cluster,
+ dict,
+ ],
+)
+def test_update_cluster_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.update_cluster(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_update_cluster_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_update_cluster"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_update_cluster"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = instance.Cluster.pb(instance.Cluster())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = instance.Cluster()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.update_cluster(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_partial_update_cluster_rest_bad_request(
+ request_type=bigtable_instance_admin.PartialUpdateClusterRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "cluster": {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.partial_update_cluster(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.PartialUpdateClusterRequest,
+ dict,
+ ],
+)
+def test_partial_update_cluster_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "cluster": {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ }
+ request_init["cluster"] = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3",
+ "location": "location_value",
+ "state": 1,
+ "serve_nodes": 1181,
+ "node_scaling_factor": 1,
+ "cluster_config": {
+ "cluster_autoscaling_config": {
+ "autoscaling_limits": {
+ "min_serve_nodes": 1600,
+ "max_serve_nodes": 1602,
+ },
+ "autoscaling_targets": {
+ "cpu_utilization_percent": 2483,
+ "storage_utilization_gib_per_node": 3404,
+ },
+ }
+ },
+ "default_storage_type": 1,
+ "encryption_config": {"kms_key_name": "kms_key_name_value"},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_instance_admin.PartialUpdateClusterRequest.meta.fields[
+ "cluster"
+ ]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["cluster"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["cluster"][field])):
+ del request_init["cluster"][field][i][subfield]
+ else:
+ del request_init["cluster"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.partial_update_cluster(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_partial_update_cluster_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_partial_update_cluster"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_partial_update_cluster"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.PartialUpdateClusterRequest.pb(
+ bigtable_instance_admin.PartialUpdateClusterRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.PartialUpdateClusterRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.partial_update_cluster(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_cluster_rest_bad_request(
+ request_type=bigtable_instance_admin.DeleteClusterRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_cluster(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.DeleteClusterRequest,
+ dict,
+ ],
+)
+def test_delete_cluster_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_cluster(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_cluster_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_delete_cluster"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_instance_admin.DeleteClusterRequest.pb(
+ bigtable_instance_admin.DeleteClusterRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_instance_admin.DeleteClusterRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_cluster(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_create_app_profile_rest_bad_request(
+ request_type=bigtable_instance_admin.CreateAppProfileRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_app_profile(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.CreateAppProfileRequest,
+ dict,
+ ],
+)
+def test_create_app_profile_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request_init["app_profile"] = {
+ "name": "name_value",
+ "etag": "etag_value",
+ "description": "description_value",
+ "multi_cluster_routing_use_any": {
+ "cluster_ids": ["cluster_ids_value1", "cluster_ids_value2"],
+ "row_affinity": {},
+ },
+ "single_cluster_routing": {
+ "cluster_id": "cluster_id_value",
+ "allow_transactional_writes": True,
+ },
+ "priority": 1,
+ "standard_isolation": {"priority": 1},
+ "data_boost_isolation_read_only": {"compute_billing_owner": 1},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_instance_admin.CreateAppProfileRequest.meta.fields[
+ "app_profile"
+ ]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["app_profile"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["app_profile"][field])):
+ del request_init["app_profile"][field][i][subfield]
+ else:
+ del request_init["app_profile"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = instance.AppProfile(
+ name="name_value",
+ etag="etag_value",
+ description="description_value",
+ priority=instance.AppProfile.Priority.PRIORITY_LOW,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = instance.AppProfile.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_app_profile(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, instance.AppProfile)
+ assert response.name == "name_value"
+ assert response.etag == "etag_value"
+ assert response.description == "description_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_app_profile_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_create_app_profile"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_create_app_profile"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.CreateAppProfileRequest.pb(
+ bigtable_instance_admin.CreateAppProfileRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = instance.AppProfile.to_json(instance.AppProfile())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.CreateAppProfileRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = instance.AppProfile()
+
+ client.create_app_profile(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_app_profile_rest_bad_request(
+ request_type=bigtable_instance_admin.GetAppProfileRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_app_profile(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.GetAppProfileRequest,
+ dict,
+ ],
+)
+def test_get_app_profile_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = instance.AppProfile(
+ name="name_value",
+ etag="etag_value",
+ description="description_value",
+ priority=instance.AppProfile.Priority.PRIORITY_LOW,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = instance.AppProfile.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_app_profile(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, instance.AppProfile)
+ assert response.name == "name_value"
+ assert response.etag == "etag_value"
+ assert response.description == "description_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_app_profile_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_get_app_profile"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_get_app_profile"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.GetAppProfileRequest.pb(
+ bigtable_instance_admin.GetAppProfileRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = instance.AppProfile.to_json(instance.AppProfile())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.GetAppProfileRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = instance.AppProfile()
+
+ client.get_app_profile(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_app_profiles_rest_bad_request(
+ request_type=bigtable_instance_admin.ListAppProfilesRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_app_profiles(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.ListAppProfilesRequest,
+ dict,
+ ],
+)
+def test_list_app_profiles_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_instance_admin.ListAppProfilesResponse(
+ next_page_token="next_page_token_value",
+ failed_locations=["failed_locations_value"],
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_instance_admin.ListAppProfilesResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_app_profiles(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListAppProfilesPager)
+ assert response.next_page_token == "next_page_token_value"
+ assert response.failed_locations == ["failed_locations_value"]
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_app_profiles_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_list_app_profiles"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_list_app_profiles"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.ListAppProfilesRequest.pb(
+ bigtable_instance_admin.ListAppProfilesRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_instance_admin.ListAppProfilesResponse.to_json(
+ bigtable_instance_admin.ListAppProfilesResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.ListAppProfilesRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_instance_admin.ListAppProfilesResponse()
+
+ client.list_app_profiles(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_update_app_profile_rest_bad_request(
+ request_type=bigtable_instance_admin.UpdateAppProfileRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "app_profile": {
+ "name": "projects/sample1/instances/sample2/appProfiles/sample3"
+ }
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.update_app_profile(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.UpdateAppProfileRequest,
+ dict,
+ ],
+)
+def test_update_app_profile_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "app_profile": {
+ "name": "projects/sample1/instances/sample2/appProfiles/sample3"
+ }
+ }
+ request_init["app_profile"] = {
+ "name": "projects/sample1/instances/sample2/appProfiles/sample3",
+ "etag": "etag_value",
+ "description": "description_value",
+ "multi_cluster_routing_use_any": {
+ "cluster_ids": ["cluster_ids_value1", "cluster_ids_value2"],
+ "row_affinity": {},
+ },
+ "single_cluster_routing": {
+ "cluster_id": "cluster_id_value",
+ "allow_transactional_writes": True,
+ },
+ "priority": 1,
+ "standard_isolation": {"priority": 1},
+ "data_boost_isolation_read_only": {"compute_billing_owner": 1},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_instance_admin.UpdateAppProfileRequest.meta.fields[
+ "app_profile"
+ ]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["app_profile"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["app_profile"][field])):
+ del request_init["app_profile"][field][i][subfield]
+ else:
+ del request_init["app_profile"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.update_app_profile(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_update_app_profile_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_update_app_profile"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_update_app_profile"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.UpdateAppProfileRequest.pb(
+ bigtable_instance_admin.UpdateAppProfileRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.UpdateAppProfileRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.update_app_profile(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_app_profile_rest_bad_request(
+ request_type=bigtable_instance_admin.DeleteAppProfileRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_app_profile(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.DeleteAppProfileRequest,
+ dict,
+ ],
+)
+def test_delete_app_profile_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/appProfiles/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_app_profile(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_app_profile_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_delete_app_profile"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_instance_admin.DeleteAppProfileRequest.pb(
+ bigtable_instance_admin.DeleteAppProfileRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_instance_admin.DeleteAppProfileRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_app_profile(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_get_iam_policy_rest_bad_request(
+ request_type=iam_policy_pb2.GetIamPolicyRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ iam_policy_pb2.GetIamPolicyRequest,
+ dict,
+ ],
+)
+def test_get_iam_policy_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_iam_policy(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, policy_pb2.Policy)
+ assert response.version == 774
+ assert response.etag == b"etag_blob"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_iam_policy_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_get_iam_policy"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_get_iam_policy"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = iam_policy_pb2.GetIamPolicyRequest()
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(policy_pb2.Policy())
+ req.return_value.content = return_value
+
+ request = iam_policy_pb2.GetIamPolicyRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = policy_pb2.Policy()
+
+ client.get_iam_policy(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_set_iam_policy_rest_bad_request(
+ request_type=iam_policy_pb2.SetIamPolicyRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.set_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ iam_policy_pb2.SetIamPolicyRequest,
+ dict,
+ ],
+)
+def test_set_iam_policy_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.set_iam_policy(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, policy_pb2.Policy)
+ assert response.version == 774
+ assert response.etag == b"etag_blob"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_set_iam_policy_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_set_iam_policy"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_set_iam_policy"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = iam_policy_pb2.SetIamPolicyRequest()
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(policy_pb2.Policy())
+ req.return_value.content = return_value
+
+ request = iam_policy_pb2.SetIamPolicyRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = policy_pb2.Policy()
+
+ client.set_iam_policy(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_test_iam_permissions_rest_bad_request(
+ request_type=iam_policy_pb2.TestIamPermissionsRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.test_iam_permissions(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ iam_policy_pb2.TestIamPermissionsRequest,
+ dict,
+ ],
+)
+def test_test_iam_permissions_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = iam_policy_pb2.TestIamPermissionsResponse(
+ permissions=["permissions_value"],
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.test_iam_permissions(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+ assert response.permissions == ["permissions_value"]
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_test_iam_permissions_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_test_iam_permissions"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_test_iam_permissions"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = iam_policy_pb2.TestIamPermissionsRequest()
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(
+ iam_policy_pb2.TestIamPermissionsResponse()
+ )
+ req.return_value.content = return_value
+
+ request = iam_policy_pb2.TestIamPermissionsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+ client.test_iam_permissions(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_hot_tablets_rest_bad_request(
+ request_type=bigtable_instance_admin.ListHotTabletsRequest,
+):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_hot_tablets(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_instance_admin.ListHotTabletsRequest,
+ dict,
+ ],
+)
+def test_list_hot_tablets_rest_call_success(request_type):
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_instance_admin.ListHotTabletsResponse(
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_instance_admin.ListHotTabletsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_hot_tablets(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListHotTabletsPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_hot_tablets_rest_interceptors(null_interceptor):
+ transport = transports.BigtableInstanceAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableInstanceAdminRestInterceptor(),
+ )
+ client = BigtableInstanceAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "post_list_hot_tablets"
+ ) as post, mock.patch.object(
+ transports.BigtableInstanceAdminRestInterceptor, "pre_list_hot_tablets"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_instance_admin.ListHotTabletsRequest.pb(
+ bigtable_instance_admin.ListHotTabletsRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_instance_admin.ListHotTabletsResponse.to_json(
+ bigtable_instance_admin.ListHotTabletsResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_instance_admin.ListHotTabletsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_instance_admin.ListHotTabletsResponse()
+
+ client.list_hot_tablets(
+ request,
metadata=[
("key", "val"),
("cephalopod", "squid"),
@@ -16280,258 +16456,462 @@ def test_list_hot_tablets_rest_interceptors(null_interceptor):
post.assert_called_once()
-def test_list_hot_tablets_rest_bad_request(
- transport: str = "rest", request_type=bigtable_instance_admin.ListHotTabletsRequest
-):
+def test_initialize_client_w_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_instance_empty_call_rest():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_instance), "__call__") as call:
+ client.create_instance(request=None)
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_hot_tablets(request)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateInstanceRequest()
+ assert args[0] == request_msg
-def test_list_hot_tablets_rest_flattened():
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_instance_empty_call_rest():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_instance_admin.ListHotTabletsResponse()
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_instance), "__call__") as call:
+ client.get_instance(request=None)
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
- }
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetInstanceRequest()
- # get truthy value for each flattened field
- mock_args = dict(
- parent="parent_value",
- )
- mock_args.update(sample_request)
+ assert args[0] == request_msg
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_instance_admin.ListHotTabletsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- client.list_hot_tablets(**mock_args)
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_instances_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- # Establish that the underlying call was made with the expected
- # request object values.
- assert len(req.mock_calls) == 1
- _, args, _ = req.mock_calls[0]
- assert path_template.validate(
- "%s/v2/{parent=projects/*/instances/*/clusters/*}/hotTablets"
- % client.transport._host,
- args[1],
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_instances), "__call__") as call:
+ client.list_instances(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListInstancesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_instance_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_instance), "__call__") as call:
+ client.update_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = instance.Instance()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_partial_update_instance_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.partial_update_instance), "__call__"
+ ) as call:
+ client.partial_update_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.PartialUpdateInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_instance_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_instance), "__call__") as call:
+ client.delete_instance(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteInstanceRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_cluster_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_cluster), "__call__") as call:
+ client.create_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_cluster_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_cluster), "__call__") as call:
+ client.get_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_clusters_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_clusters), "__call__") as call:
+ client.list_clusters(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListClustersRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_cluster_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_cluster), "__call__") as call:
+ client.update_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = instance.Cluster()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_partial_update_cluster_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.partial_update_cluster), "__call__"
+ ) as call:
+ client.partial_update_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.PartialUpdateClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_cluster_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_cluster), "__call__") as call:
+ client.delete_cluster(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteClusterRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_app_profile_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_app_profile), "__call__"
+ ) as call:
+ client.create_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.CreateAppProfileRequest()
+
+ assert args[0] == request_msg
-def test_list_hot_tablets_rest_flattened_error(transport: str = "rest"):
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_app_profile_empty_call_rest():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # Attempting to call a method with both a request object and flattened
- # fields is an error.
- with pytest.raises(ValueError):
- client.list_hot_tablets(
- bigtable_instance_admin.ListHotTabletsRequest(),
- parent="parent_value",
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_app_profile), "__call__") as call:
+ client.get_app_profile(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.GetAppProfileRequest()
+ assert args[0] == request_msg
-def test_list_hot_tablets_rest_pager(transport: str = "rest"):
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_app_profiles_empty_call_rest():
client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # TODO(kbandes): remove this mock unless there's a good reason for it.
- # with mock.patch.object(path_template, 'transcode') as transcode:
- # Set the response as a series of pages
- response = (
- bigtable_instance_admin.ListHotTabletsResponse(
- hot_tablets=[
- instance.HotTablet(),
- instance.HotTablet(),
- instance.HotTablet(),
- ],
- next_page_token="abc",
- ),
- bigtable_instance_admin.ListHotTabletsResponse(
- hot_tablets=[],
- next_page_token="def",
- ),
- bigtable_instance_admin.ListHotTabletsResponse(
- hot_tablets=[
- instance.HotTablet(),
- ],
- next_page_token="ghi",
- ),
- bigtable_instance_admin.ListHotTabletsResponse(
- hot_tablets=[
- instance.HotTablet(),
- instance.HotTablet(),
- ],
- ),
- )
- # Two responses for two calls
- response = response + response
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_app_profiles), "__call__"
+ ) as call:
+ client.list_app_profiles(request=None)
- # Wrap the values into proper Response objs
- response = tuple(
- bigtable_instance_admin.ListHotTabletsResponse.to_json(x) for x in response
- )
- return_values = tuple(Response() for i in response)
- for return_val, response_val in zip(return_values, response):
- return_val._content = response_val.encode("UTF-8")
- return_val.status_code = 200
- req.side_effect = return_values
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListAppProfilesRequest()
- sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
- }
+ assert args[0] == request_msg
- pager = client.list_hot_tablets(request=sample_request)
- results = list(pager)
- assert len(results) == 6
- assert all(isinstance(i, instance.HotTablet) for i in results)
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_app_profile_empty_call_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- pages = list(client.list_hot_tablets(request=sample_request).pages)
- for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
- assert page_.raw_page.next_page_token == token
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_app_profile), "__call__"
+ ) as call:
+ client.update_app_profile(request=None)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.UpdateAppProfileRequest()
-def test_credentials_transport_error():
- # It is an error to provide credentials and a transport instance.
- transport = transports.BigtableInstanceAdminGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- with pytest.raises(ValueError):
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
+ assert args[0] == request_msg
- # It is an error to provide a credentials file and a transport instance.
- transport = transports.BigtableInstanceAdminGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- with pytest.raises(ValueError):
- client = BigtableInstanceAdminClient(
- client_options={"credentials_file": "credentials.json"},
- transport=transport,
- )
- # It is an error to provide an api_key and a transport instance.
- transport = transports.BigtableInstanceAdminGrpcTransport(
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_app_profile_empty_call_rest():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- options = client_options.ClientOptions()
- options.api_key = "api_key"
- with pytest.raises(ValueError):
- client = BigtableInstanceAdminClient(
- client_options=options,
- transport=transport,
- )
- # It is an error to provide an api_key and a credential.
- options = client_options.ClientOptions()
- options.api_key = "api_key"
- with pytest.raises(ValueError):
- client = BigtableInstanceAdminClient(
- client_options=options, credentials=ga_credentials.AnonymousCredentials()
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_app_profile), "__call__"
+ ) as call:
+ client.delete_app_profile(request=None)
- # It is an error to provide scopes and a transport instance.
- transport = transports.BigtableInstanceAdminGrpcTransport(
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.DeleteAppProfileRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_iam_policy_empty_call_rest():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- with pytest.raises(ValueError):
- client = BigtableInstanceAdminClient(
- client_options={"scopes": ["1", "2"]},
- transport=transport,
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+ client.get_iam_policy(request=None)
-def test_transport_instance():
- # A client may be instantiated with a custom transport instance.
- transport = transports.BigtableInstanceAdminGrpcTransport(
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.GetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_set_iam_policy_empty_call_rest():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- client = BigtableInstanceAdminClient(transport=transport)
- assert client.transport is transport
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+ client.set_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.SetIamPolicyRequest()
-def test_transport_get_channel():
- # A client may be instantiated with a custom transport instance.
- transport = transports.BigtableInstanceAdminGrpcTransport(
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_test_iam_permissions_empty_call_rest():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- channel = transport.grpc_channel
- assert channel
- transport = transports.BigtableInstanceAdminGrpcAsyncIOTransport(
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.test_iam_permissions), "__call__"
+ ) as call:
+ client.test_iam_permissions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.TestIamPermissionsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_hot_tablets_empty_call_rest():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- channel = transport.grpc_channel
- assert channel
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_hot_tablets), "__call__") as call:
+ client.list_hot_tablets(request=None)
-@pytest.mark.parametrize(
- "transport_class",
- [
- transports.BigtableInstanceAdminGrpcTransport,
- transports.BigtableInstanceAdminGrpcAsyncIOTransport,
- transports.BigtableInstanceAdminRestTransport,
- ],
-)
-def test_transport_adc(transport_class):
- # Test default credentials are used if not provided.
- with mock.patch.object(google.auth, "default") as adc:
- adc.return_value = (ga_credentials.AnonymousCredentials(), None)
- transport_class()
- adc.assert_called_once()
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_instance_admin.ListHotTabletsRequest()
+ assert args[0] == request_msg
-@pytest.mark.parametrize(
- "transport_name",
- [
- "grpc",
- "rest",
- ],
-)
-def test_transport_kind(transport_name):
- transport = BigtableInstanceAdminClient.get_transport_class(transport_name)(
+
+def test_bigtable_instance_admin_rest_lro_client():
+ client = BigtableInstanceAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ transport = client.transport
+
+ # Ensure that we have an api-core operations client.
+ assert isinstance(
+ transport.operations_client,
+ operations_v1.AbstractOperationsClient,
)
- assert transport.kind == transport_name
+
+ # Ensure that subsequent calls to the property send the exact same object.
+ assert transport.operations_client is transport.operations_client
def test_transport_grpc_default():
@@ -16824,23 +17204,6 @@ def test_bigtable_instance_admin_http_transport_client_cert_source_for_mtls():
mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback)
-def test_bigtable_instance_admin_rest_lro_client():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
- transport = client.transport
-
- # Ensure that we have a api-core operations client.
- assert isinstance(
- transport.operations_client,
- operations_v1.AbstractOperationsClient,
- )
-
- # Ensure that subsequent calls to the property send the exact same object.
- assert transport.operations_client is transport.operations_client
-
-
@pytest.mark.parametrize(
"transport_name",
[
@@ -17422,36 +17785,41 @@ def test_client_with_default_client_info():
prep.assert_called_once_with(client_info)
+def test_transport_close_grpc():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc"
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "_grpc_channel")), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
+
+
@pytest.mark.asyncio
-async def test_transport_close_async():
+async def test_transport_close_grpc_asyncio():
client = BigtableInstanceAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
+ credentials=async_anonymous_credentials(), transport="grpc_asyncio"
)
with mock.patch.object(
- type(getattr(client.transport, "grpc_channel")), "close"
+ type(getattr(client.transport, "_grpc_channel")), "close"
) as close:
async with client:
close.assert_not_called()
close.assert_called_once()
-def test_transport_close():
- transports = {
- "rest": "_session",
- "grpc": "_grpc_channel",
- }
-
- for transport, close_name in transports.items():
- client = BigtableInstanceAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport=transport
- )
- with mock.patch.object(
- type(getattr(client.transport, close_name)), "close"
- ) as close:
- with client:
- close.assert_not_called()
- close.assert_called_once()
+def test_transport_close_rest():
+ client = BigtableInstanceAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "_session")), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
def test_client_ctx():
diff --git a/tests/unit/gapic/bigtable_admin_v2/test_bigtable_table_admin.py b/tests/unit/gapic/bigtable_admin_v2/test_bigtable_table_admin.py
index c9455cd5f..53788921f 100644
--- a/tests/unit/gapic/bigtable_admin_v2/test_bigtable_table_admin.py
+++ b/tests/unit/gapic/bigtable_admin_v2/test_bigtable_table_admin.py
@@ -24,7 +24,7 @@
import grpc
from grpc.experimental import aio
-from collections.abc import Iterable
+from collections.abc import Iterable, AsyncIterable
from google.protobuf import json_format
import json
import math
@@ -37,6 +37,13 @@
from requests.sessions import Session
from google.protobuf import json_format
+try:
+ from google.auth.aio import credentials as ga_credentials_async
+
+ HAS_GOOGLE_AUTH_AIO = True
+except ImportError: # pragma: NO COVER
+ HAS_GOOGLE_AUTH_AIO = False
+
from google.api_core import client_options
from google.api_core import exceptions as core_exceptions
from google.api_core import future
@@ -76,10 +83,24 @@
import google.auth
+async def mock_async_gen(data, chunk_size=1):
+ for i in range(0, len(data)): # pragma: NO COVER
+ chunk = data[i : i + chunk_size]
+ yield chunk.encode("utf-8")
+
+
def client_cert_source_callback():
return b"cert bytes", b"key bytes"
+# TODO: use async auth anon credentials by default once the minimum version of google-auth is upgraded.
+# See related issue: https://github.com/googleapis/gapic-generator-python/issues/2107.
+def async_anonymous_credentials():
+ if HAS_GOOGLE_AUTH_AIO:
+ return ga_credentials_async.AnonymousCredentials()
+ return ga_credentials.AnonymousCredentials()
+
+
# If default endpoint is localhost, then default mtls endpoint will be the same.
# This method modifies the default endpoint so the client can produce a different
# mtls endpoint for endpoint testing purposes.
@@ -332,86 +353,6 @@ def test__get_universe_domain():
assert str(excinfo.value) == "Universe Domain cannot be an empty string."
-@pytest.mark.parametrize(
- "client_class,transport_class,transport_name",
- [
- (BigtableTableAdminClient, transports.BigtableTableAdminGrpcTransport, "grpc"),
- (BigtableTableAdminClient, transports.BigtableTableAdminRestTransport, "rest"),
- ],
-)
-def test__validate_universe_domain(client_class, transport_class, transport_name):
- client = client_class(
- transport=transport_class(credentials=ga_credentials.AnonymousCredentials())
- )
- assert client._validate_universe_domain() == True
-
- # Test the case when universe is already validated.
- assert client._validate_universe_domain() == True
-
- if transport_name == "grpc":
- # Test the case where credentials are provided by the
- # `local_channel_credentials`. The default universes in both match.
- channel = grpc.secure_channel(
- "http://localhost/", grpc.local_channel_credentials()
- )
- client = client_class(transport=transport_class(channel=channel))
- assert client._validate_universe_domain() == True
-
- # Test the case where credentials do not exist: e.g. a transport is provided
- # with no credentials. Validation should still succeed because there is no
- # mismatch with non-existent credentials.
- channel = grpc.secure_channel(
- "http://localhost/", grpc.local_channel_credentials()
- )
- transport = transport_class(channel=channel)
- transport._credentials = None
- client = client_class(transport=transport)
- assert client._validate_universe_domain() == True
-
- # TODO: This is needed to cater for older versions of google-auth
- # Make this test unconditional once the minimum supported version of
- # google-auth becomes 2.23.0 or higher.
- google_auth_major, google_auth_minor = [
- int(part) for part in google.auth.__version__.split(".")[0:2]
- ]
- if google_auth_major > 2 or (google_auth_major == 2 and google_auth_minor >= 23):
- credentials = ga_credentials.AnonymousCredentials()
- credentials._universe_domain = "foo.com"
- # Test the case when there is a universe mismatch from the credentials.
- client = client_class(transport=transport_class(credentials=credentials))
- with pytest.raises(ValueError) as excinfo:
- client._validate_universe_domain()
- assert (
- str(excinfo.value)
- == "The configured universe domain (googleapis.com) does not match the universe domain found in the credentials (foo.com). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
- )
-
- # Test the case when there is a universe mismatch from the client.
- #
- # TODO: Make this test unconditional once the minimum supported version of
- # google-api-core becomes 2.15.0 or higher.
- api_core_major, api_core_minor = [
- int(part) for part in api_core_version.__version__.split(".")[0:2]
- ]
- if api_core_major > 2 or (api_core_major == 2 and api_core_minor >= 15):
- client = client_class(
- client_options={"universe_domain": "bar.com"},
- transport=transport_class(
- credentials=ga_credentials.AnonymousCredentials(),
- ),
- )
- with pytest.raises(ValueError) as excinfo:
- client._validate_universe_domain()
- assert (
- str(excinfo.value)
- == "The configured universe domain (bar.com) does not match the universe domain found in the credentials (googleapis.com). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
- )
-
- # Test that ValueError is raised if universe_domain is provided via client options and credentials is None
- with pytest.raises(ValueError):
- client._compare_universes("foo.bar", None)
-
-
@pytest.mark.parametrize(
"client_class,transport_name",
[
@@ -1230,25 +1171,6 @@ def test_create_table(request_type, transport: str = "grpc"):
assert response.deletion_protection is True
-def test_create_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateTableRequest()
-
-
def test_create_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1314,31 +1236,6 @@ def test_create_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- gba_table.Table(
- name="name_value",
- granularity=gba_table.Table.TimestampGranularity.MILLIS,
- deletion_protection=True,
- )
- )
- response = await client.create_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateTableRequest()
-
-
@pytest.mark.asyncio
async def test_create_table_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -1347,7 +1244,7 @@ async def test_create_table_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1387,7 +1284,7 @@ async def test_create_table_async(
request_type=bigtable_table_admin.CreateTableRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1457,7 +1354,7 @@ def test_create_table_field_headers():
@pytest.mark.asyncio
async def test_create_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -1535,7 +1432,7 @@ def test_create_table_flattened_error():
@pytest.mark.asyncio
async def test_create_table_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -1570,7 +1467,7 @@ async def test_create_table_flattened_async():
@pytest.mark.asyncio
async def test_create_table_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -1619,27 +1516,6 @@ def test_create_table_from_snapshot(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_create_table_from_snapshot_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.create_table_from_snapshot), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_table_from_snapshot()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateTableFromSnapshotRequest()
-
-
def test_create_table_from_snapshot_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1719,29 +1595,6 @@ def test_create_table_from_snapshot_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_table_from_snapshot_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.create_table_from_snapshot), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.create_table_from_snapshot()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateTableFromSnapshotRequest()
-
-
@pytest.mark.asyncio
async def test_create_table_from_snapshot_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -1750,7 +1603,7 @@ async def test_create_table_from_snapshot_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1795,7 +1648,7 @@ async def test_create_table_from_snapshot_async(
request_type=bigtable_table_admin.CreateTableFromSnapshotRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1862,7 +1715,7 @@ def test_create_table_from_snapshot_field_headers():
@pytest.mark.asyncio
async def test_create_table_from_snapshot_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -1946,7 +1799,7 @@ def test_create_table_from_snapshot_flattened_error():
@pytest.mark.asyncio
async def test_create_table_from_snapshot_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -1985,7 +1838,7 @@ async def test_create_table_from_snapshot_flattened_async():
@pytest.mark.asyncio
async def test_create_table_from_snapshot_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2035,25 +1888,6 @@ def test_list_tables(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_tables_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_tables), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_tables()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListTablesRequest()
-
-
def test_list_tables_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2119,29 +1953,6 @@ def test_list_tables_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_tables_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_tables), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_table_admin.ListTablesResponse(
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_tables()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListTablesRequest()
-
-
@pytest.mark.asyncio
async def test_list_tables_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -2150,7 +1961,7 @@ async def test_list_tables_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2189,7 +2000,7 @@ async def test_list_tables_async(
transport: str = "grpc_asyncio", request_type=bigtable_table_admin.ListTablesRequest
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2255,7 +2066,7 @@ def test_list_tables_field_headers():
@pytest.mark.asyncio
async def test_list_tables_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -2325,7 +2136,7 @@ def test_list_tables_flattened_error():
@pytest.mark.asyncio
async def test_list_tables_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2354,7 +2165,7 @@ async def test_list_tables_flattened_async():
@pytest.mark.asyncio
async def test_list_tables_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2464,7 +2275,7 @@ def test_list_tables_pages(transport_name: str = "grpc"):
@pytest.mark.asyncio
async def test_list_tables_async_pager():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2514,7 +2325,7 @@ async def test_list_tables_async_pager():
@pytest.mark.asyncio
async def test_list_tables_async_pages():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2600,25 +2411,6 @@ def test_get_table(request_type, transport: str = "grpc"):
assert response.deletion_protection is True
-def test_get_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetTableRequest()
-
-
def test_get_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2682,38 +2474,13 @@ def test_get_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- table.Table(
- name="name_value",
- granularity=table.Table.TimestampGranularity.MILLIS,
- deletion_protection=True,
- )
- )
- response = await client.get_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetTableRequest()
-
-
@pytest.mark.asyncio
async def test_get_table_async_use_cached_wrapped_rpc(transport: str = "grpc_asyncio"):
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2752,7 +2519,7 @@ async def test_get_table_async(
transport: str = "grpc_asyncio", request_type=bigtable_table_admin.GetTableRequest
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2822,7 +2589,7 @@ def test_get_table_field_headers():
@pytest.mark.asyncio
async def test_get_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -2890,7 +2657,7 @@ def test_get_table_flattened_error():
@pytest.mark.asyncio
async def test_get_table_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2917,7 +2684,7 @@ async def test_get_table_flattened_async():
@pytest.mark.asyncio
async def test_get_table_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2962,25 +2729,6 @@ def test_update_table(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_update_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.update_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UpdateTableRequest()
-
-
def test_update_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3045,27 +2793,6 @@ def test_update_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_update_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.update_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UpdateTableRequest()
-
-
@pytest.mark.asyncio
async def test_update_table_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3074,7 +2801,7 @@ async def test_update_table_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3119,7 +2846,7 @@ async def test_update_table_async(
request_type=bigtable_table_admin.UpdateTableRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3182,7 +2909,7 @@ def test_update_table_field_headers():
@pytest.mark.asyncio
async def test_update_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -3257,7 +2984,7 @@ def test_update_table_flattened_error():
@pytest.mark.asyncio
async def test_update_table_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3290,7 +3017,7 @@ async def test_update_table_flattened_async():
@pytest.mark.asyncio
async def test_update_table_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3336,25 +3063,6 @@ def test_delete_table(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteTableRequest()
-
-
def test_delete_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3418,25 +3126,6 @@ def test_delete_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteTableRequest()
-
-
@pytest.mark.asyncio
async def test_delete_table_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3445,7 +3134,7 @@ async def test_delete_table_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3485,7 +3174,7 @@ async def test_delete_table_async(
request_type=bigtable_table_admin.DeleteTableRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3546,7 +3235,7 @@ def test_delete_table_field_headers():
@pytest.mark.asyncio
async def test_delete_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -3614,7 +3303,7 @@ def test_delete_table_flattened_error():
@pytest.mark.asyncio
async def test_delete_table_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3641,7 +3330,7 @@ async def test_delete_table_flattened_async():
@pytest.mark.asyncio
async def test_delete_table_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3686,25 +3375,6 @@ def test_undelete_table(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_undelete_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.undelete_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.undelete_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UndeleteTableRequest()
-
-
def test_undelete_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3773,27 +3443,6 @@ def test_undelete_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_undelete_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.undelete_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.undelete_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UndeleteTableRequest()
-
-
@pytest.mark.asyncio
async def test_undelete_table_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3802,7 +3451,7 @@ async def test_undelete_table_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3847,7 +3496,7 @@ async def test_undelete_table_async(
request_type=bigtable_table_admin.UndeleteTableRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3910,7 +3559,7 @@ def test_undelete_table_field_headers():
@pytest.mark.asyncio
async def test_undelete_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -3980,7 +3629,7 @@ def test_undelete_table_flattened_error():
@pytest.mark.asyncio
async def test_undelete_table_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4009,7 +3658,7 @@ async def test_undelete_table_flattened_async():
@pytest.mark.asyncio
async def test_undelete_table_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4056,27 +3705,6 @@ def test_create_authorized_view(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_create_authorized_view_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.create_authorized_view), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateAuthorizedViewRequest()
-
-
def test_create_authorized_view_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4154,29 +3782,6 @@ def test_create_authorized_view_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_authorized_view_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.create_authorized_view), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.create_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateAuthorizedViewRequest()
-
-
@pytest.mark.asyncio
async def test_create_authorized_view_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4185,7 +3790,7 @@ async def test_create_authorized_view_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4230,7 +3835,7 @@ async def test_create_authorized_view_async(
request_type=bigtable_table_admin.CreateAuthorizedViewRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4297,7 +3902,7 @@ def test_create_authorized_view_field_headers():
@pytest.mark.asyncio
async def test_create_authorized_view_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4381,7 +3986,7 @@ def test_create_authorized_view_flattened_error():
@pytest.mark.asyncio
async def test_create_authorized_view_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4420,7 +4025,7 @@ async def test_create_authorized_view_flattened_async():
@pytest.mark.asyncio
async def test_create_authorized_view_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4472,27 +4077,6 @@ def test_list_authorized_views(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_authorized_views_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.list_authorized_views), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_authorized_views()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListAuthorizedViewsRequest()
-
-
def test_list_authorized_views_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4565,31 +4149,6 @@ def test_list_authorized_views_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_authorized_views_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.list_authorized_views), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_table_admin.ListAuthorizedViewsResponse(
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_authorized_views()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListAuthorizedViewsRequest()
-
-
@pytest.mark.asyncio
async def test_list_authorized_views_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4598,7 +4157,7 @@ async def test_list_authorized_views_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4638,7 +4197,7 @@ async def test_list_authorized_views_async(
request_type=bigtable_table_admin.ListAuthorizedViewsRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4708,7 +4267,7 @@ def test_list_authorized_views_field_headers():
@pytest.mark.asyncio
async def test_list_authorized_views_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4782,7 +4341,7 @@ def test_list_authorized_views_flattened_error():
@pytest.mark.asyncio
async def test_list_authorized_views_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4813,7 +4372,7 @@ async def test_list_authorized_views_flattened_async():
@pytest.mark.asyncio
async def test_list_authorized_views_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4927,7 +4486,7 @@ def test_list_authorized_views_pages(transport_name: str = "grpc"):
@pytest.mark.asyncio
async def test_list_authorized_views_async_pager():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4979,7 +4538,7 @@ async def test_list_authorized_views_async_pager():
@pytest.mark.asyncio
async def test_list_authorized_views_async_pages():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -5069,27 +4628,6 @@ def test_get_authorized_view(request_type, transport: str = "grpc"):
assert response.deletion_protection is True
-def test_get_authorized_view_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.get_authorized_view), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetAuthorizedViewRequest()
-
-
def test_get_authorized_view_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -5159,33 +4697,6 @@ def test_get_authorized_view_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_authorized_view_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.get_authorized_view), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- table.AuthorizedView(
- name="name_value",
- etag="etag_value",
- deletion_protection=True,
- )
- )
- response = await client.get_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetAuthorizedViewRequest()
-
-
@pytest.mark.asyncio
async def test_get_authorized_view_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -5194,7 +4705,7 @@ async def test_get_authorized_view_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5234,7 +4745,7 @@ async def test_get_authorized_view_async(
request_type=bigtable_table_admin.GetAuthorizedViewRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5308,7 +4819,7 @@ def test_get_authorized_view_field_headers():
@pytest.mark.asyncio
async def test_get_authorized_view_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -5382,7 +4893,7 @@ def test_get_authorized_view_flattened_error():
@pytest.mark.asyncio
async def test_get_authorized_view_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -5413,7 +4924,7 @@ async def test_get_authorized_view_flattened_async():
@pytest.mark.asyncio
async def test_get_authorized_view_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -5460,27 +4971,6 @@ def test_update_authorized_view(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_update_authorized_view_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.update_authorized_view), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.update_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UpdateAuthorizedViewRequest()
-
-
def test_update_authorized_view_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -5552,29 +5042,6 @@ def test_update_authorized_view_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_update_authorized_view_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.update_authorized_view), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.update_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UpdateAuthorizedViewRequest()
-
-
@pytest.mark.asyncio
async def test_update_authorized_view_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -5583,7 +5050,7 @@ async def test_update_authorized_view_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5628,7 +5095,7 @@ async def test_update_authorized_view_async(
request_type=bigtable_table_admin.UpdateAuthorizedViewRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -5695,7 +5162,7 @@ def test_update_authorized_view_field_headers():
@pytest.mark.asyncio
async def test_update_authorized_view_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -5774,7 +5241,7 @@ def test_update_authorized_view_flattened_error():
@pytest.mark.asyncio
async def test_update_authorized_view_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -5809,7 +5276,7 @@ async def test_update_authorized_view_flattened_async():
@pytest.mark.asyncio
async def test_update_authorized_view_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -5857,27 +5324,6 @@ def test_delete_authorized_view(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_authorized_view_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.delete_authorized_view), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteAuthorizedViewRequest()
-
-
def test_delete_authorized_view_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -5950,27 +5396,6 @@ def test_delete_authorized_view_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_authorized_view_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.delete_authorized_view), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_authorized_view()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteAuthorizedViewRequest()
-
-
@pytest.mark.asyncio
async def test_delete_authorized_view_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -5979,7 +5404,7 @@ async def test_delete_authorized_view_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6019,7 +5444,7 @@ async def test_delete_authorized_view_async(
request_type=bigtable_table_admin.DeleteAuthorizedViewRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6084,7 +5509,7 @@ def test_delete_authorized_view_field_headers():
@pytest.mark.asyncio
async def test_delete_authorized_view_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -6156,7 +5581,7 @@ def test_delete_authorized_view_flattened_error():
@pytest.mark.asyncio
async def test_delete_authorized_view_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -6185,7 +5610,7 @@ async def test_delete_authorized_view_flattened_async():
@pytest.mark.asyncio
async def test_delete_authorized_view_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -6239,30 +5664,9 @@ def test_modify_column_families(request_type, transport: str = "grpc"):
assert response.deletion_protection is True
-def test_modify_column_families_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.modify_column_families), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.modify_column_families()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ModifyColumnFamiliesRequest()
-
-
-def test_modify_column_families_non_empty_request_with_auto_populated_field():
- # This test is a coverage failsafe to make sure that UUID4 fields are
- # automatically populated, according to AIP-4235, with non-empty requests.
+def test_modify_column_families_non_empty_request_with_auto_populated_field():
+ # This test is a coverage failsafe to make sure that UUID4 fields are
+ # automatically populated, according to AIP-4235, with non-empty requests.
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="grpc",
@@ -6330,33 +5734,6 @@ def test_modify_column_families_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_modify_column_families_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.modify_column_families), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- table.Table(
- name="name_value",
- granularity=table.Table.TimestampGranularity.MILLIS,
- deletion_protection=True,
- )
- )
- response = await client.modify_column_families()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ModifyColumnFamiliesRequest()
-
-
@pytest.mark.asyncio
async def test_modify_column_families_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -6365,7 +5742,7 @@ async def test_modify_column_families_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6405,7 +5782,7 @@ async def test_modify_column_families_async(
request_type=bigtable_table_admin.ModifyColumnFamiliesRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6479,7 +5856,7 @@ def test_modify_column_families_field_headers():
@pytest.mark.asyncio
async def test_modify_column_families_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -6566,7 +5943,7 @@ def test_modify_column_families_flattened_error():
@pytest.mark.asyncio
async def test_modify_column_families_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -6605,7 +5982,7 @@ async def test_modify_column_families_flattened_async():
@pytest.mark.asyncio
async def test_modify_column_families_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -6655,25 +6032,6 @@ def test_drop_row_range(request_type, transport: str = "grpc"):
assert response is None
-def test_drop_row_range_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.drop_row_range), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.drop_row_range()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DropRowRangeRequest()
-
-
def test_drop_row_range_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -6737,25 +6095,6 @@ def test_drop_row_range_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_drop_row_range_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.drop_row_range), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.drop_row_range()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DropRowRangeRequest()
-
-
@pytest.mark.asyncio
async def test_drop_row_range_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -6764,7 +6103,7 @@ async def test_drop_row_range_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6804,7 +6143,7 @@ async def test_drop_row_range_async(
request_type=bigtable_table_admin.DropRowRangeRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -6865,7 +6204,7 @@ def test_drop_row_range_field_headers():
@pytest.mark.asyncio
async def test_drop_row_range_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -6930,27 +6269,6 @@ def test_generate_consistency_token(request_type, transport: str = "grpc"):
assert response.consistency_token == "consistency_token_value"
-def test_generate_consistency_token_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.generate_consistency_token), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.generate_consistency_token()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GenerateConsistencyTokenRequest()
-
-
def test_generate_consistency_token_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -7021,31 +6339,6 @@ def test_generate_consistency_token_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_generate_consistency_token_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.generate_consistency_token), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_table_admin.GenerateConsistencyTokenResponse(
- consistency_token="consistency_token_value",
- )
- )
- response = await client.generate_consistency_token()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GenerateConsistencyTokenRequest()
-
-
@pytest.mark.asyncio
async def test_generate_consistency_token_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -7054,7 +6347,7 @@ async def test_generate_consistency_token_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7094,7 +6387,7 @@ async def test_generate_consistency_token_async(
request_type=bigtable_table_admin.GenerateConsistencyTokenRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7164,7 +6457,7 @@ def test_generate_consistency_token_field_headers():
@pytest.mark.asyncio
async def test_generate_consistency_token_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -7238,7 +6531,7 @@ def test_generate_consistency_token_flattened_error():
@pytest.mark.asyncio
async def test_generate_consistency_token_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -7269,7 +6562,7 @@ async def test_generate_consistency_token_flattened_async():
@pytest.mark.asyncio
async def test_generate_consistency_token_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -7319,27 +6612,6 @@ def test_check_consistency(request_type, transport: str = "grpc"):
assert response.consistent is True
-def test_check_consistency_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_consistency), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.check_consistency()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CheckConsistencyRequest()
-
-
def test_check_consistency_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -7409,31 +6681,6 @@ def test_check_consistency_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_check_consistency_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_consistency), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_table_admin.CheckConsistencyResponse(
- consistent=True,
- )
- )
- response = await client.check_consistency()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CheckConsistencyRequest()
-
-
@pytest.mark.asyncio
async def test_check_consistency_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -7442,7 +6689,7 @@ async def test_check_consistency_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7482,7 +6729,7 @@ async def test_check_consistency_async(
request_type=bigtable_table_admin.CheckConsistencyRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7552,7 +6799,7 @@ def test_check_consistency_field_headers():
@pytest.mark.asyncio
async def test_check_consistency_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -7631,7 +6878,7 @@ def test_check_consistency_flattened_error():
@pytest.mark.asyncio
async def test_check_consistency_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -7666,7 +6913,7 @@ async def test_check_consistency_flattened_async():
@pytest.mark.asyncio
async def test_check_consistency_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -7712,25 +6959,6 @@ def test_snapshot_table(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_snapshot_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.snapshot_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.snapshot_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.SnapshotTableRequest()
-
-
def test_snapshot_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -7805,27 +7033,6 @@ def test_snapshot_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_snapshot_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.snapshot_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.snapshot_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.SnapshotTableRequest()
-
-
@pytest.mark.asyncio
async def test_snapshot_table_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -7834,7 +7041,7 @@ async def test_snapshot_table_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7879,7 +7086,7 @@ async def test_snapshot_table_async(
request_type=bigtable_table_admin.SnapshotTableRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -7942,7 +7149,7 @@ def test_snapshot_table_field_headers():
@pytest.mark.asyncio
async def test_snapshot_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -8027,7 +7234,7 @@ def test_snapshot_table_flattened_error():
@pytest.mark.asyncio
async def test_snapshot_table_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8068,7 +7275,7 @@ async def test_snapshot_table_flattened_async():
@pytest.mark.asyncio
async def test_snapshot_table_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -8125,25 +7332,6 @@ def test_get_snapshot(request_type, transport: str = "grpc"):
assert response.description == "description_value"
-def test_get_snapshot_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_snapshot), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_snapshot()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetSnapshotRequest()
-
-
def test_get_snapshot_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -8207,32 +7395,6 @@ def test_get_snapshot_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_snapshot_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_snapshot), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- table.Snapshot(
- name="name_value",
- data_size_bytes=1594,
- state=table.Snapshot.State.READY,
- description="description_value",
- )
- )
- response = await client.get_snapshot()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetSnapshotRequest()
-
-
@pytest.mark.asyncio
async def test_get_snapshot_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -8241,7 +7403,7 @@ async def test_get_snapshot_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8281,7 +7443,7 @@ async def test_get_snapshot_async(
request_type=bigtable_table_admin.GetSnapshotRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8353,7 +7515,7 @@ def test_get_snapshot_field_headers():
@pytest.mark.asyncio
async def test_get_snapshot_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -8421,7 +7583,7 @@ def test_get_snapshot_flattened_error():
@pytest.mark.asyncio
async def test_get_snapshot_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8448,7 +7610,7 @@ async def test_get_snapshot_flattened_async():
@pytest.mark.asyncio
async def test_get_snapshot_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -8496,25 +7658,6 @@ def test_list_snapshots(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_snapshots_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_snapshots), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_snapshots()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListSnapshotsRequest()
-
-
def test_list_snapshots_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -8581,39 +7724,16 @@ def test_list_snapshots_use_cached_wrapped_rpc():
@pytest.mark.asyncio
-async def test_list_snapshots_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_snapshots), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_table_admin.ListSnapshotsResponse(
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_snapshots()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListSnapshotsRequest()
-
-
-@pytest.mark.asyncio
-async def test_list_snapshots_async_use_cached_wrapped_rpc(
- transport: str = "grpc_asyncio",
-):
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
+async def test_list_snapshots_async_use_cached_wrapped_rpc(
+ transport: str = "grpc_asyncio",
+):
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport=transport,
+ )
# Should wrap all calls on client creation
assert wrapper_fn.call_count > 0
@@ -8651,7 +7771,7 @@ async def test_list_snapshots_async(
request_type=bigtable_table_admin.ListSnapshotsRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -8717,7 +7837,7 @@ def test_list_snapshots_field_headers():
@pytest.mark.asyncio
async def test_list_snapshots_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -8787,7 +7907,7 @@ def test_list_snapshots_flattened_error():
@pytest.mark.asyncio
async def test_list_snapshots_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8816,7 +7936,7 @@ async def test_list_snapshots_flattened_async():
@pytest.mark.asyncio
async def test_list_snapshots_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -8926,7 +8046,7 @@ def test_list_snapshots_pages(transport_name: str = "grpc"):
@pytest.mark.asyncio
async def test_list_snapshots_async_pager():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -8976,7 +8096,7 @@ async def test_list_snapshots_async_pager():
@pytest.mark.asyncio
async def test_list_snapshots_async_pages():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -9055,25 +8175,6 @@ def test_delete_snapshot(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_snapshot_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_snapshot), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_snapshot()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteSnapshotRequest()
-
-
def test_delete_snapshot_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -9137,25 +8238,6 @@ def test_delete_snapshot_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_snapshot_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_snapshot), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_snapshot()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteSnapshotRequest()
-
-
@pytest.mark.asyncio
async def test_delete_snapshot_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -9164,7 +8246,7 @@ async def test_delete_snapshot_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9204,7 +8286,7 @@ async def test_delete_snapshot_async(
request_type=bigtable_table_admin.DeleteSnapshotRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9265,7 +8347,7 @@ def test_delete_snapshot_field_headers():
@pytest.mark.asyncio
async def test_delete_snapshot_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -9333,7 +8415,7 @@ def test_delete_snapshot_flattened_error():
@pytest.mark.asyncio
async def test_delete_snapshot_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -9360,7 +8442,7 @@ async def test_delete_snapshot_flattened_async():
@pytest.mark.asyncio
async def test_delete_snapshot_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -9405,25 +8487,6 @@ def test_create_backup(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_create_backup_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_backup), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.create_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateBackupRequest()
-
-
def test_create_backup_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -9494,27 +8557,6 @@ def test_create_backup_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_create_backup_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.create_backup), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.create_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CreateBackupRequest()
-
-
@pytest.mark.asyncio
async def test_create_backup_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -9523,7 +8565,7 @@ async def test_create_backup_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9568,7 +8610,7 @@ async def test_create_backup_async(
request_type=bigtable_table_admin.CreateBackupRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9631,7 +8673,7 @@ def test_create_backup_field_headers():
@pytest.mark.asyncio
async def test_create_backup_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -9711,7 +8753,7 @@ def test_create_backup_flattened_error():
@pytest.mark.asyncio
async def test_create_backup_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -9748,7 +8790,7 @@ async def test_create_backup_flattened_async():
@pytest.mark.asyncio
async def test_create_backup_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -9808,25 +8850,6 @@ def test_get_backup(request_type, transport: str = "grpc"):
assert response.backup_type == table.Backup.BackupType.STANDARD
-def test_get_backup_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_backup), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetBackupRequest()
-
-
def test_get_backup_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -9890,41 +8913,13 @@ def test_get_backup_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_backup_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_backup), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- table.Backup(
- name="name_value",
- source_table="source_table_value",
- source_backup="source_backup_value",
- size_bytes=1089,
- state=table.Backup.State.CREATING,
- backup_type=table.Backup.BackupType.STANDARD,
- )
- )
- response = await client.get_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.GetBackupRequest()
-
-
@pytest.mark.asyncio
async def test_get_backup_async_use_cached_wrapped_rpc(transport: str = "grpc_asyncio"):
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -9963,7 +8958,7 @@ async def test_get_backup_async(
transport: str = "grpc_asyncio", request_type=bigtable_table_admin.GetBackupRequest
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -10039,7 +9034,7 @@ def test_get_backup_field_headers():
@pytest.mark.asyncio
async def test_get_backup_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -10107,7 +9102,7 @@ def test_get_backup_flattened_error():
@pytest.mark.asyncio
async def test_get_backup_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -10134,7 +9129,7 @@ async def test_get_backup_flattened_async():
@pytest.mark.asyncio
async def test_get_backup_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -10192,25 +9187,6 @@ def test_update_backup(request_type, transport: str = "grpc"):
assert response.backup_type == table.Backup.BackupType.STANDARD
-def test_update_backup_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_backup), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.update_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UpdateBackupRequest()
-
-
def test_update_backup_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -10270,34 +9246,6 @@ def test_update_backup_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_update_backup_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.update_backup), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- table.Backup(
- name="name_value",
- source_table="source_table_value",
- source_backup="source_backup_value",
- size_bytes=1089,
- state=table.Backup.State.CREATING,
- backup_type=table.Backup.BackupType.STANDARD,
- )
- )
- response = await client.update_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.UpdateBackupRequest()
-
-
@pytest.mark.asyncio
async def test_update_backup_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -10306,7 +9254,7 @@ async def test_update_backup_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -10346,7 +9294,7 @@ async def test_update_backup_async(
request_type=bigtable_table_admin.UpdateBackupRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -10422,7 +9370,7 @@ def test_update_backup_field_headers():
@pytest.mark.asyncio
async def test_update_backup_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -10495,7 +9443,7 @@ def test_update_backup_flattened_error():
@pytest.mark.asyncio
async def test_update_backup_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -10526,7 +9474,7 @@ async def test_update_backup_flattened_async():
@pytest.mark.asyncio
async def test_update_backup_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -10572,25 +9520,6 @@ def test_delete_backup(request_type, transport: str = "grpc"):
assert response is None
-def test_delete_backup_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_backup), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.delete_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteBackupRequest()
-
-
def test_delete_backup_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -10654,25 +9583,6 @@ def test_delete_backup_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_delete_backup_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.delete_backup), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
- response = await client.delete_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.DeleteBackupRequest()
-
-
@pytest.mark.asyncio
async def test_delete_backup_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -10681,7 +9591,7 @@ async def test_delete_backup_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -10721,7 +9631,7 @@ async def test_delete_backup_async(
request_type=bigtable_table_admin.DeleteBackupRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -10782,7 +9692,7 @@ def test_delete_backup_field_headers():
@pytest.mark.asyncio
async def test_delete_backup_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -10850,7 +9760,7 @@ def test_delete_backup_flattened_error():
@pytest.mark.asyncio
async def test_delete_backup_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -10877,7 +9787,7 @@ async def test_delete_backup_flattened_async():
@pytest.mark.asyncio
async def test_delete_backup_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -10925,25 +9835,6 @@ def test_list_backups(request_type, transport: str = "grpc"):
assert response.next_page_token == "next_page_token_value"
-def test_list_backups_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_backups), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.list_backups()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListBackupsRequest()
-
-
def test_list_backups_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -11013,29 +9904,6 @@ def test_list_backups_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_list_backups_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.list_backups), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable_table_admin.ListBackupsResponse(
- next_page_token="next_page_token_value",
- )
- )
- response = await client.list_backups()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.ListBackupsRequest()
-
-
@pytest.mark.asyncio
async def test_list_backups_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -11044,7 +9912,7 @@ async def test_list_backups_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -11084,7 +9952,7 @@ async def test_list_backups_async(
request_type=bigtable_table_admin.ListBackupsRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -11150,7 +10018,7 @@ def test_list_backups_field_headers():
@pytest.mark.asyncio
async def test_list_backups_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -11220,7 +10088,7 @@ def test_list_backups_flattened_error():
@pytest.mark.asyncio
async def test_list_backups_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -11249,7 +10117,7 @@ async def test_list_backups_flattened_async():
@pytest.mark.asyncio
async def test_list_backups_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -11359,7 +10227,7 @@ def test_list_backups_pages(transport_name: str = "grpc"):
@pytest.mark.asyncio
async def test_list_backups_async_pager():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -11409,7 +10277,7 @@ async def test_list_backups_async_pager():
@pytest.mark.asyncio
async def test_list_backups_async_pages():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -11488,25 +10356,6 @@ def test_restore_table(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_restore_table_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.restore_table), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.restore_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.RestoreTableRequest()
-
-
def test_restore_table_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -11579,27 +10428,6 @@ def test_restore_table_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_restore_table_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.restore_table), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.restore_table()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.RestoreTableRequest()
-
-
@pytest.mark.asyncio
async def test_restore_table_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -11608,7 +10436,7 @@ async def test_restore_table_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -11653,7 +10481,7 @@ async def test_restore_table_async(
request_type=bigtable_table_admin.RestoreTableRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -11716,7 +10544,7 @@ def test_restore_table_field_headers():
@pytest.mark.asyncio
async def test_restore_table_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -11778,25 +10606,6 @@ def test_copy_backup(request_type, transport: str = "grpc"):
assert isinstance(response, future.Future)
-def test_copy_backup_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.copy_backup), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.copy_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CopyBackupRequest()
-
-
def test_copy_backup_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -11869,27 +10678,6 @@ def test_copy_backup_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_copy_backup_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.copy_backup), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- operations_pb2.Operation(name="operations/spam")
- )
- response = await client.copy_backup()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable_table_admin.CopyBackupRequest()
-
-
@pytest.mark.asyncio
async def test_copy_backup_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -11898,7 +10686,7 @@ async def test_copy_backup_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -11942,7 +10730,7 @@ async def test_copy_backup_async(
transport: str = "grpc_asyncio", request_type=bigtable_table_admin.CopyBackupRequest
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -12005,7 +10793,7 @@ def test_copy_backup_field_headers():
@pytest.mark.asyncio
async def test_copy_backup_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -12090,7 +10878,7 @@ def test_copy_backup_flattened_error():
@pytest.mark.asyncio
async def test_copy_backup_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -12131,7 +10919,7 @@ async def test_copy_backup_flattened_async():
@pytest.mark.asyncio
async def test_copy_backup_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -12184,25 +10972,6 @@ def test_get_iam_policy(request_type, transport: str = "grpc"):
assert response.etag == b"etag_blob"
-def test_get_iam_policy_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.get_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.GetIamPolicyRequest()
-
-
def test_get_iam_policy_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -12266,30 +11035,6 @@ def test_get_iam_policy_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_get_iam_policy_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
- )
- response = await client.get_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.GetIamPolicyRequest()
-
-
@pytest.mark.asyncio
async def test_get_iam_policy_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -12298,7 +11043,7 @@ async def test_get_iam_policy_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -12337,7 +11082,7 @@ async def test_get_iam_policy_async(
transport: str = "grpc_asyncio", request_type=iam_policy_pb2.GetIamPolicyRequest
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -12405,7 +11150,7 @@ def test_get_iam_policy_field_headers():
@pytest.mark.asyncio
async def test_get_iam_policy_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -12490,7 +11235,7 @@ def test_get_iam_policy_flattened_error():
@pytest.mark.asyncio
async def test_get_iam_policy_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -12517,7 +11262,7 @@ async def test_get_iam_policy_flattened_async():
@pytest.mark.asyncio
async def test_get_iam_policy_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -12567,25 +11312,6 @@ def test_set_iam_policy(request_type, transport: str = "grpc"):
assert response.etag == b"etag_blob"
-def test_set_iam_policy_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.set_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.SetIamPolicyRequest()
-
-
def test_set_iam_policy_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -12649,30 +11375,6 @@ def test_set_iam_policy_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_set_iam_policy_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
- )
- response = await client.set_iam_policy()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.SetIamPolicyRequest()
-
-
@pytest.mark.asyncio
async def test_set_iam_policy_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -12681,7 +11383,7 @@ async def test_set_iam_policy_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -12720,7 +11422,7 @@ async def test_set_iam_policy_async(
transport: str = "grpc_asyncio", request_type=iam_policy_pb2.SetIamPolicyRequest
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -12788,7 +11490,7 @@ def test_set_iam_policy_field_headers():
@pytest.mark.asyncio
async def test_set_iam_policy_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -12874,7 +11576,7 @@ def test_set_iam_policy_flattened_error():
@pytest.mark.asyncio
async def test_set_iam_policy_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -12901,7 +11603,7 @@ async def test_set_iam_policy_flattened_async():
@pytest.mark.asyncio
async def test_set_iam_policy_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -12951,27 +11653,6 @@ def test_test_iam_permissions(request_type, transport: str = "grpc"):
assert response.permissions == ["permissions_value"]
-def test_test_iam_permissions_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.test_iam_permissions), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.test_iam_permissions()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.TestIamPermissionsRequest()
-
-
def test_test_iam_permissions_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -13041,31 +11722,6 @@ def test_test_iam_permissions_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_test_iam_permissions_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.test_iam_permissions), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- iam_policy_pb2.TestIamPermissionsResponse(
- permissions=["permissions_value"],
- )
- )
- response = await client.test_iam_permissions()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == iam_policy_pb2.TestIamPermissionsRequest()
-
-
@pytest.mark.asyncio
async def test_test_iam_permissions_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -13074,7 +11730,7 @@ async def test_test_iam_permissions_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -13114,7 +11770,7 @@ async def test_test_iam_permissions_async(
request_type=iam_policy_pb2.TestIamPermissionsRequest,
):
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -13184,7 +11840,7 @@ def test_test_iam_permissions_field_headers():
@pytest.mark.asyncio
async def test_test_iam_permissions_field_headers_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -13282,7 +11938,7 @@ def test_test_iam_permissions_flattened_error():
@pytest.mark.asyncio
async def test_test_iam_permissions_flattened_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -13317,7 +11973,7 @@ async def test_test_iam_permissions_flattened_async():
@pytest.mark.asyncio
async def test_test_iam_permissions_flattened_error_async():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -13330,50 +11986,6 @@ async def test_test_iam_permissions_flattened_error_async():
)
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.CreateTableRequest,
- dict,
- ],
-)
-def test_create_table_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = gba_table.Table(
- name="name_value",
- granularity=gba_table.Table.TimestampGranularity.MILLIS,
- deletion_protection=True,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = gba_table.Table.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_table(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, gba_table.Table)
- assert response.name == "name_value"
- assert response.granularity == gba_table.Table.TimestampGranularity.MILLIS
- assert response.deletion_protection is True
-
-
def test_create_table_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -13507,89 +12119,10 @@ def test_create_table_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_create_table_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_create_table"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_create_table"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.CreateTableRequest.pb(
- bigtable_table_admin.CreateTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = gba_table.Table.to_json(gba_table.Table())
-
- request = bigtable_table_admin.CreateTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = gba_table.Table()
-
- client.create_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.CreateTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_table(request)
-
-
-def test_create_table_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
@@ -13646,47 +12179,6 @@ def test_create_table_rest_flattened_error(transport: str = "rest"):
)
-def test_create_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.CreateTableFromSnapshotRequest,
- dict,
- ],
-)
-def test_create_table_from_snapshot_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_table_from_snapshot(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
def test_create_table_from_snapshot_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -13830,90 +12322,6 @@ def test_create_table_from_snapshot_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_table_from_snapshot_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_create_table_from_snapshot"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_create_table_from_snapshot"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.CreateTableFromSnapshotRequest.pb(
- bigtable_table_admin.CreateTableFromSnapshotRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_table_admin.CreateTableFromSnapshotRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.create_table_from_snapshot(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_table_from_snapshot_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.CreateTableFromSnapshotRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_table_from_snapshot(request)
-
-
def test_create_table_from_snapshot_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -13973,52 +12381,6 @@ def test_create_table_from_snapshot_rest_flattened_error(transport: str = "rest"
)
-def test_create_table_from_snapshot_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.ListTablesRequest,
- dict,
- ],
-)
-def test_list_tables_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListTablesResponse(
- next_page_token="next_page_token_value",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListTablesResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_tables(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, pagers.ListTablesPager)
- assert response.next_page_token == "next_page_token_value"
-
-
def test_list_tables_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -14155,106 +12517,25 @@ def test_list_tables_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_tables_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_list_tables_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_list_tables"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_list_tables"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.ListTablesRequest.pb(
- bigtable_table_admin.ListTablesRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable_table_admin.ListTablesResponse.to_json(
- bigtable_table_admin.ListTablesResponse()
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.ListTablesResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {"parent": "projects/sample1/instances/sample2"}
+
+ # get truthy value for each flattened field
+ mock_args = dict(
+ parent="parent_value",
)
-
- request = bigtable_table_admin.ListTablesRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_table_admin.ListTablesResponse()
-
- client.list_tables(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_tables_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.ListTablesRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_tables(request)
-
-
-def test_list_tables_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListTablesResponse()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {"parent": "projects/sample1/instances/sample2"}
-
- # get truthy value for each flattened field
- mock_args = dict(
- parent="parent_value",
- )
- mock_args.update(sample_request)
+ mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
@@ -14355,50 +12636,6 @@ def test_list_tables_rest_pager(transport: str = "rest"):
assert page_.raw_page.next_page_token == token
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.GetTableRequest,
- dict,
- ],
-)
-def test_get_table_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Table(
- name="name_value",
- granularity=table.Table.TimestampGranularity.MILLIS,
- deletion_protection=True,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Table.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_table(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, table.Table)
- assert response.name == "name_value"
- assert response.granularity == table.Table.TimestampGranularity.MILLIS
- assert response.deletion_protection is True
-
-
def test_get_table_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -14520,85 +12757,6 @@ def test_get_table_rest_unset_required_fields():
assert set(unset_fields) == (set(("view",)) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_get_table"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_get_table"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.GetTableRequest.pb(
- bigtable_table_admin.GetTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = table.Table.to_json(table.Table())
-
- request = bigtable_table_admin.GetTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = table.Table()
-
- client.get_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.GetTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_table(request)
-
-
def test_get_table_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -14655,136 +12813,192 @@ def test_get_table_rest_flattened_error(transport: str = "rest"):
)
-def test_get_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+def test_update_table_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
+
+ # Ensure method has been cached
+ assert client._transport.update_table in client._transport._wrapped_methods
+
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[client._transport.update_table] = mock_rpc
+
+ request = {}
+ client.update_table(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert mock_rpc.call_count == 1
+
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.update_table(request)
+
+ # Establish that a new wrapper was not created for this call
+ assert wrapper_fn.call_count == 0
+ assert mock_rpc.call_count == 2
+
+
+def test_update_table_rest_required_fields(
+ request_type=bigtable_table_admin.UpdateTableRequest,
+):
+ transport_class = transports.BigtableTableAdminRestTransport
+
+ request_init = {}
+ request = request_type(**request_init)
+ pb_request = request_type.pb(request)
+ jsonified_request = json.loads(
+ json_format.MessageToJson(pb_request, use_integers_for_enums=False)
)
+ # verify fields with default values are dropped
+
+ unset_fields = transport_class(
+ credentials=ga_credentials.AnonymousCredentials()
+ ).update_table._get_unset_required_fields(jsonified_request)
+ jsonified_request.update(unset_fields)
+
+ # verify required fields with default values are now present
+
+ unset_fields = transport_class(
+ credentials=ga_credentials.AnonymousCredentials()
+ ).update_table._get_unset_required_fields(jsonified_request)
+ # Check that path parameters and body parameters are not mixing in.
+ assert not set(unset_fields) - set(("update_mask",))
+ jsonified_request.update(unset_fields)
+
+ # verify required fields with non-default values are left alone
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.UpdateTableRequest,
- dict,
- ],
-)
-def test_update_table_rest(request_type):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
+ request = request_type(**request_init)
- # send a request that will satisfy transcoding
- request_init = {
- "table": {"name": "projects/sample1/instances/sample2/tables/sample3"}
- }
- request_init["table"] = {
- "name": "projects/sample1/instances/sample2/tables/sample3",
- "cluster_states": {},
- "column_families": {},
- "granularity": 1,
- "restore_info": {
- "source_type": 1,
- "backup_info": {
- "backup": "backup_value",
- "start_time": {"seconds": 751, "nanos": 543},
- "end_time": {},
- "source_table": "source_table_value",
- "source_backup": "source_backup_value",
- },
- },
- "change_stream_config": {"retention_period": {"seconds": 751, "nanos": 543}},
- "deletion_protection": True,
- "automated_backup_policy": {"retention_period": {}, "frequency": {}},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(Session, "request") as req:
+ # We need to mock transcode() because providing default values
+ # for required fields will fail the real version if the http_options
+ # expect actual values for those fields.
+ with mock.patch.object(path_template, "transcode") as transcode:
+ # A uri without fields and an empty body will force all the
+ # request fields to show up in the query_params.
+ pb_request = request_type.pb(request)
+ transcode_result = {
+ "uri": "v1/sample_method",
+ "method": "patch",
+ "query_params": pb_request,
+ }
+ transcode_result["body"] = pb_request
+ transcode.return_value = transcode_result
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_table_admin.UpdateTableRequest.meta.fields["table"]
+ response_value = Response()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+ response = client.update_table(request)
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
+ expected_params = [("$alt", "json;enum-encoding=int")]
+ actual_params = req.call_args.kwargs["params"]
+ assert expected_params == actual_params
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
- subfields_not_in_runtime = []
+def test_update_table_rest_unset_required_fields():
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials
+ )
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["table"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
+ unset_fields = transport.update_table._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(("updateMask",))
+ & set(
+ (
+ "table",
+ "updateMask",
+ )
+ )
+ )
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["table"][field])):
- del request_init["table"][field][i][subfield]
- else:
- del request_init["table"][field][subfield]
- request = request_type(**request_init)
+def test_update_table_rest_flattened():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = operations_pb2.Operation(name="operations/spam")
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "table": {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ }
+
+ # get truthy value for each flattened field
+ mock_args = dict(
+ table=gba_table.Table(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+ mock_args.update(sample_request)
+
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = json_format.MessageToJson(return_value)
-
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.update_table(request)
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
+ client.update_table(**mock_args)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(req.mock_calls) == 1
+ _, args, _ = req.mock_calls[0]
+ assert path_template.validate(
+ "%s/v2/{table.name=projects/*/instances/*/tables/*}"
+ % client.transport._host,
+ args[1],
+ )
-def test_update_table_rest_use_cached_wrapped_rpc():
+def test_update_table_rest_flattened_error(transport: str = "rest"):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.update_table(
+ bigtable_table_admin.UpdateTableRequest(),
+ table=gba_table.Table(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+def test_delete_table_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -14798,38 +13012,35 @@ def test_update_table_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.update_table in client._transport._wrapped_methods
+ assert client._transport.delete_table in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.update_table] = mock_rpc
+ client._transport._wrapped_methods[client._transport.delete_table] = mock_rpc
request = {}
- client.update_table(request)
+ client.delete_table(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.update_table(request)
+ client.delete_table(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_update_table_rest_required_fields(
- request_type=bigtable_table_admin.UpdateTableRequest,
+def test_delete_table_rest_required_fields(
+ request_type=bigtable_table_admin.DeleteTableRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
+ request_init["name"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -14840,19 +13051,21 @@ def test_update_table_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).update_table._get_unset_required_fields(jsonified_request)
+ ).delete_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
+ jsonified_request["name"] = "name_value"
+
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).update_table._get_unset_required_fields(jsonified_request)
- # Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(("update_mask",))
+ ).delete_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
+ assert "name" in jsonified_request
+ assert jsonified_request["name"] == "name_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -14861,7 +13074,7 @@ def test_update_table_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = None
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -14873,172 +13086,74 @@ def test_update_table_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "patch",
+ "method": "delete",
"query_params": pb_request,
}
- transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.update_table(request)
+ response = client.delete_table(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_update_table_rest_unset_required_fields():
+def test_delete_table_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.update_table._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(("updateMask",))
- & set(
- (
- "table",
- "updateMask",
- )
- )
- )
+ unset_fields = transport.delete_table._get_unset_required_fields({})
+ assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_update_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_delete_table_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_update_table"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_update_table"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.UpdateTableRequest.pb(
- bigtable_table_admin.UpdateTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_table_admin.UpdateTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.update_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_update_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.UpdateTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "table": {"name": "projects/sample1/instances/sample2/tables/sample3"}
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.update_table(request)
-
-
-def test_update_table_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = None
# get arguments that satisfy an http rule for this method
- sample_request = {
- "table": {"name": "projects/sample1/instances/sample2/tables/sample3"}
- }
+ sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
# get truthy value for each flattened field
mock_args = dict(
- table=gba_table.Table(name="name_value"),
- update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ name="name_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.update_table(**mock_args)
+ client.delete_table(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{table.name=projects/*/instances/*/tables/*}"
- % client.transport._host,
+ "%s/v2/{name=projects/*/instances/*/tables/*}" % client.transport._host,
args[1],
)
-def test_update_table_rest_flattened_error(transport: str = "rest"):
+def test_delete_table_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -15047,55 +13162,13 @@ def test_update_table_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.update_table(
- bigtable_table_admin.UpdateTableRequest(),
- table=gba_table.Table(name="name_value"),
- update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ client.delete_table(
+ bigtable_table_admin.DeleteTableRequest(),
+ name="name_value",
)
-def test_update_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.DeleteTableRequest,
- dict,
- ],
-)
-def test_delete_table_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_table(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
-def test_delete_table_rest_use_cached_wrapped_rpc():
+def test_undelete_table_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -15109,30 +13182,34 @@ def test_delete_table_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.delete_table in client._transport._wrapped_methods
+ assert client._transport.undelete_table in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.delete_table] = mock_rpc
+ client._transport._wrapped_methods[client._transport.undelete_table] = mock_rpc
request = {}
- client.delete_table(request)
+ client.undelete_table(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.delete_table(request)
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.undelete_table(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_delete_table_rest_required_fields(
- request_type=bigtable_table_admin.DeleteTableRequest,
+def test_undelete_table_rest_required_fields(
+ request_type=bigtable_table_admin.UndeleteTableRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
@@ -15148,7 +13225,7 @@ def test_delete_table_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_table._get_unset_required_fields(jsonified_request)
+ ).undelete_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
@@ -15157,7 +13234,7 @@ def test_delete_table_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_table._get_unset_required_fields(jsonified_request)
+ ).undelete_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
@@ -15171,7 +13248,7 @@ def test_delete_table_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = operations_pb2.Operation(name="operations/spam")
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -15183,108 +13260,36 @@ def test_delete_table_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "delete",
+ "method": "post",
"query_params": pb_request,
}
+ transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.delete_table(request)
+ response = client.undelete_table(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_delete_table_rest_unset_required_fields():
+def test_undelete_table_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.delete_table._get_unset_required_fields({})
+ unset_fields = transport.undelete_table._get_unset_required_fields({})
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_delete_table"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_table_admin.DeleteTableRequest.pb(
- bigtable_table_admin.DeleteTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_table_admin.DeleteTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.delete_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
-
-
-def test_delete_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.DeleteTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_table(request)
-
-
-def test_delete_table_rest_flattened():
+def test_undelete_table_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -15293,7 +13298,7 @@ def test_delete_table_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = operations_pb2.Operation(name="operations/spam")
# get arguments that satisfy an http rule for this method
sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
@@ -15307,23 +13312,24 @@ def test_delete_table_rest_flattened():
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.delete_table(**mock_args)
+ client.undelete_table(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*}" % client.transport._host,
+ "%s/v2/{name=projects/*/instances/*/tables/*}:undelete"
+ % client.transport._host,
args[1],
)
-def test_delete_table_rest_flattened_error(transport: str = "rest"):
+def test_undelete_table_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -15332,78 +13338,42 @@ def test_delete_table_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.delete_table(
- bigtable_table_admin.DeleteTableRequest(),
+ client.undelete_table(
+ bigtable_table_admin.UndeleteTableRequest(),
name="name_value",
)
-def test_delete_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+def test_create_authorized_view_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.UndeleteTableRequest,
- dict,
- ],
-)
-def test_undelete_table_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.undelete_table(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_undelete_table_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.undelete_table in client._transport._wrapped_methods
+ assert (
+ client._transport.create_authorized_view
+ in client._transport._wrapped_methods
+ )
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.undelete_table] = mock_rpc
+ client._transport._wrapped_methods[
+ client._transport.create_authorized_view
+ ] = mock_rpc
request = {}
- client.undelete_table(request)
+ client.create_authorized_view(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
@@ -15412,20 +13382,21 @@ def test_undelete_table_rest_use_cached_wrapped_rpc():
# subsequent calls should use the cached wrapper
wrapper_fn.reset_mock()
- client.undelete_table(request)
+ client.create_authorized_view(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_undelete_table_rest_required_fields(
- request_type=bigtable_table_admin.UndeleteTableRequest,
+def test_create_authorized_view_rest_required_fields(
+ request_type=bigtable_table_admin.CreateAuthorizedViewRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["name"] = ""
+ request_init["parent"] = ""
+ request_init["authorized_view_id"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -15433,24 +13404,32 @@ def test_undelete_table_rest_required_fields(
)
# verify fields with default values are dropped
+ assert "authorizedViewId" not in jsonified_request
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).undelete_table._get_unset_required_fields(jsonified_request)
+ ).create_authorized_view._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
+ assert "authorizedViewId" in jsonified_request
+ assert jsonified_request["authorizedViewId"] == request_init["authorized_view_id"]
- jsonified_request["name"] = "name_value"
+ jsonified_request["parent"] = "parent_value"
+ jsonified_request["authorizedViewId"] = "authorized_view_id_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).undelete_table._get_unset_required_fields(jsonified_request)
+ ).create_authorized_view._get_unset_required_fields(jsonified_request)
+ # Check that path parameters and body parameters are not mixing in.
+ assert not set(unset_fields) - set(("authorized_view_id",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "name" in jsonified_request
- assert jsonified_request["name"] == "name_value"
+ assert "parent" in jsonified_request
+ assert jsonified_request["parent"] == "parent_value"
+ assert "authorizedViewId" in jsonified_request
+ assert jsonified_request["authorizedViewId"] == "authorized_view_id_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -15484,106 +13463,38 @@ def test_undelete_table_rest_required_fields(
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.undelete_table(request)
+ response = client.create_authorized_view(request)
- expected_params = [("$alt", "json;enum-encoding=int")]
+ expected_params = [
+ (
+ "authorizedViewId",
+ "",
+ ),
+ ("$alt", "json;enum-encoding=int"),
+ ]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_undelete_table_rest_unset_required_fields():
+def test_create_authorized_view_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.undelete_table._get_unset_required_fields({})
- assert set(unset_fields) == (set(()) & set(("name",)))
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_undelete_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_undelete_table"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_undelete_table"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.UndeleteTableRequest.pb(
- bigtable_table_admin.UndeleteTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_table_admin.UndeleteTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.undelete_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ unset_fields = transport.create_authorized_view._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(("authorizedViewId",))
+ & set(
+ (
+ "parent",
+ "authorizedViewId",
+ "authorizedView",
+ )
)
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_undelete_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.UndeleteTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.undelete_table(request)
-
-def test_undelete_table_rest_flattened():
+def test_create_authorized_view_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -15595,11 +13506,13 @@ def test_undelete_table_rest_flattened():
return_value = operations_pb2.Operation(name="operations/spam")
# get arguments that satisfy an http rule for this method
- sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ sample_request = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
# get truthy value for each flattened field
mock_args = dict(
- name="name_value",
+ parent="parent_value",
+ authorized_view=table.AuthorizedView(name="name_value"),
+ authorized_view_id="authorized_view_id_value",
)
mock_args.update(sample_request)
@@ -15610,20 +13523,20 @@ def test_undelete_table_rest_flattened():
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.undelete_table(**mock_args)
+ client.create_authorized_view(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*}:undelete"
+ "%s/v2/{parent=projects/*/instances/*/tables/*}/authorizedViews"
% client.transport._host,
args[1],
)
-def test_undelete_table_rest_flattened_error(transport: str = "rest"):
+def test_create_authorized_view_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -15632,184 +13545,62 @@ def test_undelete_table_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.undelete_table(
- bigtable_table_admin.UndeleteTableRequest(),
- name="name_value",
+ client.create_authorized_view(
+ bigtable_table_admin.CreateAuthorizedViewRequest(),
+ parent="parent_value",
+ authorized_view=table.AuthorizedView(name="name_value"),
+ authorized_view_id="authorized_view_id_value",
)
-def test_undelete_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+def test_list_authorized_views_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.CreateAuthorizedViewRequest,
- dict,
- ],
-)
-def test_create_authorized_view_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+ # Ensure method has been cached
+ assert (
+ client._transport.list_authorized_views
+ in client._transport._wrapped_methods
+ )
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
- request_init["authorized_view"] = {
- "name": "name_value",
- "subset_view": {
- "row_prefixes": [b"row_prefixes_blob1", b"row_prefixes_blob2"],
- "family_subsets": {},
- },
- "etag": "etag_value",
- "deletion_protection": True,
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[
+ client._transport.list_authorized_views
+ ] = mock_rpc
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_table_admin.CreateAuthorizedViewRequest.meta.fields[
- "authorized_view"
- ]
-
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
-
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["authorized_view"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["authorized_view"][field])):
- del request_init["authorized_view"][field][i][subfield]
- else:
- del request_init["authorized_view"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_authorized_view(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_create_authorized_view_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert (
- client._transport.create_authorized_view
- in client._transport._wrapped_methods
- )
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[
- client._transport.create_authorized_view
- ] = mock_rpc
-
- request = {}
- client.create_authorized_view(request)
+ request = {}
+ client.list_authorized_views(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.create_authorized_view(request)
+ client.list_authorized_views(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_create_authorized_view_rest_required_fields(
- request_type=bigtable_table_admin.CreateAuthorizedViewRequest,
+def test_list_authorized_views_rest_required_fields(
+ request_type=bigtable_table_admin.ListAuthorizedViewsRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
request_init["parent"] = ""
- request_init["authorized_view_id"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -15817,32 +13608,32 @@ def test_create_authorized_view_rest_required_fields(
)
# verify fields with default values are dropped
- assert "authorizedViewId" not in jsonified_request
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).create_authorized_view._get_unset_required_fields(jsonified_request)
+ ).list_authorized_views._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- assert "authorizedViewId" in jsonified_request
- assert jsonified_request["authorizedViewId"] == request_init["authorized_view_id"]
jsonified_request["parent"] = "parent_value"
- jsonified_request["authorizedViewId"] = "authorized_view_id_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).create_authorized_view._get_unset_required_fields(jsonified_request)
+ ).list_authorized_views._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(("authorized_view_id",))
+ assert not set(unset_fields) - set(
+ (
+ "page_size",
+ "page_token",
+ "view",
+ )
+ )
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "parent" in jsonified_request
assert jsonified_request["parent"] == "parent_value"
- assert "authorizedViewId" in jsonified_request
- assert jsonified_request["authorizedViewId"] == "authorized_view_id_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -15851,7 +13642,7 @@ def test_create_authorized_view_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -15863,135 +13654,49 @@ def test_create_authorized_view_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "post",
+ "method": "get",
"query_params": pb_request,
}
- transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse.pb(
+ return_value
+ )
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.create_authorized_view(request)
+ response = client.list_authorized_views(request)
- expected_params = [
- (
- "authorizedViewId",
- "",
- ),
- ("$alt", "json;enum-encoding=int"),
- ]
+ expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_create_authorized_view_rest_unset_required_fields():
+def test_list_authorized_views_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.create_authorized_view._get_unset_required_fields({})
+ unset_fields = transport.list_authorized_views._get_unset_required_fields({})
assert set(unset_fields) == (
- set(("authorizedViewId",))
- & set(
+ set(
(
- "parent",
- "authorizedViewId",
- "authorizedView",
+ "pageSize",
+ "pageToken",
+ "view",
)
)
+ & set(("parent",))
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_authorized_view_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_create_authorized_view"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_create_authorized_view"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.CreateAuthorizedViewRequest.pb(
- bigtable_table_admin.CreateAuthorizedViewRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_table_admin.CreateAuthorizedViewRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.create_authorized_view(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_authorized_view_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.CreateAuthorizedViewRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_authorized_view(request)
-
-
-def test_create_authorized_view_rest_flattened():
+def test_list_authorized_views_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -16000,7 +13705,7 @@ def test_create_authorized_view_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
# get arguments that satisfy an http rule for this method
sample_request = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
@@ -16008,19 +13713,19 @@ def test_create_authorized_view_rest_flattened():
# get truthy value for each flattened field
mock_args = dict(
parent="parent_value",
- authorized_view=table.AuthorizedView(name="name_value"),
- authorized_view_id="authorized_view_id_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.create_authorized_view(**mock_args)
+ client.list_authorized_views(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
@@ -16033,7 +13738,7 @@ def test_create_authorized_view_rest_flattened():
)
-def test_create_authorized_view_rest_flattened_error(transport: str = "rest"):
+def test_list_authorized_views_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -16042,61 +13747,77 @@ def test_create_authorized_view_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.create_authorized_view(
- bigtable_table_admin.CreateAuthorizedViewRequest(),
+ client.list_authorized_views(
+ bigtable_table_admin.ListAuthorizedViewsRequest(),
parent="parent_value",
- authorized_view=table.AuthorizedView(name="name_value"),
- authorized_view_id="authorized_view_id_value",
)
-def test_create_authorized_view_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.ListAuthorizedViewsRequest,
- dict,
- ],
-)
-def test_list_authorized_views_rest(request_type):
+def test_list_authorized_views_rest_pager(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
# Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListAuthorizedViewsResponse(
- next_page_token="next_page_token_value",
+ with mock.patch.object(Session, "request") as req:
+ # TODO(kbandes): remove this mock unless there's a good reason for it.
+ # with mock.patch.object(path_template, 'transcode') as transcode:
+ # Set the response as a series of pages
+ response = (
+ bigtable_table_admin.ListAuthorizedViewsResponse(
+ authorized_views=[
+ table.AuthorizedView(),
+ table.AuthorizedView(),
+ table.AuthorizedView(),
+ ],
+ next_page_token="abc",
+ ),
+ bigtable_table_admin.ListAuthorizedViewsResponse(
+ authorized_views=[],
+ next_page_token="def",
+ ),
+ bigtable_table_admin.ListAuthorizedViewsResponse(
+ authorized_views=[
+ table.AuthorizedView(),
+ ],
+ next_page_token="ghi",
+ ),
+ bigtable_table_admin.ListAuthorizedViewsResponse(
+ authorized_views=[
+ table.AuthorizedView(),
+ table.AuthorizedView(),
+ ],
+ ),
)
+ # Two responses for two calls
+ response = response + response
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListAuthorizedViewsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ # Wrap the values into proper Response objs
+ response = tuple(
+ bigtable_table_admin.ListAuthorizedViewsResponse.to_json(x)
+ for x in response
+ )
+ return_values = tuple(Response() for i in response)
+ for return_val, response_val in zip(return_values, response):
+ return_val._content = response_val.encode("UTF-8")
+ return_val.status_code = 200
+ req.side_effect = return_values
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_authorized_views(request)
+ sample_request = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
- # Establish that the response is the type that we expect.
- assert isinstance(response, pagers.ListAuthorizedViewsPager)
- assert response.next_page_token == "next_page_token_value"
+ pager = client.list_authorized_views(request=sample_request)
+ results = list(pager)
+ assert len(results) == 6
+ assert all(isinstance(i, table.AuthorizedView) for i in results)
-def test_list_authorized_views_rest_use_cached_wrapped_rpc():
+ pages = list(client.list_authorized_views(request=sample_request).pages)
+ for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
+ assert page_.raw_page.next_page_token == token
+
+
+def test_get_authorized_view_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -16111,8 +13832,7 @@ def test_list_authorized_views_rest_use_cached_wrapped_rpc():
# Ensure method has been cached
assert (
- client._transport.list_authorized_views
- in client._transport._wrapped_methods
+ client._transport.get_authorized_view in client._transport._wrapped_methods
)
# Replace cached wrapped function with mock
@@ -16121,29 +13841,29 @@ def test_list_authorized_views_rest_use_cached_wrapped_rpc():
"foo" # operation_request.operation in compute client(s) expect a string.
)
client._transport._wrapped_methods[
- client._transport.list_authorized_views
+ client._transport.get_authorized_view
] = mock_rpc
request = {}
- client.list_authorized_views(request)
+ client.get_authorized_view(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.list_authorized_views(request)
+ client.get_authorized_view(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_list_authorized_views_rest_required_fields(
- request_type=bigtable_table_admin.ListAuthorizedViewsRequest,
+def test_get_authorized_view_rest_required_fields(
+ request_type=bigtable_table_admin.GetAuthorizedViewRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["parent"] = ""
+ request_init["name"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -16154,29 +13874,23 @@ def test_list_authorized_views_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).list_authorized_views._get_unset_required_fields(jsonified_request)
+ ).get_authorized_view._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["parent"] = "parent_value"
+ jsonified_request["name"] = "name_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).list_authorized_views._get_unset_required_fields(jsonified_request)
+ ).get_authorized_view._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(
- (
- "page_size",
- "page_token",
- "view",
- )
- )
+ assert not set(unset_fields) - set(("view",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "parent" in jsonified_request
- assert jsonified_request["parent"] == "parent_value"
+ assert "name" in jsonified_request
+ assert jsonified_request["name"] == "name_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -16185,7 +13899,7 @@ def test_list_authorized_views_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
+ return_value = table.AuthorizedView()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -16206,124 +13920,29 @@ def test_list_authorized_views_rest_required_fields(
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = bigtable_table_admin.ListAuthorizedViewsResponse.pb(
- return_value
- )
+ return_value = table.AuthorizedView.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.list_authorized_views(request)
+ response = client.get_authorized_view(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_list_authorized_views_rest_unset_required_fields():
+def test_get_authorized_view_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.list_authorized_views._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(
- (
- "pageSize",
- "pageToken",
- "view",
- )
- )
- & set(("parent",))
- )
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_authorized_views_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_list_authorized_views"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_list_authorized_views"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.ListAuthorizedViewsRequest.pb(
- bigtable_table_admin.ListAuthorizedViewsRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_table_admin.ListAuthorizedViewsResponse.to_json(
- bigtable_table_admin.ListAuthorizedViewsResponse()
- )
- )
-
- request = bigtable_table_admin.ListAuthorizedViewsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
-
- client.list_authorized_views(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_authorized_views_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.ListAuthorizedViewsRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_authorized_views(request)
+ unset_fields = transport.get_authorized_view._get_unset_required_fields({})
+ assert set(unset_fields) == (set(("view",)) & set(("name",)))
-def test_list_authorized_views_rest_flattened():
+def test_get_authorized_view_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -16332,14 +13951,16 @@ def test_list_authorized_views_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
+ return_value = table.AuthorizedView()
# get arguments that satisfy an http rule for this method
- sample_request = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
+ sample_request = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
# get truthy value for each flattened field
mock_args = dict(
- parent="parent_value",
+ name="name_value",
)
mock_args.update(sample_request)
@@ -16347,25 +13968,25 @@ def test_list_authorized_views_rest_flattened():
response_value = Response()
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = bigtable_table_admin.ListAuthorizedViewsResponse.pb(return_value)
+ return_value = table.AuthorizedView.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.list_authorized_views(**mock_args)
+ client.get_authorized_view(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{parent=projects/*/instances/*/tables/*}/authorizedViews"
+ "%s/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}"
% client.transport._host,
args[1],
)
-def test_list_authorized_views_rest_flattened_error(transport: str = "rest"):
+def test_get_authorized_view_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -16374,123 +13995,13 @@ def test_list_authorized_views_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.list_authorized_views(
- bigtable_table_admin.ListAuthorizedViewsRequest(),
- parent="parent_value",
- )
-
-
-def test_list_authorized_views_rest_pager(transport: str = "rest"):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # TODO(kbandes): remove this mock unless there's a good reason for it.
- # with mock.patch.object(path_template, 'transcode') as transcode:
- # Set the response as a series of pages
- response = (
- bigtable_table_admin.ListAuthorizedViewsResponse(
- authorized_views=[
- table.AuthorizedView(),
- table.AuthorizedView(),
- table.AuthorizedView(),
- ],
- next_page_token="abc",
- ),
- bigtable_table_admin.ListAuthorizedViewsResponse(
- authorized_views=[],
- next_page_token="def",
- ),
- bigtable_table_admin.ListAuthorizedViewsResponse(
- authorized_views=[
- table.AuthorizedView(),
- ],
- next_page_token="ghi",
- ),
- bigtable_table_admin.ListAuthorizedViewsResponse(
- authorized_views=[
- table.AuthorizedView(),
- table.AuthorizedView(),
- ],
- ),
- )
- # Two responses for two calls
- response = response + response
-
- # Wrap the values into proper Response objs
- response = tuple(
- bigtable_table_admin.ListAuthorizedViewsResponse.to_json(x)
- for x in response
- )
- return_values = tuple(Response() for i in response)
- for return_val, response_val in zip(return_values, response):
- return_val._content = response_val.encode("UTF-8")
- return_val.status_code = 200
- req.side_effect = return_values
-
- sample_request = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
-
- pager = client.list_authorized_views(request=sample_request)
-
- results = list(pager)
- assert len(results) == 6
- assert all(isinstance(i, table.AuthorizedView) for i in results)
-
- pages = list(client.list_authorized_views(request=sample_request).pages)
- for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
- assert page_.raw_page.next_page_token == token
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.GetAuthorizedViewRequest,
- dict,
- ],
-)
-def test_get_authorized_view_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.AuthorizedView(
+ client.get_authorized_view(
+ bigtable_table_admin.GetAuthorizedViewRequest(),
name="name_value",
- etag="etag_value",
- deletion_protection=True,
)
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.AuthorizedView.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_authorized_view(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, table.AuthorizedView)
- assert response.name == "name_value"
- assert response.etag == "etag_value"
- assert response.deletion_protection is True
-
-def test_get_authorized_view_rest_use_cached_wrapped_rpc():
+def test_update_authorized_view_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -16505,7 +14016,8 @@ def test_get_authorized_view_rest_use_cached_wrapped_rpc():
# Ensure method has been cached
assert (
- client._transport.get_authorized_view in client._transport._wrapped_methods
+ client._transport.update_authorized_view
+ in client._transport._wrapped_methods
)
# Replace cached wrapped function with mock
@@ -16514,29 +14026,32 @@ def test_get_authorized_view_rest_use_cached_wrapped_rpc():
"foo" # operation_request.operation in compute client(s) expect a string.
)
client._transport._wrapped_methods[
- client._transport.get_authorized_view
+ client._transport.update_authorized_view
] = mock_rpc
request = {}
- client.get_authorized_view(request)
+ client.update_authorized_view(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.get_authorized_view(request)
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.update_authorized_view(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_get_authorized_view_rest_required_fields(
- request_type=bigtable_table_admin.GetAuthorizedViewRequest,
+def test_update_authorized_view_rest_required_fields(
+ request_type=bigtable_table_admin.UpdateAuthorizedViewRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["name"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -16547,23 +14062,24 @@ def test_get_authorized_view_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).get_authorized_view._get_unset_required_fields(jsonified_request)
+ ).update_authorized_view._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["name"] = "name_value"
-
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).get_authorized_view._get_unset_required_fields(jsonified_request)
+ ).update_authorized_view._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(("view",))
+ assert not set(unset_fields) - set(
+ (
+ "ignore_warnings",
+ "update_mask",
+ )
+ )
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "name" in jsonified_request
- assert jsonified_request["name"] == "name_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -16572,7 +14088,7 @@ def test_get_authorized_view_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = table.AuthorizedView()
+ return_value = operations_pb2.Operation(name="operations/spam")
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -16584,119 +14100,44 @@ def test_get_authorized_view_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "get",
+ "method": "patch",
"query_params": pb_request,
}
+ transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
-
- # Convert return value to protobuf type
- return_value = table.AuthorizedView.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.get_authorized_view(request)
+ response = client.update_authorized_view(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_get_authorized_view_rest_unset_required_fields():
+def test_update_authorized_view_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.get_authorized_view._get_unset_required_fields({})
- assert set(unset_fields) == (set(("view",)) & set(("name",)))
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_authorized_view_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_get_authorized_view"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_get_authorized_view"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.GetAuthorizedViewRequest.pb(
- bigtable_table_admin.GetAuthorizedViewRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = table.AuthorizedView.to_json(table.AuthorizedView())
-
- request = bigtable_table_admin.GetAuthorizedViewRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = table.AuthorizedView()
-
- client.get_authorized_view(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ unset_fields = transport.update_authorized_view._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(
+ (
+ "ignoreWarnings",
+ "updateMask",
+ )
)
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_authorized_view_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.GetAuthorizedViewRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ & set(("authorizedView",))
)
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_authorized_view(request)
-
-def test_get_authorized_view_rest_flattened():
+def test_update_authorized_view_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -16705,42 +14146,43 @@ def test_get_authorized_view_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = table.AuthorizedView()
+ return_value = operations_pb2.Operation(name="operations/spam")
# get arguments that satisfy an http rule for this method
sample_request = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ "authorized_view": {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
}
# get truthy value for each flattened field
mock_args = dict(
- name="name_value",
+ authorized_view=table.AuthorizedView(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.AuthorizedView.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.get_authorized_view(**mock_args)
+ client.update_authorized_view(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}"
+ "%s/v2/{authorized_view.name=projects/*/instances/*/tables/*/authorizedViews/*}"
% client.transport._host,
args[1],
)
-def test_get_authorized_view_rest_flattened_error(transport: str = "rest"):
+def test_update_authorized_view_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -16749,136 +14191,14 @@ def test_get_authorized_view_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.get_authorized_view(
- bigtable_table_admin.GetAuthorizedViewRequest(),
- name="name_value",
+ client.update_authorized_view(
+ bigtable_table_admin.UpdateAuthorizedViewRequest(),
+ authorized_view=table.AuthorizedView(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
)
-def test_get_authorized_view_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.UpdateAuthorizedViewRequest,
- dict,
- ],
-)
-def test_update_authorized_view_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "authorized_view": {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- }
- request_init["authorized_view"] = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4",
- "subset_view": {
- "row_prefixes": [b"row_prefixes_blob1", b"row_prefixes_blob2"],
- "family_subsets": {},
- },
- "etag": "etag_value",
- "deletion_protection": True,
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
-
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_table_admin.UpdateAuthorizedViewRequest.meta.fields[
- "authorized_view"
- ]
-
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
-
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["authorized_view"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["authorized_view"][field])):
- del request_init["authorized_view"][field][i][subfield]
- else:
- del request_init["authorized_view"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.update_authorized_view(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_update_authorized_view_rest_use_cached_wrapped_rpc():
+def test_delete_authorized_view_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -16893,7 +14213,7 @@ def test_update_authorized_view_rest_use_cached_wrapped_rpc():
# Ensure method has been cached
assert (
- client._transport.update_authorized_view
+ client._transport.delete_authorized_view
in client._transport._wrapped_methods
)
@@ -16903,32 +14223,29 @@ def test_update_authorized_view_rest_use_cached_wrapped_rpc():
"foo" # operation_request.operation in compute client(s) expect a string.
)
client._transport._wrapped_methods[
- client._transport.update_authorized_view
+ client._transport.delete_authorized_view
] = mock_rpc
request = {}
- client.update_authorized_view(request)
+ client.delete_authorized_view(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.update_authorized_view(request)
+ client.delete_authorized_view(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_update_authorized_view_rest_required_fields(
- request_type=bigtable_table_admin.UpdateAuthorizedViewRequest,
+def test_delete_authorized_view_rest_required_fields(
+ request_type=bigtable_table_admin.DeleteAuthorizedViewRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
+ request_init["name"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -16939,24 +14256,23 @@ def test_update_authorized_view_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).update_authorized_view._get_unset_required_fields(jsonified_request)
+ ).delete_authorized_view._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
+ jsonified_request["name"] = "name_value"
+
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).update_authorized_view._get_unset_required_fields(jsonified_request)
+ ).delete_authorized_view._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(
- (
- "ignore_warnings",
- "update_mask",
- )
- )
+ assert not set(unset_fields) - set(("etag",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
+ assert "name" in jsonified_request
+ assert jsonified_request["name"] == "name_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -16965,7 +14281,7 @@ def test_update_authorized_view_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = None
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -16977,177 +14293,77 @@ def test_update_authorized_view_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "patch",
+ "method": "delete",
"query_params": pb_request,
}
- transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.update_authorized_view(request)
+ response = client.delete_authorized_view(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_update_authorized_view_rest_unset_required_fields():
+def test_delete_authorized_view_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.update_authorized_view._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(
- (
- "ignoreWarnings",
- "updateMask",
- )
- )
- & set(("authorizedView",))
- )
+ unset_fields = transport.delete_authorized_view._get_unset_required_fields({})
+ assert set(unset_fields) == (set(("etag",)) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_update_authorized_view_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_delete_authorized_view_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_update_authorized_view"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_update_authorized_view"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.UpdateAuthorizedViewRequest.pb(
- bigtable_table_admin.UpdateAuthorizedViewRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
- request = bigtable_table_admin.UpdateAuthorizedViewRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
- client.update_authorized_view(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ # get truthy value for each flattened field
+ mock_args = dict(
+ name="name_value",
)
+ mock_args.update(sample_request)
- pre.assert_called_once()
- post.assert_called_once()
+ # Wrap the value into a proper Response obj
+ response_value = Response()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
-
-def test_update_authorized_view_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.UpdateAuthorizedViewRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "authorized_view": {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.update_authorized_view(request)
-
-
-def test_update_authorized_view_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "authorized_view": {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- authorized_view=table.AuthorizedView(name="name_value"),
- update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
- )
- mock_args.update(sample_request)
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
-
- client.update_authorized_view(**mock_args)
+ client.delete_authorized_view(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{authorized_view.name=projects/*/instances/*/tables/*/authorizedViews/*}"
+ "%s/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}"
% client.transport._host,
args[1],
)
-def test_update_authorized_view_rest_flattened_error(transport: str = "rest"):
+def test_delete_authorized_view_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -17156,57 +14372,13 @@ def test_update_authorized_view_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.update_authorized_view(
- bigtable_table_admin.UpdateAuthorizedViewRequest(),
- authorized_view=table.AuthorizedView(name="name_value"),
- update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ client.delete_authorized_view(
+ bigtable_table_admin.DeleteAuthorizedViewRequest(),
+ name="name_value",
)
-def test_update_authorized_view_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.DeleteAuthorizedViewRequest,
- dict,
- ],
-)
-def test_delete_authorized_view_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_authorized_view(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
-def test_delete_authorized_view_rest_use_cached_wrapped_rpc():
+def test_modify_column_families_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -17221,7 +14393,7 @@ def test_delete_authorized_view_rest_use_cached_wrapped_rpc():
# Ensure method has been cached
assert (
- client._transport.delete_authorized_view
+ client._transport.modify_column_families
in client._transport._wrapped_methods
)
@@ -17231,24 +14403,24 @@ def test_delete_authorized_view_rest_use_cached_wrapped_rpc():
"foo" # operation_request.operation in compute client(s) expect a string.
)
client._transport._wrapped_methods[
- client._transport.delete_authorized_view
+ client._transport.modify_column_families
] = mock_rpc
request = {}
- client.delete_authorized_view(request)
+ client.modify_column_families(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.delete_authorized_view(request)
+ client.modify_column_families(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_delete_authorized_view_rest_required_fields(
- request_type=bigtable_table_admin.DeleteAuthorizedViewRequest,
+def test_modify_column_families_rest_required_fields(
+ request_type=bigtable_table_admin.ModifyColumnFamiliesRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
@@ -17264,7 +14436,7 @@ def test_delete_authorized_view_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_authorized_view._get_unset_required_fields(jsonified_request)
+ ).modify_column_families._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
@@ -17273,9 +14445,7 @@ def test_delete_authorized_view_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_authorized_view._get_unset_required_fields(jsonified_request)
- # Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(("etag",))
+ ).modify_column_families._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
@@ -17289,7 +14459,7 @@ def test_delete_authorized_view_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = table.Table()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -17301,111 +14471,47 @@ def test_delete_authorized_view_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "delete",
+ "method": "post",
"query_params": pb_request,
}
+ transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+
+ # Convert return value to protobuf type
+ return_value = table.Table.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.delete_authorized_view(request)
+ response = client.modify_column_families(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_delete_authorized_view_rest_unset_required_fields():
+def test_modify_column_families_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.delete_authorized_view._get_unset_required_fields({})
- assert set(unset_fields) == (set(("etag",)) & set(("name",)))
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_authorized_view_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_delete_authorized_view"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_table_admin.DeleteAuthorizedViewRequest.pb(
- bigtable_table_admin.DeleteAuthorizedViewRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_table_admin.DeleteAuthorizedViewRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.delete_authorized_view(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ unset_fields = transport.modify_column_families._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(())
+ & set(
+ (
+ "name",
+ "modifications",
+ )
)
-
- pre.assert_called_once()
-
-
-def test_delete_authorized_view_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.DeleteAuthorizedViewRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_authorized_view(request)
-
-def test_delete_authorized_view_rest_flattened():
+def test_modify_column_families_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -17414,40 +14520,45 @@ def test_delete_authorized_view_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = table.Table()
# get arguments that satisfy an http rule for this method
- sample_request = {
- "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
+ sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
# get truthy value for each flattened field
mock_args = dict(
name="name_value",
+ modifications=[
+ bigtable_table_admin.ModifyColumnFamiliesRequest.Modification(
+ id="id_value"
+ )
+ ],
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+ # Convert return value to protobuf type
+ return_value = table.Table.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.delete_authorized_view(**mock_args)
+ client.modify_column_families(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*/authorizedViews/*}"
+ "%s/v2/{name=projects/*/instances/*/tables/*}:modifyColumnFamilies"
% client.transport._host,
args[1],
)
-def test_delete_authorized_view_rest_flattened_error(transport: str = "rest"):
+def test_modify_column_families_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -17456,63 +14567,135 @@ def test_delete_authorized_view_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.delete_authorized_view(
- bigtable_table_admin.DeleteAuthorizedViewRequest(),
+ client.modify_column_families(
+ bigtable_table_admin.ModifyColumnFamiliesRequest(),
name="name_value",
- )
-
-
-def test_delete_authorized_view_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ modifications=[
+ bigtable_table_admin.ModifyColumnFamiliesRequest.Modification(
+ id="id_value"
+ )
+ ],
+ )
+
+
+def test_drop_row_range_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
+
+ # Ensure method has been cached
+ assert client._transport.drop_row_range in client._transport._wrapped_methods
+
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
+ )
+ client._transport._wrapped_methods[client._transport.drop_row_range] = mock_rpc
+
+ request = {}
+ client.drop_row_range(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert mock_rpc.call_count == 1
+
+ client.drop_row_range(request)
+
+ # Establish that a new wrapper was not created for this call
+ assert wrapper_fn.call_count == 0
+ assert mock_rpc.call_count == 2
+
+
+def test_drop_row_range_rest_required_fields(
+ request_type=bigtable_table_admin.DropRowRangeRequest,
+):
+ transport_class = transports.BigtableTableAdminRestTransport
+
+ request_init = {}
+ request_init["name"] = ""
+ request = request_type(**request_init)
+ pb_request = request_type.pb(request)
+ jsonified_request = json.loads(
+ json_format.MessageToJson(pb_request, use_integers_for_enums=False)
)
+ # verify fields with default values are dropped
+
+ unset_fields = transport_class(
+ credentials=ga_credentials.AnonymousCredentials()
+ ).drop_row_range._get_unset_required_fields(jsonified_request)
+ jsonified_request.update(unset_fields)
+
+ # verify required fields with default values are now present
+
+ jsonified_request["name"] = "name_value"
+
+ unset_fields = transport_class(
+ credentials=ga_credentials.AnonymousCredentials()
+ ).drop_row_range._get_unset_required_fields(jsonified_request)
+ jsonified_request.update(unset_fields)
+
+ # verify required fields with non-default values are left alone
+ assert "name" in jsonified_request
+ assert jsonified_request["name"] == "name_value"
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.ModifyColumnFamiliesRequest,
- dict,
- ],
-)
-def test_modify_column_families_rest(request_type):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
request = request_type(**request_init)
+ # Designate an appropriate value for the returned response.
+ return_value = None
# Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Table(
- name="name_value",
- granularity=table.Table.TimestampGranularity.MILLIS,
- deletion_protection=True,
- )
+ with mock.patch.object(Session, "request") as req:
+ # We need to mock transcode() because providing default values
+ # for required fields will fail the real version if the http_options
+ # expect actual values for those fields.
+ with mock.patch.object(path_template, "transcode") as transcode:
+ # A uri without fields and an empty body will force all the
+ # request fields to show up in the query_params.
+ pb_request = request_type.pb(request)
+ transcode_result = {
+ "uri": "v1/sample_method",
+ "method": "post",
+ "query_params": pb_request,
+ }
+ transcode_result["body"] = pb_request
+ transcode.return_value = transcode_result
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Table.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ response_value = Response()
+ response_value.status_code = 200
+ json_return_value = ""
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.modify_column_families(request)
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
- # Establish that the response is the type that we expect.
- assert isinstance(response, table.Table)
- assert response.name == "name_value"
- assert response.granularity == table.Table.TimestampGranularity.MILLIS
- assert response.deletion_protection is True
+ response = client.drop_row_range(request)
+
+ expected_params = [("$alt", "json;enum-encoding=int")]
+ actual_params = req.call_args.kwargs["params"]
+ assert expected_params == actual_params
-def test_modify_column_families_rest_use_cached_wrapped_rpc():
+def test_drop_row_range_rest_unset_required_fields():
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials
+ )
+
+ unset_fields = transport.drop_row_range._get_unset_required_fields({})
+ assert set(unset_fields) == (set(()) & set(("name",)))
+
+
+def test_generate_consistency_token_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -17527,7 +14710,7 @@ def test_modify_column_families_rest_use_cached_wrapped_rpc():
# Ensure method has been cached
assert (
- client._transport.modify_column_families
+ client._transport.generate_consistency_token
in client._transport._wrapped_methods
)
@@ -17537,24 +14720,24 @@ def test_modify_column_families_rest_use_cached_wrapped_rpc():
"foo" # operation_request.operation in compute client(s) expect a string.
)
client._transport._wrapped_methods[
- client._transport.modify_column_families
+ client._transport.generate_consistency_token
] = mock_rpc
request = {}
- client.modify_column_families(request)
+ client.generate_consistency_token(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.modify_column_families(request)
+ client.generate_consistency_token(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_modify_column_families_rest_required_fields(
- request_type=bigtable_table_admin.ModifyColumnFamiliesRequest,
+def test_generate_consistency_token_rest_required_fields(
+ request_type=bigtable_table_admin.GenerateConsistencyTokenRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
@@ -17570,7 +14753,7 @@ def test_modify_column_families_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).modify_column_families._get_unset_required_fields(jsonified_request)
+ ).generate_consistency_token._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
@@ -17579,7 +14762,7 @@ def test_modify_column_families_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).modify_column_families._get_unset_required_fields(jsonified_request)
+ ).generate_consistency_token._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
@@ -17593,7 +14776,7 @@ def test_modify_column_families_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = table.Table()
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -17615,164 +14798,75 @@ def test_modify_column_families_rest_required_fields(
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = table.Table.pb(return_value)
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.pb(
+ return_value
+ )
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.modify_column_families(request)
+ response = client.generate_consistency_token(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_modify_column_families_rest_unset_required_fields():
+def test_generate_consistency_token_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.modify_column_families._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(())
- & set(
- (
- "name",
- "modifications",
- )
- )
- )
+ unset_fields = transport.generate_consistency_token._get_unset_required_fields({})
+ assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_modify_column_families_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_generate_consistency_token_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_modify_column_families"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_modify_column_families"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.ModifyColumnFamiliesRequest.pb(
- bigtable_table_admin.ModifyColumnFamiliesRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = table.Table.to_json(table.Table())
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
- request = bigtable_table_admin.ModifyColumnFamiliesRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = table.Table()
+ # get arguments that satisfy an http rule for this method
+ sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- client.modify_column_families(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ # get truthy value for each flattened field
+ mock_args = dict(
+ name="name_value",
)
+ mock_args.update(sample_request)
- pre.assert_called_once()
- post.assert_called_once()
+ # Wrap the value into a proper Response obj
+ response_value = Response()
+ response_value.status_code = 200
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.pb(
+ return_value
+ )
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
-
-def test_modify_column_families_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.ModifyColumnFamiliesRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.modify_column_families(request)
-
-
-def test_modify_column_families_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Table()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
-
- # get truthy value for each flattened field
- mock_args = dict(
- name="name_value",
- modifications=[
- bigtable_table_admin.ModifyColumnFamiliesRequest.Modification(
- id="id_value"
- )
- ],
- )
- mock_args.update(sample_request)
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Table.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
-
- client.modify_column_families(**mock_args)
+ client.generate_consistency_token(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*}:modifyColumnFamilies"
+ "%s/v2/{name=projects/*/instances/*/tables/*}:generateConsistencyToken"
% client.transport._host,
args[1],
)
-def test_modify_column_families_rest_flattened_error(transport: str = "rest"):
+def test_generate_consistency_token_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -17781,59 +14875,13 @@ def test_modify_column_families_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.modify_column_families(
- bigtable_table_admin.ModifyColumnFamiliesRequest(),
+ client.generate_consistency_token(
+ bigtable_table_admin.GenerateConsistencyTokenRequest(),
name="name_value",
- modifications=[
- bigtable_table_admin.ModifyColumnFamiliesRequest.Modification(
- id="id_value"
- )
- ],
)
-def test_modify_column_families_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.DropRowRangeRequest,
- dict,
- ],
-)
-def test_drop_row_range_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.drop_row_range(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
-def test_drop_row_range_rest_use_cached_wrapped_rpc():
+def test_check_consistency_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -17847,35 +14895,38 @@ def test_drop_row_range_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.drop_row_range in client._transport._wrapped_methods
+ assert client._transport.check_consistency in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.drop_row_range] = mock_rpc
+ client._transport._wrapped_methods[
+ client._transport.check_consistency
+ ] = mock_rpc
request = {}
- client.drop_row_range(request)
+ client.check_consistency(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.drop_row_range(request)
+ client.check_consistency(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_drop_row_range_rest_required_fields(
- request_type=bigtable_table_admin.DropRowRangeRequest,
+def test_check_consistency_rest_required_fields(
+ request_type=bigtable_table_admin.CheckConsistencyRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
request_init["name"] = ""
+ request_init["consistency_token"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -17886,21 +14937,24 @@ def test_drop_row_range_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).drop_row_range._get_unset_required_fields(jsonified_request)
+ ).check_consistency._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["name"] = "name_value"
+ jsonified_request["consistencyToken"] = "consistency_token_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).drop_row_range._get_unset_required_fields(jsonified_request)
+ ).check_consistency._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "name" in jsonified_request
assert jsonified_request["name"] == "name_value"
+ assert "consistencyToken" in jsonified_request
+ assert jsonified_request["consistencyToken"] == "consistency_token_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -17909,7 +14963,7 @@ def test_drop_row_range_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = bigtable_table_admin.CheckConsistencyResponse()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -17929,149 +14983,100 @@ def test_drop_row_range_rest_required_fields(
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.CheckConsistencyResponse.pb(
+ return_value
+ )
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.drop_row_range(request)
+ response = client.check_consistency(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_drop_row_range_rest_unset_required_fields():
+def test_check_consistency_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.drop_row_range._get_unset_required_fields({})
- assert set(unset_fields) == (set(()) & set(("name",)))
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_drop_row_range_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_drop_row_range"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_table_admin.DropRowRangeRequest.pb(
- bigtable_table_admin.DropRowRangeRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_table_admin.DropRowRangeRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.drop_row_range(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ unset_fields = transport.check_consistency._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(())
+ & set(
+ (
+ "name",
+ "consistencyToken",
+ )
)
-
- pre.assert_called_once()
-
-
-def test_drop_row_range_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.DropRowRangeRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.drop_row_range(request)
-
-
-def test_drop_row_range_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.GenerateConsistencyTokenRequest,
- dict,
- ],
-)
-def test_generate_consistency_token_rest(request_type):
+def test_check_consistency_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.GenerateConsistencyTokenResponse(
+ return_value = bigtable_table_admin.CheckConsistencyResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+
+ # get truthy value for each flattened field
+ mock_args = dict(
+ name="name_value",
consistency_token="consistency_token_value",
)
+ mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.pb(
- return_value
- )
+ return_value = bigtable_table_admin.CheckConsistencyResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
-
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.generate_consistency_token(request)
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable_table_admin.GenerateConsistencyTokenResponse)
- assert response.consistency_token == "consistency_token_value"
+ client.check_consistency(**mock_args)
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(req.mock_calls) == 1
+ _, args, _ = req.mock_calls[0]
+ assert path_template.validate(
+ "%s/v2/{name=projects/*/instances/*/tables/*}:checkConsistency"
+ % client.transport._host,
+ args[1],
+ )
-def test_generate_consistency_token_rest_use_cached_wrapped_rpc():
+
+def test_check_consistency_rest_flattened_error(transport: str = "rest"):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.check_consistency(
+ bigtable_table_admin.CheckConsistencyRequest(),
+ name="name_value",
+ consistency_token="consistency_token_value",
+ )
+
+
+def test_snapshot_table_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -18085,40 +15090,41 @@ def test_generate_consistency_token_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert (
- client._transport.generate_consistency_token
- in client._transport._wrapped_methods
- )
+ assert client._transport.snapshot_table in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[
- client._transport.generate_consistency_token
- ] = mock_rpc
+ client._transport._wrapped_methods[client._transport.snapshot_table] = mock_rpc
request = {}
- client.generate_consistency_token(request)
+ client.snapshot_table(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.generate_consistency_token(request)
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.snapshot_table(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_generate_consistency_token_rest_required_fields(
- request_type=bigtable_table_admin.GenerateConsistencyTokenRequest,
+def test_snapshot_table_rest_required_fields(
+ request_type=bigtable_table_admin.SnapshotTableRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
request_init["name"] = ""
+ request_init["cluster"] = ""
+ request_init["snapshot_id"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -18129,21 +15135,27 @@ def test_generate_consistency_token_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).generate_consistency_token._get_unset_required_fields(jsonified_request)
+ ).snapshot_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["name"] = "name_value"
+ jsonified_request["cluster"] = "cluster_value"
+ jsonified_request["snapshotId"] = "snapshot_id_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).generate_consistency_token._get_unset_required_fields(jsonified_request)
+ ).snapshot_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "name" in jsonified_request
assert jsonified_request["name"] == "name_value"
+ assert "cluster" in jsonified_request
+ assert jsonified_request["cluster"] == "cluster_value"
+ assert "snapshotId" in jsonified_request
+ assert jsonified_request["snapshotId"] == "snapshot_id_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -18152,7 +15164,7 @@ def test_generate_consistency_token_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
+ return_value = operations_pb2.Operation(name="operations/spam")
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -18172,117 +15184,37 @@ def test_generate_consistency_token_rest_required_fields(
response_value = Response()
response_value.status_code = 200
-
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.pb(
- return_value
- )
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.generate_consistency_token(request)
+ response = client.snapshot_table(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_generate_consistency_token_rest_unset_required_fields():
+def test_snapshot_table_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.generate_consistency_token._get_unset_required_fields({})
- assert set(unset_fields) == (set(()) & set(("name",)))
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_generate_consistency_token_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_generate_consistency_token"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_generate_consistency_token"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.GenerateConsistencyTokenRequest.pb(
- bigtable_table_admin.GenerateConsistencyTokenRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_table_admin.GenerateConsistencyTokenResponse.to_json(
- bigtable_table_admin.GenerateConsistencyTokenResponse()
+ unset_fields = transport.snapshot_table._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(())
+ & set(
+ (
+ "name",
+ "cluster",
+ "snapshotId",
)
)
-
- request = bigtable_table_admin.GenerateConsistencyTokenRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
-
- client.generate_consistency_token(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_generate_consistency_token_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable_table_admin.GenerateConsistencyTokenRequest,
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.generate_consistency_token(request)
-
-def test_generate_consistency_token_rest_flattened():
+def test_snapshot_table_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -18291,7 +15223,7 @@ def test_generate_consistency_token_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
+ return_value = operations_pb2.Operation(name="operations/spam")
# get arguments that satisfy an http rule for this method
sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
@@ -18299,34 +15231,33 @@ def test_generate_consistency_token_rest_flattened():
# get truthy value for each flattened field
mock_args = dict(
name="name_value",
+ cluster="cluster_value",
+ snapshot_id="snapshot_id_value",
+ description="description_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.pb(
- return_value
- )
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.generate_consistency_token(**mock_args)
+ client.snapshot_table(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*}:generateConsistencyToken"
+ "%s/v2/{name=projects/*/instances/*/tables/*}:snapshot"
% client.transport._host,
args[1],
)
-def test_generate_consistency_token_rest_flattened_error(transport: str = "rest"):
+def test_snapshot_table_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -18335,59 +15266,16 @@ def test_generate_consistency_token_rest_flattened_error(transport: str = "rest"
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.generate_consistency_token(
- bigtable_table_admin.GenerateConsistencyTokenRequest(),
+ client.snapshot_table(
+ bigtable_table_admin.SnapshotTableRequest(),
name="name_value",
+ cluster="cluster_value",
+ snapshot_id="snapshot_id_value",
+ description="description_value",
)
-def test_generate_consistency_token_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.CheckConsistencyRequest,
- dict,
- ],
-)
-def test_check_consistency_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.CheckConsistencyResponse(
- consistent=True,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.CheckConsistencyResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.check_consistency(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable_table_admin.CheckConsistencyResponse)
- assert response.consistent is True
-
-
-def test_check_consistency_rest_use_cached_wrapped_rpc():
+def test_get_snapshot_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -18401,38 +15289,35 @@ def test_check_consistency_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.check_consistency in client._transport._wrapped_methods
+ assert client._transport.get_snapshot in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[
- client._transport.check_consistency
- ] = mock_rpc
+ client._transport._wrapped_methods[client._transport.get_snapshot] = mock_rpc
request = {}
- client.check_consistency(request)
+ client.get_snapshot(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.check_consistency(request)
+ client.get_snapshot(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_check_consistency_rest_required_fields(
- request_type=bigtable_table_admin.CheckConsistencyRequest,
+def test_get_snapshot_rest_required_fields(
+ request_type=bigtable_table_admin.GetSnapshotRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
request_init["name"] = ""
- request_init["consistency_token"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -18443,24 +15328,21 @@ def test_check_consistency_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).check_consistency._get_unset_required_fields(jsonified_request)
+ ).get_snapshot._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["name"] = "name_value"
- jsonified_request["consistencyToken"] = "consistency_token_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).check_consistency._get_unset_required_fields(jsonified_request)
+ ).get_snapshot._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "name" in jsonified_request
assert jsonified_request["name"] == "name_value"
- assert "consistencyToken" in jsonified_request
- assert jsonified_request["consistencyToken"] == "consistency_token_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -18469,7 +15351,7 @@ def test_check_consistency_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.CheckConsistencyResponse()
+ return_value = table.Snapshot()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -18481,132 +15363,38 @@ def test_check_consistency_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "post",
+ "method": "get",
"query_params": pb_request,
}
- transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = bigtable_table_admin.CheckConsistencyResponse.pb(
- return_value
- )
+ return_value = table.Snapshot.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.check_consistency(request)
+ response = client.get_snapshot(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_check_consistency_rest_unset_required_fields():
+def test_get_snapshot_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.check_consistency._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(())
- & set(
- (
- "name",
- "consistencyToken",
- )
- )
- )
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_check_consistency_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_check_consistency"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_check_consistency"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.CheckConsistencyRequest.pb(
- bigtable_table_admin.CheckConsistencyRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable_table_admin.CheckConsistencyResponse.to_json(
- bigtable_table_admin.CheckConsistencyResponse()
- )
- )
-
- request = bigtable_table_admin.CheckConsistencyRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_table_admin.CheckConsistencyResponse()
-
- client.check_consistency(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_check_consistency_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.CheckConsistencyRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.check_consistency(request)
+ unset_fields = transport.get_snapshot._get_unset_required_fields({})
+ assert set(unset_fields) == (set(()) & set(("name",)))
-def test_check_consistency_rest_flattened():
+def test_get_snapshot_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -18615,15 +15403,16 @@ def test_check_consistency_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.CheckConsistencyResponse()
+ return_value = table.Snapshot()
# get arguments that satisfy an http rule for this method
- sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ sample_request = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ }
# get truthy value for each flattened field
mock_args = dict(
name="name_value",
- consistency_token="consistency_token_value",
)
mock_args.update(sample_request)
@@ -18631,25 +15420,25 @@ def test_check_consistency_rest_flattened():
response_value = Response()
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = bigtable_table_admin.CheckConsistencyResponse.pb(return_value)
+ return_value = table.Snapshot.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.check_consistency(**mock_args)
+ client.get_snapshot(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*}:checkConsistency"
+ "%s/v2/{name=projects/*/instances/*/clusters/*/snapshots/*}"
% client.transport._host,
args[1],
)
-def test_check_consistency_rest_flattened_error(transport: str = "rest"):
+def test_get_snapshot_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -18658,55 +15447,13 @@ def test_check_consistency_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.check_consistency(
- bigtable_table_admin.CheckConsistencyRequest(),
+ client.get_snapshot(
+ bigtable_table_admin.GetSnapshotRequest(),
name="name_value",
- consistency_token="consistency_token_value",
)
-def test_check_consistency_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.SnapshotTableRequest,
- dict,
- ],
-)
-def test_snapshot_table_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.snapshot_table(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_snapshot_table_rest_use_cached_wrapped_rpc():
+def test_list_snapshots_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -18720,41 +15467,35 @@ def test_snapshot_table_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.snapshot_table in client._transport._wrapped_methods
+ assert client._transport.list_snapshots in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.snapshot_table] = mock_rpc
+ client._transport._wrapped_methods[client._transport.list_snapshots] = mock_rpc
request = {}
- client.snapshot_table(request)
+ client.list_snapshots(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.snapshot_table(request)
+ client.list_snapshots(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_snapshot_table_rest_required_fields(
- request_type=bigtable_table_admin.SnapshotTableRequest,
+def test_list_snapshots_rest_required_fields(
+ request_type=bigtable_table_admin.ListSnapshotsRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["name"] = ""
- request_init["cluster"] = ""
- request_init["snapshot_id"] = ""
+ request_init["parent"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -18765,27 +15506,28 @@ def test_snapshot_table_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).snapshot_table._get_unset_required_fields(jsonified_request)
+ ).list_snapshots._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["name"] = "name_value"
- jsonified_request["cluster"] = "cluster_value"
- jsonified_request["snapshotId"] = "snapshot_id_value"
+ jsonified_request["parent"] = "parent_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).snapshot_table._get_unset_required_fields(jsonified_request)
+ ).list_snapshots._get_unset_required_fields(jsonified_request)
+ # Check that path parameters and body parameters are not mixing in.
+ assert not set(unset_fields) - set(
+ (
+ "page_size",
+ "page_token",
+ )
+ )
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "name" in jsonified_request
- assert jsonified_request["name"] == "name_value"
- assert "cluster" in jsonified_request
- assert jsonified_request["cluster"] == "cluster_value"
- assert "snapshotId" in jsonified_request
- assert jsonified_request["snapshotId"] == "snapshot_id_value"
+ assert "parent" in jsonified_request
+ assert jsonified_request["parent"] == "parent_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -18794,7 +15536,7 @@ def test_snapshot_table_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = bigtable_table_admin.ListSnapshotsResponse()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -18806,171 +15548,90 @@ def test_snapshot_table_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "post",
+ "method": "get",
"query_params": pb_request,
}
- transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListSnapshotsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.snapshot_table(request)
+ response = client.list_snapshots(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_snapshot_table_rest_unset_required_fields():
+def test_list_snapshots_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.snapshot_table._get_unset_required_fields({})
+ unset_fields = transport.list_snapshots._get_unset_required_fields({})
assert set(unset_fields) == (
- set(())
- & set(
+ set(
(
- "name",
- "cluster",
- "snapshotId",
+ "pageSize",
+ "pageToken",
)
)
+ & set(("parent",))
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_snapshot_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_list_snapshots_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_snapshot_table"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_snapshot_table"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.SnapshotTableRequest.pb(
- bigtable_table_admin.SnapshotTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
-
- request = bigtable_table_admin.SnapshotTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.snapshot_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_snapshot_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.SnapshotTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.snapshot_table(request)
-
-
-def test_snapshot_table_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = bigtable_table_admin.ListSnapshotsResponse()
# get arguments that satisfy an http rule for this method
- sample_request = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ sample_request = {
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
+ }
# get truthy value for each flattened field
mock_args = dict(
- name="name_value",
- cluster="cluster_value",
- snapshot_id="snapshot_id_value",
- description="description_value",
+ parent="parent_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListSnapshotsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.snapshot_table(**mock_args)
+ client.list_snapshots(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/tables/*}:snapshot"
+ "%s/v2/{parent=projects/*/instances/*/clusters/*}/snapshots"
% client.transport._host,
args[1],
)
-def test_snapshot_table_rest_flattened_error(transport: str = "rest"):
+def test_list_snapshots_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -18979,70 +15640,78 @@ def test_snapshot_table_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.snapshot_table(
- bigtable_table_admin.SnapshotTableRequest(),
- name="name_value",
- cluster="cluster_value",
- snapshot_id="snapshot_id_value",
- description="description_value",
+ client.list_snapshots(
+ bigtable_table_admin.ListSnapshotsRequest(),
+ parent="parent_value",
)
-def test_snapshot_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.GetSnapshotRequest,
- dict,
- ],
-)
-def test_get_snapshot_rest(request_type):
+def test_list_snapshots_rest_pager(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
- }
- request = request_type(**request_init)
-
# Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Snapshot(
- name="name_value",
- data_size_bytes=1594,
- state=table.Snapshot.State.READY,
- description="description_value",
+ with mock.patch.object(Session, "request") as req:
+ # TODO(kbandes): remove this mock unless there's a good reason for it.
+ # with mock.patch.object(path_template, 'transcode') as transcode:
+ # Set the response as a series of pages
+ response = (
+ bigtable_table_admin.ListSnapshotsResponse(
+ snapshots=[
+ table.Snapshot(),
+ table.Snapshot(),
+ table.Snapshot(),
+ ],
+ next_page_token="abc",
+ ),
+ bigtable_table_admin.ListSnapshotsResponse(
+ snapshots=[],
+ next_page_token="def",
+ ),
+ bigtable_table_admin.ListSnapshotsResponse(
+ snapshots=[
+ table.Snapshot(),
+ ],
+ next_page_token="ghi",
+ ),
+ bigtable_table_admin.ListSnapshotsResponse(
+ snapshots=[
+ table.Snapshot(),
+ table.Snapshot(),
+ ],
+ ),
)
+ # Two responses for two calls
+ response = response + response
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Snapshot.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ # Wrap the values into proper Response objs
+ response = tuple(
+ bigtable_table_admin.ListSnapshotsResponse.to_json(x) for x in response
+ )
+ return_values = tuple(Response() for i in response)
+ for return_val, response_val in zip(return_values, response):
+ return_val._content = response_val.encode("UTF-8")
+ return_val.status_code = 200
+ req.side_effect = return_values
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_snapshot(request)
+ sample_request = {
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
+ }
- # Establish that the response is the type that we expect.
- assert isinstance(response, table.Snapshot)
- assert response.name == "name_value"
- assert response.data_size_bytes == 1594
- assert response.state == table.Snapshot.State.READY
- assert response.description == "description_value"
+ pager = client.list_snapshots(request=sample_request)
+ results = list(pager)
+ assert len(results) == 6
+ assert all(isinstance(i, table.Snapshot) for i in results)
-def test_get_snapshot_rest_use_cached_wrapped_rpc():
+ pages = list(client.list_snapshots(request=sample_request).pages)
+ for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
+ assert page_.raw_page.next_page_token == token
+
+
+def test_delete_snapshot_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -19056,30 +15725,30 @@ def test_get_snapshot_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.get_snapshot in client._transport._wrapped_methods
+ assert client._transport.delete_snapshot in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.get_snapshot] = mock_rpc
+ client._transport._wrapped_methods[client._transport.delete_snapshot] = mock_rpc
request = {}
- client.get_snapshot(request)
+ client.delete_snapshot(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.get_snapshot(request)
+ client.delete_snapshot(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_get_snapshot_rest_required_fields(
- request_type=bigtable_table_admin.GetSnapshotRequest,
+def test_delete_snapshot_rest_required_fields(
+ request_type=bigtable_table_admin.DeleteSnapshotRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
@@ -19095,7 +15764,7 @@ def test_get_snapshot_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).get_snapshot._get_unset_required_fields(jsonified_request)
+ ).delete_snapshot._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
@@ -19104,7 +15773,7 @@ def test_get_snapshot_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).get_snapshot._get_unset_required_fields(jsonified_request)
+ ).delete_snapshot._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
@@ -19118,7 +15787,7 @@ def test_get_snapshot_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = table.Snapshot()
+ return_value = None
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -19130,133 +15799,49 @@ def test_get_snapshot_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "get",
+ "method": "delete",
"query_params": pb_request,
}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
-
- # Convert return value to protobuf type
- return_value = table.Snapshot.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.get_snapshot(request)
+ response = client.delete_snapshot(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_get_snapshot_rest_unset_required_fields():
+def test_delete_snapshot_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.get_snapshot._get_unset_required_fields({})
+ unset_fields = transport.delete_snapshot._get_unset_required_fields({})
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_snapshot_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_delete_snapshot_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_get_snapshot"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_get_snapshot"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.GetSnapshotRequest.pb(
- bigtable_table_admin.GetSnapshotRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = table.Snapshot.to_json(table.Snapshot())
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
- request = bigtable_table_admin.GetSnapshotRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = table.Snapshot()
-
- client.get_snapshot(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_snapshot_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.GetSnapshotRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_snapshot(request)
-
-
-def test_get_snapshot_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Snapshot()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
- }
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ }
# get truthy value for each flattened field
mock_args = dict(
@@ -19267,13 +15852,11 @@ def test_get_snapshot_rest_flattened():
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Snapshot.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.get_snapshot(**mock_args)
+ client.delete_snapshot(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
@@ -19286,7 +15869,7 @@ def test_get_snapshot_rest_flattened():
)
-def test_get_snapshot_rest_flattened_error(transport: str = "rest"):
+def test_delete_snapshot_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -19295,59 +15878,13 @@ def test_get_snapshot_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.get_snapshot(
- bigtable_table_admin.GetSnapshotRequest(),
+ client.delete_snapshot(
+ bigtable_table_admin.DeleteSnapshotRequest(),
name="name_value",
)
-def test_get_snapshot_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.ListSnapshotsRequest,
- dict,
- ],
-)
-def test_list_snapshots_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListSnapshotsResponse(
- next_page_token="next_page_token_value",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListSnapshotsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_snapshots(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, pagers.ListSnapshotsPager)
- assert response.next_page_token == "next_page_token_value"
-
-
-def test_list_snapshots_rest_use_cached_wrapped_rpc():
+def test_create_backup_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -19361,35 +15898,40 @@ def test_list_snapshots_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.list_snapshots in client._transport._wrapped_methods
+ assert client._transport.create_backup in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.list_snapshots] = mock_rpc
+ client._transport._wrapped_methods[client._transport.create_backup] = mock_rpc
request = {}
- client.list_snapshots(request)
+ client.create_backup(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.list_snapshots(request)
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.create_backup(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_list_snapshots_rest_required_fields(
- request_type=bigtable_table_admin.ListSnapshotsRequest,
+def test_create_backup_rest_required_fields(
+ request_type=bigtable_table_admin.CreateBackupRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
request_init["parent"] = ""
+ request_init["backup_id"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -19397,31 +15939,32 @@ def test_list_snapshots_rest_required_fields(
)
# verify fields with default values are dropped
+ assert "backupId" not in jsonified_request
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).list_snapshots._get_unset_required_fields(jsonified_request)
+ ).create_backup._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
+ assert "backupId" in jsonified_request
+ assert jsonified_request["backupId"] == request_init["backup_id"]
jsonified_request["parent"] = "parent_value"
+ jsonified_request["backupId"] = "backup_id_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).list_snapshots._get_unset_required_fields(jsonified_request)
+ ).create_backup._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(
- (
- "page_size",
- "page_token",
- )
- )
+ assert not set(unset_fields) - set(("backup_id",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "parent" in jsonified_request
assert jsonified_request["parent"] == "parent_value"
+ assert "backupId" in jsonified_request
+ assert jsonified_request["backupId"] == "backup_id_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -19430,7 +15973,7 @@ def test_list_snapshots_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListSnapshotsResponse()
+ return_value = operations_pb2.Operation(name="operations/spam")
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -19442,127 +15985,51 @@ def test_list_snapshots_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "get",
+ "method": "post",
"query_params": pb_request,
}
+ transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
-
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListSnapshotsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.list_snapshots(request)
+ response = client.create_backup(request)
- expected_params = [("$alt", "json;enum-encoding=int")]
+ expected_params = [
+ (
+ "backupId",
+ "",
+ ),
+ ("$alt", "json;enum-encoding=int"),
+ ]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_list_snapshots_rest_unset_required_fields():
+def test_create_backup_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.list_snapshots._get_unset_required_fields({})
+ unset_fields = transport.create_backup._get_unset_required_fields({})
assert set(unset_fields) == (
- set(
+ set(("backupId",))
+ & set(
(
- "pageSize",
- "pageToken",
+ "parent",
+ "backupId",
+ "backup",
)
)
- & set(("parent",))
- )
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_snapshots_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_list_snapshots"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_list_snapshots"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.ListSnapshotsRequest.pb(
- bigtable_table_admin.ListSnapshotsRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable_table_admin.ListSnapshotsResponse.to_json(
- bigtable_table_admin.ListSnapshotsResponse()
- )
-
- request = bigtable_table_admin.ListSnapshotsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_table_admin.ListSnapshotsResponse()
-
- client.list_snapshots(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_snapshots_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.ListSnapshotsRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_snapshots(request)
-
-def test_list_snapshots_rest_flattened():
+def test_create_backup_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -19571,7 +16038,7 @@ def test_list_snapshots_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListSnapshotsResponse()
+ return_value = operations_pb2.Operation(name="operations/spam")
# get arguments that satisfy an http rule for this method
sample_request = {
@@ -19581,32 +16048,32 @@ def test_list_snapshots_rest_flattened():
# get truthy value for each flattened field
mock_args = dict(
parent="parent_value",
+ backup_id="backup_id_value",
+ backup=table.Backup(name="name_value"),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListSnapshotsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.list_snapshots(**mock_args)
+ client.create_backup(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{parent=projects/*/instances/*/clusters/*}/snapshots"
+ "%s/v2/{parent=projects/*/instances/*/clusters/*}/backups"
% client.transport._host,
args[1],
)
-def test_list_snapshots_rest_flattened_error(transport: str = "rest"):
+def test_create_backup_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -19615,115 +16082,15 @@ def test_list_snapshots_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.list_snapshots(
- bigtable_table_admin.ListSnapshotsRequest(),
+ client.create_backup(
+ bigtable_table_admin.CreateBackupRequest(),
parent="parent_value",
+ backup_id="backup_id_value",
+ backup=table.Backup(name="name_value"),
)
-def test_list_snapshots_rest_pager(transport: str = "rest"):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # TODO(kbandes): remove this mock unless there's a good reason for it.
- # with mock.patch.object(path_template, 'transcode') as transcode:
- # Set the response as a series of pages
- response = (
- bigtable_table_admin.ListSnapshotsResponse(
- snapshots=[
- table.Snapshot(),
- table.Snapshot(),
- table.Snapshot(),
- ],
- next_page_token="abc",
- ),
- bigtable_table_admin.ListSnapshotsResponse(
- snapshots=[],
- next_page_token="def",
- ),
- bigtable_table_admin.ListSnapshotsResponse(
- snapshots=[
- table.Snapshot(),
- ],
- next_page_token="ghi",
- ),
- bigtable_table_admin.ListSnapshotsResponse(
- snapshots=[
- table.Snapshot(),
- table.Snapshot(),
- ],
- ),
- )
- # Two responses for two calls
- response = response + response
-
- # Wrap the values into proper Response objs
- response = tuple(
- bigtable_table_admin.ListSnapshotsResponse.to_json(x) for x in response
- )
- return_values = tuple(Response() for i in response)
- for return_val, response_val in zip(return_values, response):
- return_val._content = response_val.encode("UTF-8")
- return_val.status_code = 200
- req.side_effect = return_values
-
- sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
- }
-
- pager = client.list_snapshots(request=sample_request)
-
- results = list(pager)
- assert len(results) == 6
- assert all(isinstance(i, table.Snapshot) for i in results)
-
- pages = list(client.list_snapshots(request=sample_request).pages)
- for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
- assert page_.raw_page.next_page_token == token
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.DeleteSnapshotRequest,
- dict,
- ],
-)
-def test_delete_snapshot_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_snapshot(request)
-
- # Establish that the response is the type that we expect.
- assert response is None
-
-
-def test_delete_snapshot_rest_use_cached_wrapped_rpc():
+def test_get_backup_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -19737,30 +16104,30 @@ def test_delete_snapshot_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.delete_snapshot in client._transport._wrapped_methods
+ assert client._transport.get_backup in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.delete_snapshot] = mock_rpc
+ client._transport._wrapped_methods[client._transport.get_backup] = mock_rpc
request = {}
- client.delete_snapshot(request)
+ client.get_backup(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.delete_snapshot(request)
+ client.get_backup(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_delete_snapshot_rest_required_fields(
- request_type=bigtable_table_admin.DeleteSnapshotRequest,
+def test_get_backup_rest_required_fields(
+ request_type=bigtable_table_admin.GetBackupRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
@@ -19776,7 +16143,7 @@ def test_delete_snapshot_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_snapshot._get_unset_required_fields(jsonified_request)
+ ).get_backup._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
@@ -19785,7 +16152,7 @@ def test_delete_snapshot_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_snapshot._get_unset_required_fields(jsonified_request)
+ ).get_backup._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
@@ -19799,7 +16166,7 @@ def test_delete_snapshot_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = table.Backup()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -19811,110 +16178,38 @@ def test_delete_snapshot_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "delete",
+ "method": "get",
"query_params": pb_request,
}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+
+ # Convert return value to protobuf type
+ return_value = table.Backup.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.delete_snapshot(request)
+ response = client.get_backup(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_delete_snapshot_rest_unset_required_fields():
+def test_get_backup_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.delete_snapshot._get_unset_required_fields({})
+ unset_fields = transport.get_backup._get_unset_required_fields({})
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_snapshot_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_delete_snapshot"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_table_admin.DeleteSnapshotRequest.pb(
- bigtable_table_admin.DeleteSnapshotRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
-
- request = bigtable_table_admin.DeleteSnapshotRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
-
- client.delete_snapshot(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
-
-
-def test_delete_snapshot_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.DeleteSnapshotRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_snapshot(request)
-
-
-def test_delete_snapshot_rest_flattened():
+def test_get_backup_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -19923,11 +16218,11 @@ def test_delete_snapshot_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = table.Backup()
# get arguments that satisfy an http rule for this method
sample_request = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
}
# get truthy value for each flattened field
@@ -19939,24 +16234,26 @@ def test_delete_snapshot_rest_flattened():
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+ # Convert return value to protobuf type
+ return_value = table.Backup.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.delete_snapshot(**mock_args)
+ client.get_backup(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/clusters/*/snapshots/*}"
+ "%s/v2/{name=projects/*/instances/*/clusters/*/backups/*}"
% client.transport._host,
args[1],
)
-def test_delete_snapshot_rest_flattened_error(transport: str = "rest"):
+def test_get_backup_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -19965,194 +16262,54 @@ def test_delete_snapshot_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.delete_snapshot(
- bigtable_table_admin.DeleteSnapshotRequest(),
+ client.get_backup(
+ bigtable_table_admin.GetBackupRequest(),
name="name_value",
)
-def test_delete_snapshot_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+def test_update_backup_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.CreateBackupRequest,
- dict,
- ],
-)
-def test_create_backup_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request_init["backup"] = {
- "name": "name_value",
- "source_table": "source_table_value",
- "source_backup": "source_backup_value",
- "expire_time": {"seconds": 751, "nanos": 543},
- "start_time": {},
- "end_time": {},
- "size_bytes": 1089,
- "state": 1,
- "encryption_info": {
- "encryption_type": 1,
- "encryption_status": {
- "code": 411,
- "message": "message_value",
- "details": [
- {
- "type_url": "type.googleapis.com/google.protobuf.Duration",
- "value": b"\x08\x0c\x10\xdb\x07",
- }
- ],
- },
- "kms_key_version": "kms_key_version_value",
- },
- "backup_type": 1,
- "hot_to_standard_time": {},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
-
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_table_admin.CreateBackupRequest.meta.fields["backup"]
-
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
-
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["backup"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["backup"][field])):
- del request_init["backup"][field][i][subfield]
- else:
- del request_init["backup"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.create_backup(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-
-
-def test_create_backup_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.create_backup in client._transport._wrapped_methods
+ assert client._transport.update_backup in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.create_backup] = mock_rpc
+ client._transport._wrapped_methods[client._transport.update_backup] = mock_rpc
request = {}
- client.create_backup(request)
+ client.update_backup(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.create_backup(request)
+ client.update_backup(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_create_backup_rest_required_fields(
- request_type=bigtable_table_admin.CreateBackupRequest,
+def test_update_backup_rest_required_fields(
+ request_type=bigtable_table_admin.UpdateBackupRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["parent"] = ""
- request_init["backup_id"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -20160,32 +16317,22 @@ def test_create_backup_rest_required_fields(
)
# verify fields with default values are dropped
- assert "backupId" not in jsonified_request
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).create_backup._get_unset_required_fields(jsonified_request)
+ ).update_backup._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- assert "backupId" in jsonified_request
- assert jsonified_request["backupId"] == request_init["backup_id"]
-
- jsonified_request["parent"] = "parent_value"
- jsonified_request["backupId"] = "backup_id_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).create_backup._get_unset_required_fields(jsonified_request)
+ ).update_backup._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(("backup_id",))
+ assert not set(unset_fields) - set(("update_mask",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "parent" in jsonified_request
- assert jsonified_request["parent"] == "parent_value"
- assert "backupId" in jsonified_request
- assert jsonified_request["backupId"] == "backup_id_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -20194,7 +16341,7 @@ def test_create_backup_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = table.Backup()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -20206,7 +16353,7 @@ def test_create_backup_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "post",
+ "method": "patch",
"query_params": pb_request,
}
transcode_result["body"] = pb_request
@@ -20214,170 +16361,86 @@ def test_create_backup_rest_required_fields(
response_value = Response()
response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.Backup.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.create_backup(request)
+ response = client.update_backup(request)
- expected_params = [
- (
- "backupId",
- "",
- ),
- ("$alt", "json;enum-encoding=int"),
- ]
+ expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_create_backup_rest_unset_required_fields():
+def test_update_backup_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.create_backup._get_unset_required_fields({})
+ unset_fields = transport.update_backup._get_unset_required_fields({})
assert set(unset_fields) == (
- set(("backupId",))
+ set(("updateMask",))
& set(
(
- "parent",
- "backupId",
"backup",
+ "updateMask",
)
)
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_create_backup_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_update_backup_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_create_backup"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_create_backup"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.CreateBackupRequest.pb(
- bigtable_table_admin.CreateBackupRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.Backup()
- request = bigtable_table_admin.CreateBackupRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "backup": {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ }
- client.create_backup(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ # get truthy value for each flattened field
+ mock_args = dict(
+ backup=table.Backup(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
)
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_create_backup_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.CreateBackupRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.create_backup(request)
-
-
-def test_create_backup_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- parent="parent_value",
- backup_id="backup_id_value",
- backup=table.Backup(name="name_value"),
- )
- mock_args.update(sample_request)
+ mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
+ # Convert return value to protobuf type
+ return_value = table.Backup.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.create_backup(**mock_args)
+ client.update_backup(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{parent=projects/*/instances/*/clusters/*}/backups"
+ "%s/v2/{backup.name=projects/*/instances/*/clusters/*/backups/*}"
% client.transport._host,
args[1],
)
-def test_create_backup_rest_flattened_error(transport: str = "rest"):
+def test_update_backup_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -20386,73 +16449,14 @@ def test_create_backup_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.create_backup(
- bigtable_table_admin.CreateBackupRequest(),
- parent="parent_value",
- backup_id="backup_id_value",
+ client.update_backup(
+ bigtable_table_admin.UpdateBackupRequest(),
backup=table.Backup(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
)
-def test_create_backup_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.GetBackupRequest,
- dict,
- ],
-)
-def test_get_backup_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Backup(
- name="name_value",
- source_table="source_table_value",
- source_backup="source_backup_value",
- size_bytes=1089,
- state=table.Backup.State.CREATING,
- backup_type=table.Backup.BackupType.STANDARD,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Backup.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_backup(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, table.Backup)
- assert response.name == "name_value"
- assert response.source_table == "source_table_value"
- assert response.source_backup == "source_backup_value"
- assert response.size_bytes == 1089
- assert response.state == table.Backup.State.CREATING
- assert response.backup_type == table.Backup.BackupType.STANDARD
-
-
-def test_get_backup_rest_use_cached_wrapped_rpc():
+def test_delete_backup_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -20466,30 +16470,30 @@ def test_get_backup_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.get_backup in client._transport._wrapped_methods
+ assert client._transport.delete_backup in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.get_backup] = mock_rpc
+ client._transport._wrapped_methods[client._transport.delete_backup] = mock_rpc
request = {}
- client.get_backup(request)
+ client.delete_backup(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.get_backup(request)
+ client.delete_backup(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_get_backup_rest_required_fields(
- request_type=bigtable_table_admin.GetBackupRequest,
+def test_delete_backup_rest_required_fields(
+ request_type=bigtable_table_admin.DeleteBackupRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
@@ -20505,7 +16509,7 @@ def test_get_backup_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).get_backup._get_unset_required_fields(jsonified_request)
+ ).delete_backup._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
@@ -20514,7 +16518,7 @@ def test_get_backup_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).get_backup._get_unset_required_fields(jsonified_request)
+ ).delete_backup._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
@@ -20528,7 +16532,7 @@ def test_get_backup_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = table.Backup()
+ return_value = None
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -20540,119 +16544,35 @@ def test_get_backup_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "get",
+ "method": "delete",
"query_params": pb_request,
}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
-
- # Convert return value to protobuf type
- return_value = table.Backup.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.get_backup(request)
+ response = client.delete_backup(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_get_backup_rest_unset_required_fields():
+def test_delete_backup_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.get_backup._get_unset_required_fields({})
+ unset_fields = transport.delete_backup._get_unset_required_fields({})
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_get_backup_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_get_backup"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_get_backup"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.GetBackupRequest.pb(
- bigtable_table_admin.GetBackupRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = table.Backup.to_json(table.Backup())
-
- request = bigtable_table_admin.GetBackupRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = table.Backup()
-
- client.get_backup(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_get_backup_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.GetBackupRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_backup(request)
-
-
-def test_get_backup_rest_flattened():
+def test_delete_backup_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -20661,7 +16581,7 @@ def test_get_backup_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = table.Backup()
+ return_value = None
# get arguments that satisfy an http rule for this method
sample_request = {
@@ -20677,13 +16597,11 @@ def test_get_backup_rest_flattened():
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Backup.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = ""
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.get_backup(**mock_args)
+ client.delete_backup(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
@@ -20696,7 +16614,7 @@ def test_get_backup_rest_flattened():
)
-def test_get_backup_rest_flattened_error(transport: str = "rest"):
+def test_delete_backup_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -20705,207 +16623,55 @@ def test_get_backup_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.get_backup(
- bigtable_table_admin.GetBackupRequest(),
+ client.delete_backup(
+ bigtable_table_admin.DeleteBackupRequest(),
name="name_value",
)
-def test_get_backup_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.UpdateBackupRequest,
- dict,
- ],
-)
-def test_update_backup_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "backup": {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
- }
- request_init["backup"] = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4",
- "source_table": "source_table_value",
- "source_backup": "source_backup_value",
- "expire_time": {"seconds": 751, "nanos": 543},
- "start_time": {},
- "end_time": {},
- "size_bytes": 1089,
- "state": 1,
- "encryption_info": {
- "encryption_type": 1,
- "encryption_status": {
- "code": 411,
- "message": "message_value",
- "details": [
- {
- "type_url": "type.googleapis.com/google.protobuf.Duration",
- "value": b"\x08\x0c\x10\xdb\x07",
- }
- ],
- },
- "kms_key_version": "kms_key_version_value",
- },
- "backup_type": 1,
- "hot_to_standard_time": {},
- }
- # The version of a generated dependency at test runtime may differ from the version used during generation.
- # Delete any fields which are not present in the current runtime dependency
- # See https://github.com/googleapis/gapic-generator-python/issues/1748
-
- # Determine if the message type is proto-plus or protobuf
- test_field = bigtable_table_admin.UpdateBackupRequest.meta.fields["backup"]
-
- def get_message_fields(field):
- # Given a field which is a message (composite type), return a list with
- # all the fields of the message.
- # If the field is not a composite type, return an empty list.
- message_fields = []
-
- if hasattr(field, "message") and field.message:
- is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
-
- if is_field_type_proto_plus_type:
- message_fields = field.message.meta.fields.values()
- # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
- else: # pragma: NO COVER
- message_fields = field.message.DESCRIPTOR.fields
- return message_fields
-
- runtime_nested_fields = [
- (field.name, nested_field.name)
- for field in get_message_fields(test_field)
- for nested_field in get_message_fields(field)
- ]
-
- subfields_not_in_runtime = []
-
- # For each item in the sample request, create a list of sub fields which are not present at runtime
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for field, value in request_init["backup"].items(): # pragma: NO COVER
- result = None
- is_repeated = False
- # For repeated fields
- if isinstance(value, list) and len(value):
- is_repeated = True
- result = value[0]
- # For fields where the type is another message
- if isinstance(value, dict):
- result = value
-
- if result and hasattr(result, "keys"):
- for subfield in result.keys():
- if (field, subfield) not in runtime_nested_fields:
- subfields_not_in_runtime.append(
- {
- "field": field,
- "subfield": subfield,
- "is_repeated": is_repeated,
- }
- )
-
- # Remove fields from the sample request which are not present in the runtime version of the dependency
- # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
- for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
- field = subfield_to_delete.get("field")
- field_repeated = subfield_to_delete.get("is_repeated")
- subfield = subfield_to_delete.get("subfield")
- if subfield:
- if field_repeated:
- for i in range(0, len(request_init["backup"][field])):
- del request_init["backup"][field][i][subfield]
- else:
- del request_init["backup"][field][subfield]
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Backup(
- name="name_value",
- source_table="source_table_value",
- source_backup="source_backup_value",
- size_bytes=1089,
- state=table.Backup.State.CREATING,
- backup_type=table.Backup.BackupType.STANDARD,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = table.Backup.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.update_backup(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, table.Backup)
- assert response.name == "name_value"
- assert response.source_table == "source_table_value"
- assert response.source_backup == "source_backup_value"
- assert response.size_bytes == 1089
- assert response.state == table.Backup.State.CREATING
- assert response.backup_type == table.Backup.BackupType.STANDARD
-
-
-def test_update_backup_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+def test_list_backups_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
# Should wrap all calls on client creation
assert wrapper_fn.call_count > 0
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.update_backup in client._transport._wrapped_methods
+ assert client._transport.list_backups in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.update_backup] = mock_rpc
+ client._transport._wrapped_methods[client._transport.list_backups] = mock_rpc
request = {}
- client.update_backup(request)
+ client.list_backups(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.update_backup(request)
+ client.list_backups(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_update_backup_rest_required_fields(
- request_type=bigtable_table_admin.UpdateBackupRequest,
+def test_list_backups_rest_required_fields(
+ request_type=bigtable_table_admin.ListBackupsRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
+ request_init["parent"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -20916,19 +16682,30 @@ def test_update_backup_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).update_backup._get_unset_required_fields(jsonified_request)
+ ).list_backups._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
+ jsonified_request["parent"] = "parent_value"
+
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).update_backup._get_unset_required_fields(jsonified_request)
+ ).list_backups._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(("update_mask",))
+ assert not set(unset_fields) - set(
+ (
+ "filter",
+ "order_by",
+ "page_size",
+ "page_token",
+ )
+ )
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
+ assert "parent" in jsonified_request
+ assert jsonified_request["parent"] == "parent_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -20937,7 +16714,7 @@ def test_update_backup_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = table.Backup()
+ return_value = bigtable_table_admin.ListBackupsResponse()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -20949,151 +16726,66 @@ def test_update_backup_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "patch",
+ "method": "get",
"query_params": pb_request,
}
- transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = table.Backup.pb(return_value)
+ return_value = bigtable_table_admin.ListBackupsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.update_backup(request)
+ response = client.list_backups(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_update_backup_rest_unset_required_fields():
+def test_list_backups_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.update_backup._get_unset_required_fields({})
+ unset_fields = transport.list_backups._get_unset_required_fields({})
assert set(unset_fields) == (
- set(("updateMask",))
- & set(
+ set(
(
- "backup",
- "updateMask",
+ "filter",
+ "orderBy",
+ "pageSize",
+ "pageToken",
)
)
+ & set(("parent",))
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_update_backup_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_list_backups_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_update_backup"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_update_backup"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.UpdateBackupRequest.pb(
- bigtable_table_admin.UpdateBackupRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = table.Backup.to_json(table.Backup())
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.ListBackupsResponse()
- request = bigtable_table_admin.UpdateBackupRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = table.Backup()
-
- client.update_backup(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_update_backup_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.UpdateBackupRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {
- "backup": {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
- }
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.update_backup(request)
-
-
-def test_update_backup_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = table.Backup()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "backup": {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
- }
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
+ }
# get truthy value for each flattened field
mock_args = dict(
- backup=table.Backup(name="name_value"),
- update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ parent="parent_value",
)
mock_args.update(sample_request)
@@ -21101,25 +16793,25 @@ def test_update_backup_rest_flattened():
response_value = Response()
response_value.status_code = 200
# Convert return value to protobuf type
- return_value = table.Backup.pb(return_value)
+ return_value = bigtable_table_admin.ListBackupsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.update_backup(**mock_args)
+ client.list_backups(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{backup.name=projects/*/instances/*/clusters/*/backups/*}"
+ "%s/v2/{parent=projects/*/instances/*/clusters/*}/backups"
% client.transport._host,
args[1],
)
-def test_update_backup_rest_flattened_error(transport: str = "rest"):
+def test_list_backups_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -21128,57 +16820,78 @@ def test_update_backup_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.update_backup(
- bigtable_table_admin.UpdateBackupRequest(),
- backup=table.Backup(name="name_value"),
- update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ client.list_backups(
+ bigtable_table_admin.ListBackupsRequest(),
+ parent="parent_value",
)
-def test_update_backup_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.DeleteBackupRequest,
- dict,
- ],
-)
-def test_delete_backup_rest(request_type):
+def test_list_backups_rest_pager(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
- request = request_type(**request_init)
-
# Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = None
+ with mock.patch.object(Session, "request") as req:
+ # TODO(kbandes): remove this mock unless there's a good reason for it.
+ # with mock.patch.object(path_template, 'transcode') as transcode:
+ # Set the response as a series of pages
+ response = (
+ bigtable_table_admin.ListBackupsResponse(
+ backups=[
+ table.Backup(),
+ table.Backup(),
+ table.Backup(),
+ ],
+ next_page_token="abc",
+ ),
+ bigtable_table_admin.ListBackupsResponse(
+ backups=[],
+ next_page_token="def",
+ ),
+ bigtable_table_admin.ListBackupsResponse(
+ backups=[
+ table.Backup(),
+ ],
+ next_page_token="ghi",
+ ),
+ bigtable_table_admin.ListBackupsResponse(
+ backups=[
+ table.Backup(),
+ table.Backup(),
+ ],
+ ),
+ )
+ # Two responses for two calls
+ response = response + response
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = ""
+ # Wrap the values into proper Response objs
+ response = tuple(
+ bigtable_table_admin.ListBackupsResponse.to_json(x) for x in response
+ )
+ return_values = tuple(Response() for i in response)
+ for return_val, response_val in zip(return_values, response):
+ return_val._content = response_val.encode("UTF-8")
+ return_val.status_code = 200
+ req.side_effect = return_values
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.delete_backup(request)
+ sample_request = {
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
+ }
- # Establish that the response is the type that we expect.
- assert response is None
+ pager = client.list_backups(request=sample_request)
+
+ results = list(pager)
+ assert len(results) == 6
+ assert all(isinstance(i, table.Backup) for i in results)
+
+ pages = list(client.list_backups(request=sample_request).pages)
+ for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
+ assert page_.raw_page.next_page_token == token
-def test_delete_backup_rest_use_cached_wrapped_rpc():
+def test_restore_table_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -21192,35 +16905,40 @@ def test_delete_backup_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.delete_backup in client._transport._wrapped_methods
+ assert client._transport.restore_table in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.delete_backup] = mock_rpc
+ client._transport._wrapped_methods[client._transport.restore_table] = mock_rpc
request = {}
- client.delete_backup(request)
+ client.restore_table(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.delete_backup(request)
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.restore_table(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_delete_backup_rest_required_fields(
- request_type=bigtable_table_admin.DeleteBackupRequest,
+def test_restore_table_rest_required_fields(
+ request_type=bigtable_table_admin.RestoreTableRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["name"] = ""
+ request_init["parent"] = ""
+ request_init["table_id"] = ""
request = request_type(**request_init)
pb_request = request_type.pb(request)
jsonified_request = json.loads(
@@ -21231,21 +16949,24 @@ def test_delete_backup_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_backup._get_unset_required_fields(jsonified_request)
+ ).restore_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["name"] = "name_value"
+ jsonified_request["parent"] = "parent_value"
+ jsonified_request["tableId"] = "table_id_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).delete_backup._get_unset_required_fields(jsonified_request)
+ ).restore_table._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "name" in jsonified_request
- assert jsonified_request["name"] == "name_value"
+ assert "parent" in jsonified_request
+ assert jsonified_request["parent"] == "parent_value"
+ assert "tableId" in jsonified_request
+ assert jsonified_request["tableId"] == "table_id_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -21254,7 +16975,7 @@ def test_delete_backup_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = operations_pb2.Operation(name="operations/spam")
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -21266,110 +16987,183 @@ def test_delete_backup_rest_required_fields(
pb_request = request_type.pb(request)
transcode_result = {
"uri": "v1/sample_method",
- "method": "delete",
+ "method": "post",
"query_params": pb_request,
}
+ transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.delete_backup(request)
+ response = client.restore_table(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_delete_backup_rest_unset_required_fields():
+def test_restore_table_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.delete_backup._get_unset_required_fields({})
- assert set(unset_fields) == (set(()) & set(("name",)))
+ unset_fields = transport.restore_table._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(())
+ & set(
+ (
+ "parent",
+ "tableId",
+ )
+ )
+ )
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_delete_backup_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_delete_backup"
- ) as pre:
- pre.assert_not_called()
- pb_message = bigtable_table_admin.DeleteBackupRequest.pb(
- bigtable_table_admin.DeleteBackupRequest()
+def test_copy_backup_rest_use_cached_wrapped_rpc():
+ # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
+ # instead of constructing them on each call
+ with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
+ # Should wrap all calls on client creation
+ assert wrapper_fn.call_count > 0
+ wrapper_fn.reset_mock()
- request = bigtable_table_admin.DeleteBackupRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
+ # Ensure method has been cached
+ assert client._transport.copy_backup in client._transport._wrapped_methods
- client.delete_backup(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ # Replace cached wrapped function with mock
+ mock_rpc = mock.Mock()
+ mock_rpc.return_value.name = (
+ "foo" # operation_request.operation in compute client(s) expect a string.
)
+ client._transport._wrapped_methods[client._transport.copy_backup] = mock_rpc
- pre.assert_called_once()
+ request = {}
+ client.copy_backup(request)
+ # Establish that the underlying gRPC stub method was called.
+ assert mock_rpc.call_count == 1
-def test_delete_backup_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.DeleteBackupRequest
+ # Operation methods build a cached wrapper on first rpc call
+ # subsequent calls should use the cached wrapper
+ wrapper_fn.reset_mock()
+
+ client.copy_backup(request)
+
+ # Establish that a new wrapper was not created for this call
+ assert wrapper_fn.call_count == 0
+ assert mock_rpc.call_count == 2
+
+
+def test_copy_backup_rest_required_fields(
+ request_type=bigtable_table_admin.CopyBackupRequest,
):
+ transport_class = transports.BigtableTableAdminRestTransport
+
+ request_init = {}
+ request_init["parent"] = ""
+ request_init["backup_id"] = ""
+ request_init["source_backup"] = ""
+ request = request_type(**request_init)
+ pb_request = request_type.pb(request)
+ jsonified_request = json.loads(
+ json_format.MessageToJson(pb_request, use_integers_for_enums=False)
+ )
+
+ # verify fields with default values are dropped
+
+ unset_fields = transport_class(
+ credentials=ga_credentials.AnonymousCredentials()
+ ).copy_backup._get_unset_required_fields(jsonified_request)
+ jsonified_request.update(unset_fields)
+
+ # verify required fields with default values are now present
+
+ jsonified_request["parent"] = "parent_value"
+ jsonified_request["backupId"] = "backup_id_value"
+ jsonified_request["sourceBackup"] = "source_backup_value"
+
+ unset_fields = transport_class(
+ credentials=ga_credentials.AnonymousCredentials()
+ ).copy_backup._get_unset_required_fields(jsonified_request)
+ jsonified_request.update(unset_fields)
+
+ # verify required fields with non-default values are left alone
+ assert "parent" in jsonified_request
+ assert jsonified_request["parent"] == "parent_value"
+ assert "backupId" in jsonified_request
+ assert jsonified_request["backupId"] == "backup_id_value"
+ assert "sourceBackup" in jsonified_request
+ assert jsonified_request["sourceBackup"] == "source_backup_value"
+
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
-
- # send a request that will satisfy transcoding
- request_init = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
- }
request = request_type(**request_init)
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.delete_backup(request)
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(Session, "request") as req:
+ # We need to mock transcode() because providing default values
+ # for required fields will fail the real version if the http_options
+ # expect actual values for those fields.
+ with mock.patch.object(path_template, "transcode") as transcode:
+ # A uri without fields and an empty body will force all the
+ # request fields to show up in the query_params.
+ pb_request = request_type.pb(request)
+ transcode_result = {
+ "uri": "v1/sample_method",
+ "method": "post",
+ "query_params": pb_request,
+ }
+ transcode_result["body"] = pb_request
+ transcode.return_value = transcode_result
+ response_value = Response()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
-def test_delete_backup_rest_flattened():
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+
+ response = client.copy_backup(request)
+
+ expected_params = [("$alt", "json;enum-encoding=int")]
+ actual_params = req.call_args.kwargs["params"]
+ assert expected_params == actual_params
+
+
+def test_copy_backup_rest_unset_required_fields():
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials
+ )
+
+ unset_fields = transport.copy_backup._get_unset_required_fields({})
+ assert set(unset_fields) == (
+ set(())
+ & set(
+ (
+ "parent",
+ "backupId",
+ "sourceBackup",
+ "expireTime",
+ )
+ )
+ )
+
+
+def test_copy_backup_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -21378,40 +17172,43 @@ def test_delete_backup_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = None
+ return_value = operations_pb2.Operation(name="operations/spam")
# get arguments that satisfy an http rule for this method
sample_request = {
- "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ "parent": "projects/sample1/instances/sample2/clusters/sample3"
}
# get truthy value for each flattened field
mock_args = dict(
- name="name_value",
+ parent="parent_value",
+ backup_id="backup_id_value",
+ source_backup="source_backup_value",
+ expire_time=timestamp_pb2.Timestamp(seconds=751),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- json_return_value = ""
+ json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.delete_backup(**mock_args)
+ client.copy_backup(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{name=projects/*/instances/*/clusters/*/backups/*}"
+ "%s/v2/{parent=projects/*/instances/*/clusters/*}/backups:copy"
% client.transport._host,
args[1],
)
-def test_delete_backup_rest_flattened_error(transport: str = "rest"):
+def test_copy_backup_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -21420,59 +17217,16 @@ def test_delete_backup_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.delete_backup(
- bigtable_table_admin.DeleteBackupRequest(),
- name="name_value",
- )
-
-
-def test_delete_backup_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.ListBackupsRequest,
- dict,
- ],
-)
-def test_list_backups_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListBackupsResponse(
- next_page_token="next_page_token_value",
+ client.copy_backup(
+ bigtable_table_admin.CopyBackupRequest(),
+ parent="parent_value",
+ backup_id="backup_id_value",
+ source_backup="source_backup_value",
+ expire_time=timestamp_pb2.Timestamp(seconds=751),
)
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListBackupsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.list_backups(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, pagers.ListBackupsPager)
- assert response.next_page_token == "next_page_token_value"
-
-def test_list_backups_rest_use_cached_wrapped_rpc():
+def test_get_iam_policy_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -21486,37 +17240,37 @@ def test_list_backups_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.list_backups in client._transport._wrapped_methods
+ assert client._transport.get_iam_policy in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.list_backups] = mock_rpc
+ client._transport._wrapped_methods[client._transport.get_iam_policy] = mock_rpc
request = {}
- client.list_backups(request)
+ client.get_iam_policy(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- client.list_backups(request)
+ client.get_iam_policy(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_list_backups_rest_required_fields(
- request_type=bigtable_table_admin.ListBackupsRequest,
+def test_get_iam_policy_rest_required_fields(
+ request_type=iam_policy_pb2.GetIamPolicyRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["parent"] = ""
+ request_init["resource"] = ""
request = request_type(**request_init)
- pb_request = request_type.pb(request)
+ pb_request = request
jsonified_request = json.loads(
json_format.MessageToJson(pb_request, use_integers_for_enums=False)
)
@@ -21525,30 +17279,21 @@ def test_list_backups_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).list_backups._get_unset_required_fields(jsonified_request)
+ ).get_iam_policy._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["parent"] = "parent_value"
+ jsonified_request["resource"] = "resource_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).list_backups._get_unset_required_fields(jsonified_request)
- # Check that path parameters and body parameters are not mixing in.
- assert not set(unset_fields) - set(
- (
- "filter",
- "order_by",
- "page_size",
- "page_token",
- )
- )
+ ).get_iam_policy._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "parent" in jsonified_request
- assert jsonified_request["parent"] == "parent_value"
+ assert "resource" in jsonified_request
+ assert jsonified_request["resource"] == "resource_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -21557,7 +17302,7 @@ def test_list_backups_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListBackupsResponse()
+ return_value = policy_pb2.Policy()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -21566,132 +17311,40 @@ def test_list_backups_rest_required_fields(
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
- pb_request = request_type.pb(request)
+ pb_request = request
transcode_result = {
"uri": "v1/sample_method",
- "method": "get",
+ "method": "post",
"query_params": pb_request,
}
+ transcode_result["body"] = pb_request
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListBackupsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.list_backups(request)
+ response = client.get_iam_policy(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_list_backups_rest_unset_required_fields():
+def test_get_iam_policy_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.list_backups._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(
- (
- "filter",
- "orderBy",
- "pageSize",
- "pageToken",
- )
- )
- & set(("parent",))
- )
-
-
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_list_backups_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
- )
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_list_backups"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_list_backups"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.ListBackupsRequest.pb(
- bigtable_table_admin.ListBackupsRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable_table_admin.ListBackupsResponse.to_json(
- bigtable_table_admin.ListBackupsResponse()
- )
-
- request = bigtable_table_admin.ListBackupsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable_table_admin.ListBackupsResponse()
-
- client.list_backups(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_list_backups_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.ListBackupsRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.list_backups(request)
+ unset_fields = transport.get_iam_policy._get_unset_required_fields({})
+ assert set(unset_fields) == (set(()) & set(("resource",)))
-def test_list_backups_rest_flattened():
+def test_get_iam_policy_rest_flattened():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
@@ -21700,42 +17353,40 @@ def test_list_backups_rest_flattened():
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = bigtable_table_admin.ListBackupsResponse()
+ return_value = policy_pb2.Policy()
# get arguments that satisfy an http rule for this method
sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
+ "resource": "projects/sample1/instances/sample2/tables/sample3"
}
# get truthy value for each flattened field
mock_args = dict(
- parent="parent_value",
+ resource="resource_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable_table_admin.ListBackupsResponse.pb(return_value)
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.list_backups(**mock_args)
+ client.get_iam_policy(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{parent=projects/*/instances/*/clusters/*}/backups"
+ "%s/v2/{resource=projects/*/instances/*/tables/*}:getIamPolicy"
% client.transport._host,
args[1],
)
-def test_list_backups_rest_flattened_error(transport: str = "rest"):
+def test_get_iam_policy_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -21744,113 +17395,13 @@ def test_list_backups_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.list_backups(
- bigtable_table_admin.ListBackupsRequest(),
- parent="parent_value",
- )
-
-
-def test_list_backups_rest_pager(transport: str = "rest"):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # TODO(kbandes): remove this mock unless there's a good reason for it.
- # with mock.patch.object(path_template, 'transcode') as transcode:
- # Set the response as a series of pages
- response = (
- bigtable_table_admin.ListBackupsResponse(
- backups=[
- table.Backup(),
- table.Backup(),
- table.Backup(),
- ],
- next_page_token="abc",
- ),
- bigtable_table_admin.ListBackupsResponse(
- backups=[],
- next_page_token="def",
- ),
- bigtable_table_admin.ListBackupsResponse(
- backups=[
- table.Backup(),
- ],
- next_page_token="ghi",
- ),
- bigtable_table_admin.ListBackupsResponse(
- backups=[
- table.Backup(),
- table.Backup(),
- ],
- ),
- )
- # Two responses for two calls
- response = response + response
-
- # Wrap the values into proper Response objs
- response = tuple(
- bigtable_table_admin.ListBackupsResponse.to_json(x) for x in response
+ client.get_iam_policy(
+ iam_policy_pb2.GetIamPolicyRequest(),
+ resource="resource_value",
)
- return_values = tuple(Response() for i in response)
- for return_val, response_val in zip(return_values, response):
- return_val._content = response_val.encode("UTF-8")
- return_val.status_code = 200
- req.side_effect = return_values
-
- sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
- }
-
- pager = client.list_backups(request=sample_request)
-
- results = list(pager)
- assert len(results) == 6
- assert all(isinstance(i, table.Backup) for i in results)
-
- pages = list(client.list_backups(request=sample_request).pages)
- for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
- assert page_.raw_page.next_page_token == token
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.RestoreTableRequest,
- dict,
- ],
-)
-def test_restore_table_rest(request_type):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.restore_table(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
-def test_restore_table_rest_use_cached_wrapped_rpc():
+def test_set_iam_policy_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -21864,42 +17415,37 @@ def test_restore_table_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.restore_table in client._transport._wrapped_methods
+ assert client._transport.set_iam_policy in client._transport._wrapped_methods
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.restore_table] = mock_rpc
+ client._transport._wrapped_methods[client._transport.set_iam_policy] = mock_rpc
request = {}
- client.restore_table(request)
+ client.set_iam_policy(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.restore_table(request)
+ client.set_iam_policy(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_restore_table_rest_required_fields(
- request_type=bigtable_table_admin.RestoreTableRequest,
+def test_set_iam_policy_rest_required_fields(
+ request_type=iam_policy_pb2.SetIamPolicyRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["parent"] = ""
- request_init["table_id"] = ""
+ request_init["resource"] = ""
request = request_type(**request_init)
- pb_request = request_type.pb(request)
+ pb_request = request
jsonified_request = json.loads(
json_format.MessageToJson(pb_request, use_integers_for_enums=False)
)
@@ -21908,24 +17454,21 @@ def test_restore_table_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).restore_table._get_unset_required_fields(jsonified_request)
+ ).set_iam_policy._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["parent"] = "parent_value"
- jsonified_request["tableId"] = "table_id_value"
+ jsonified_request["resource"] = "resource_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).restore_table._get_unset_required_fields(jsonified_request)
+ ).set_iam_policy._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "parent" in jsonified_request
- assert jsonified_request["parent"] == "parent_value"
- assert "tableId" in jsonified_request
- assert jsonified_request["tableId"] == "table_id_value"
+ assert "resource" in jsonified_request
+ assert jsonified_request["resource"] == "resource_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -21934,7 +17477,7 @@ def test_restore_table_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = policy_pb2.Policy()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -21943,7 +17486,7 @@ def test_restore_table_rest_required_fields(
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
- pb_request = request_type.pb(request)
+ pb_request = request
transcode_result = {
"uri": "v1/sample_method",
"method": "post",
@@ -21954,160 +17497,94 @@ def test_restore_table_rest_required_fields(
response_value = Response()
response_value.status_code = 200
+
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.restore_table(request)
+ response = client.set_iam_policy(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_restore_table_rest_unset_required_fields():
+def test_set_iam_policy_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.restore_table._get_unset_required_fields({})
+ unset_fields = transport.set_iam_policy._get_unset_required_fields({})
assert set(unset_fields) == (
set(())
& set(
(
- "parent",
- "tableId",
+ "resource",
+ "policy",
)
)
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_restore_table_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_set_iam_policy_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_restore_table"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_restore_table"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.RestoreTableRequest.pb(
- bigtable_table_admin.RestoreTableRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
- )
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = policy_pb2.Policy()
- request = bigtable_table_admin.RestoreTableRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "resource": "projects/sample1/instances/sample2/tables/sample3"
+ }
- client.restore_table(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
+ # get truthy value for each flattened field
+ mock_args = dict(
+ resource="resource_value",
)
+ mock_args.update(sample_request)
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_restore_table_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.RestoreTableRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
# Wrap the value into a proper Response obj
response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.restore_table(request)
+ client.set_iam_policy(**mock_args)
-def test_restore_table_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(req.mock_calls) == 1
+ _, args, _ = req.mock_calls[0]
+ assert path_template.validate(
+ "%s/v2/{resource=projects/*/instances/*/tables/*}:setIamPolicy"
+ % client.transport._host,
+ args[1],
+ )
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable_table_admin.CopyBackupRequest,
- dict,
- ],
-)
-def test_copy_backup_rest(request_type):
+def test_set_iam_policy_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport=transport,
)
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.copy_backup(request)
-
- # Establish that the response is the type that we expect.
- assert response.operation.name == "operations/spam"
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.set_iam_policy(
+ iam_policy_pb2.SetIamPolicyRequest(),
+ resource="resource_value",
+ )
-def test_copy_backup_rest_use_cached_wrapped_rpc():
+def test_test_iam_permissions_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
@@ -22121,43 +17598,42 @@ def test_copy_backup_rest_use_cached_wrapped_rpc():
wrapper_fn.reset_mock()
# Ensure method has been cached
- assert client._transport.copy_backup in client._transport._wrapped_methods
+ assert (
+ client._transport.test_iam_permissions in client._transport._wrapped_methods
+ )
# Replace cached wrapped function with mock
mock_rpc = mock.Mock()
mock_rpc.return_value.name = (
"foo" # operation_request.operation in compute client(s) expect a string.
)
- client._transport._wrapped_methods[client._transport.copy_backup] = mock_rpc
+ client._transport._wrapped_methods[
+ client._transport.test_iam_permissions
+ ] = mock_rpc
request = {}
- client.copy_backup(request)
+ client.test_iam_permissions(request)
# Establish that the underlying gRPC stub method was called.
assert mock_rpc.call_count == 1
- # Operation methods build a cached wrapper on first rpc call
- # subsequent calls should use the cached wrapper
- wrapper_fn.reset_mock()
-
- client.copy_backup(request)
+ client.test_iam_permissions(request)
# Establish that a new wrapper was not created for this call
assert wrapper_fn.call_count == 0
assert mock_rpc.call_count == 2
-def test_copy_backup_rest_required_fields(
- request_type=bigtable_table_admin.CopyBackupRequest,
+def test_test_iam_permissions_rest_required_fields(
+ request_type=iam_policy_pb2.TestIamPermissionsRequest,
):
transport_class = transports.BigtableTableAdminRestTransport
request_init = {}
- request_init["parent"] = ""
- request_init["backup_id"] = ""
- request_init["source_backup"] = ""
+ request_init["resource"] = ""
+ request_init["permissions"] = ""
request = request_type(**request_init)
- pb_request = request_type.pb(request)
+ pb_request = request
jsonified_request = json.loads(
json_format.MessageToJson(pb_request, use_integers_for_enums=False)
)
@@ -22166,27 +17642,24 @@ def test_copy_backup_rest_required_fields(
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).copy_backup._get_unset_required_fields(jsonified_request)
+ ).test_iam_permissions._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
- jsonified_request["parent"] = "parent_value"
- jsonified_request["backupId"] = "backup_id_value"
- jsonified_request["sourceBackup"] = "source_backup_value"
+ jsonified_request["resource"] = "resource_value"
+ jsonified_request["permissions"] = "permissions_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
- ).copy_backup._get_unset_required_fields(jsonified_request)
+ ).test_iam_permissions._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
- assert "parent" in jsonified_request
- assert jsonified_request["parent"] == "parent_value"
- assert "backupId" in jsonified_request
- assert jsonified_request["backupId"] == "backup_id_value"
- assert "sourceBackup" in jsonified_request
- assert jsonified_request["sourceBackup"] == "source_backup_value"
+ assert "resource" in jsonified_request
+ assert jsonified_request["resource"] == "resource_value"
+ assert "permissions" in jsonified_request
+ assert jsonified_request["permissions"] == "permissions_value"
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -22195,7 +17668,7 @@ def test_copy_backup_rest_required_fields(
request = request_type(**request_init)
# Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
+ return_value = iam_policy_pb2.TestIamPermissionsResponse()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
@@ -22204,7 +17677,7 @@ def test_copy_backup_rest_required_fields(
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
- pb_request = request_type.pb(request)
+ pb_request = request
transcode_result = {
"uri": "v1/sample_method",
"method": "post",
@@ -22215,144 +17688,58 @@ def test_copy_backup_rest_required_fields(
response_value = Response()
response_value.status_code = 200
+
json_return_value = json_format.MessageToJson(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- response = client.copy_backup(request)
+ response = client.test_iam_permissions(request)
expected_params = [("$alt", "json;enum-encoding=int")]
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
-def test_copy_backup_rest_unset_required_fields():
+def test_test_iam_permissions_rest_unset_required_fields():
transport = transports.BigtableTableAdminRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
- unset_fields = transport.copy_backup._get_unset_required_fields({})
+ unset_fields = transport.test_iam_permissions._get_unset_required_fields({})
assert set(unset_fields) == (
set(())
& set(
(
- "parent",
- "backupId",
- "sourceBackup",
- "expireTime",
+ "resource",
+ "permissions",
)
)
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_copy_backup_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+def test_test_iam_permissions_rest_flattened():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- operation.Operation, "_set_result_from_operation"
- ), mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_copy_backup"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_copy_backup"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable_table_admin.CopyBackupRequest.pb(
- bigtable_table_admin.CopyBackupRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "resource": "projects/sample1/instances/sample2/tables/sample3"
}
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- operations_pb2.Operation()
+ # get truthy value for each flattened field
+ mock_args = dict(
+ resource="resource_value",
+ permissions=["permissions_value"],
)
-
- request = bigtable_table_admin.CopyBackupRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = operations_pb2.Operation()
-
- client.copy_backup(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_copy_backup_rest_bad_request(
- transport: str = "rest", request_type=bigtable_table_admin.CopyBackupRequest
-):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.copy_backup(request)
-
-
-def test_copy_backup_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = operations_pb2.Operation(name="operations/spam")
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "parent": "projects/sample1/instances/sample2/clusters/sample3"
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- parent="parent_value",
- backup_id="backup_id_value",
- source_backup="source_backup_value",
- expire_time=timestamp_pb2.Timestamp(seconds=751),
- )
- mock_args.update(sample_request)
+ mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
@@ -22361,20 +17748,20 @@ def test_copy_backup_rest_flattened():
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
- client.copy_backup(**mock_args)
+ client.test_iam_permissions(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
- "%s/v2/{parent=projects/*/instances/*/clusters/*}/backups:copy"
+ "%s/v2/{resource=projects/*/instances/*/tables/*}:testIamPermissions"
% client.transport._host,
args[1],
)
-def test_copy_backup_rest_flattened_error(transport: str = "rest"):
+def test_test_iam_permissions_rest_flattened_error(transport: str = "rest"):
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport=transport,
@@ -22383,177 +17770,5303 @@ def test_copy_backup_rest_flattened_error(transport: str = "rest"):
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
- client.copy_backup(
- bigtable_table_admin.CopyBackupRequest(),
- parent="parent_value",
- backup_id="backup_id_value",
- source_backup="source_backup_value",
- expire_time=timestamp_pb2.Timestamp(seconds=751),
+ client.test_iam_permissions(
+ iam_policy_pb2.TestIamPermissionsRequest(),
+ resource="resource_value",
+ permissions=["permissions_value"],
)
-def test_copy_backup_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+def test_credentials_transport_error():
+ # It is an error to provide credentials and a transport instance.
+ transport = transports.BigtableTableAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
)
+ with pytest.raises(ValueError):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
-
-@pytest.mark.parametrize(
- "request_type",
- [
- iam_policy_pb2.GetIamPolicyRequest,
- dict,
- ],
-)
-def test_get_iam_policy_rest(request_type):
- client = BigtableTableAdminClient(
+ # It is an error to provide a credentials file and a transport instance.
+ transport = transports.BigtableTableAdminGrpcTransport(
credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
)
-
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
+ with pytest.raises(ValueError):
+ client = BigtableTableAdminClient(
+ client_options={"credentials_file": "credentials.json"},
+ transport=transport,
)
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_iam_policy(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, policy_pb2.Policy)
- assert response.version == 774
- assert response.etag == b"etag_blob"
+ # It is an error to provide an api_key and a transport instance.
+ transport = transports.BigtableTableAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ options = client_options.ClientOptions()
+ options.api_key = "api_key"
+ with pytest.raises(ValueError):
+ client = BigtableTableAdminClient(
+ client_options=options,
+ transport=transport,
+ )
+ # It is an error to provide an api_key and a credential.
+ options = client_options.ClientOptions()
+ options.api_key = "api_key"
+ with pytest.raises(ValueError):
+ client = BigtableTableAdminClient(
+ client_options=options, credentials=ga_credentials.AnonymousCredentials()
+ )
-def test_get_iam_policy_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
+ # It is an error to provide scopes and a transport instance.
+ transport = transports.BigtableTableAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ client_options={"scopes": ["1", "2"]},
+ transport=transport,
)
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
- # Ensure method has been cached
- assert client._transport.get_iam_policy in client._transport._wrapped_methods
+def test_transport_instance():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.BigtableTableAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+ assert client.transport is transport
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[client._transport.get_iam_policy] = mock_rpc
- request = {}
- client.get_iam_policy(request)
+def test_transport_get_channel():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.BigtableTableAdminGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
- # Establish that the underlying gRPC stub method was called.
- assert mock_rpc.call_count == 1
+ transport = transports.BigtableTableAdminGrpcAsyncIOTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
- client.get_iam_policy(request)
- # Establish that a new wrapper was not created for this call
- assert wrapper_fn.call_count == 0
- assert mock_rpc.call_count == 2
+@pytest.mark.parametrize(
+ "transport_class",
+ [
+ transports.BigtableTableAdminGrpcTransport,
+ transports.BigtableTableAdminGrpcAsyncIOTransport,
+ transports.BigtableTableAdminRestTransport,
+ ],
+)
+def test_transport_adc(transport_class):
+ # Test default credentials are used if not provided.
+ with mock.patch.object(google.auth, "default") as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport_class()
+ adc.assert_called_once()
-def test_get_iam_policy_rest_required_fields(
- request_type=iam_policy_pb2.GetIamPolicyRequest,
-):
- transport_class = transports.BigtableTableAdminRestTransport
+def test_transport_kind_grpc():
+ transport = BigtableTableAdminClient.get_transport_class("grpc")(
+ credentials=ga_credentials.AnonymousCredentials()
+ )
+ assert transport.kind == "grpc"
- request_init = {}
- request_init["resource"] = ""
- request = request_type(**request_init)
- pb_request = request
- jsonified_request = json.loads(
- json_format.MessageToJson(pb_request, use_integers_for_enums=False)
+
+def test_initialize_client_w_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc"
)
+ assert client is not None
- # verify fields with default values are dropped
- unset_fields = transport_class(
- credentials=ga_credentials.AnonymousCredentials()
- ).get_iam_policy._get_unset_required_fields(jsonified_request)
- jsonified_request.update(unset_fields)
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
- # verify required fields with default values are now present
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_table), "__call__") as call:
+ call.return_value = gba_table.Table()
+ client.create_table(request=None)
- jsonified_request["resource"] = "resource_value"
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateTableRequest()
- unset_fields = transport_class(
- credentials=ga_credentials.AnonymousCredentials()
- ).get_iam_policy._get_unset_required_fields(jsonified_request)
- jsonified_request.update(unset_fields)
+ assert args[0] == request_msg
- # verify required fields with non-default values are left alone
- assert "resource" in jsonified_request
- assert jsonified_request["resource"] == "resource_value"
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_table_from_snapshot_empty_call_grpc():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ transport="grpc",
)
- request = request_type(**request_init)
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy()
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # We need to mock transcode() because providing default values
- # for required fields will fail the real version if the http_options
- # expect actual values for those fields.
- with mock.patch.object(path_template, "transcode") as transcode:
- # A uri without fields and an empty body will force all the
- # request fields to show up in the query_params.
- pb_request = request
- transcode_result = {
- "uri": "v1/sample_method",
- "method": "post",
- "query_params": pb_request,
- }
- transcode_result["body"] = pb_request
- transcode.return_value = transcode_result
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_table_from_snapshot), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.create_table_from_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateTableFromSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_tables_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_tables), "__call__") as call:
+ call.return_value = bigtable_table_admin.ListTablesResponse()
+ client.list_tables(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListTablesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_table), "__call__") as call:
+ call.return_value = table.Table()
+ client.get_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_table), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.update_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_table), "__call__") as call:
+ call.return_value = None
+ client.delete_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_undelete_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.undelete_table), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.undelete_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UndeleteTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_authorized_view_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_authorized_view), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.create_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_authorized_views_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_authorized_views), "__call__"
+ ) as call:
+ call.return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
+ client.list_authorized_views(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListAuthorizedViewsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_authorized_view_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.get_authorized_view), "__call__"
+ ) as call:
+ call.return_value = table.AuthorizedView()
+ client.get_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_authorized_view_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_authorized_view), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.update_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_authorized_view_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_authorized_view), "__call__"
+ ) as call:
+ call.return_value = None
+ client.delete_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_modify_column_families_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.modify_column_families), "__call__"
+ ) as call:
+ call.return_value = table.Table()
+ client.modify_column_families(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ModifyColumnFamiliesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_drop_row_range_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.drop_row_range), "__call__") as call:
+ call.return_value = None
+ client.drop_row_range(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DropRowRangeRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_generate_consistency_token_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.generate_consistency_token), "__call__"
+ ) as call:
+ call.return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
+ client.generate_consistency_token(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GenerateConsistencyTokenRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_check_consistency_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_consistency), "__call__"
+ ) as call:
+ call.return_value = bigtable_table_admin.CheckConsistencyResponse()
+ client.check_consistency(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CheckConsistencyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_snapshot_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.snapshot_table), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.snapshot_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.SnapshotTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_snapshot_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_snapshot), "__call__") as call:
+ call.return_value = table.Snapshot()
+ client.get_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_snapshots_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_snapshots), "__call__") as call:
+ call.return_value = bigtable_table_admin.ListSnapshotsResponse()
+ client.list_snapshots(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListSnapshotsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_snapshot_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_snapshot), "__call__") as call:
+ call.return_value = None
+ client.delete_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_backup_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_backup), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.create_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_backup_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_backup), "__call__") as call:
+ call.return_value = table.Backup()
+ client.get_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_backup_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_backup), "__call__") as call:
+ call.return_value = table.Backup()
+ client.update_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_backup_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_backup), "__call__") as call:
+ call.return_value = None
+ client.delete_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_backups_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_backups), "__call__") as call:
+ call.return_value = bigtable_table_admin.ListBackupsResponse()
+ client.list_backups(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListBackupsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_restore_table_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.restore_table), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.restore_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.RestoreTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_copy_backup_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.copy_backup), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.copy_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CopyBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_iam_policy_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+ call.return_value = policy_pb2.Policy()
+ client.get_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.GetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_set_iam_policy_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+ call.return_value = policy_pb2.Policy()
+ client.set_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.SetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_test_iam_permissions_empty_call_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.test_iam_permissions), "__call__"
+ ) as call:
+ call.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+ client.test_iam_permissions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.TestIamPermissionsRequest()
+
+ assert args[0] == request_msg
+
+
+def test_transport_kind_grpc_asyncio():
+ transport = BigtableTableAdminAsyncClient.get_transport_class("grpc_asyncio")(
+ credentials=async_anonymous_credentials()
+ )
+ assert transport.kind == "grpc_asyncio"
+
+
+def test_initialize_client_w_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(), transport="grpc_asyncio"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ gba_table.Table(
+ name="name_value",
+ granularity=gba_table.Table.TimestampGranularity.MILLIS,
+ deletion_protection=True,
+ )
+ )
+ await client.create_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_table_from_snapshot_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_table_from_snapshot), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.create_table_from_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateTableFromSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_tables_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_tables), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_table_admin.ListTablesResponse(
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_tables(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListTablesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ table.Table(
+ name="name_value",
+ granularity=table.Table.TimestampGranularity.MILLIS,
+ deletion_protection=True,
+ )
+ )
+ await client.get_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_update_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.update_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_undelete_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.undelete_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.undelete_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UndeleteTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_authorized_view_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_authorized_view), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.create_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_authorized_views_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_authorized_views), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_table_admin.ListAuthorizedViewsResponse(
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_authorized_views(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListAuthorizedViewsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_authorized_view_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.get_authorized_view), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ table.AuthorizedView(
+ name="name_value",
+ etag="etag_value",
+ deletion_protection=True,
+ )
+ )
+ await client.get_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_update_authorized_view_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_authorized_view), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.update_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_authorized_view_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_authorized_view), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_modify_column_families_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.modify_column_families), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ table.Table(
+ name="name_value",
+ granularity=table.Table.TimestampGranularity.MILLIS,
+ deletion_protection=True,
+ )
+ )
+ await client.modify_column_families(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ModifyColumnFamiliesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_drop_row_range_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.drop_row_range), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.drop_row_range(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DropRowRangeRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_generate_consistency_token_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.generate_consistency_token), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_table_admin.GenerateConsistencyTokenResponse(
+ consistency_token="consistency_token_value",
+ )
+ )
+ await client.generate_consistency_token(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GenerateConsistencyTokenRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_check_consistency_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_consistency), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_table_admin.CheckConsistencyResponse(
+ consistent=True,
+ )
+ )
+ await client.check_consistency(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CheckConsistencyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_snapshot_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.snapshot_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.snapshot_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.SnapshotTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_snapshot_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_snapshot), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ table.Snapshot(
+ name="name_value",
+ data_size_bytes=1594,
+ state=table.Snapshot.State.READY,
+ description="description_value",
+ )
+ )
+ await client.get_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_snapshots_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_snapshots), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_table_admin.ListSnapshotsResponse(
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_snapshots(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListSnapshotsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_snapshot_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_snapshot), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_create_backup_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_backup), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.create_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_backup_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_backup), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ table.Backup(
+ name="name_value",
+ source_table="source_table_value",
+ source_backup="source_backup_value",
+ size_bytes=1089,
+ state=table.Backup.State.CREATING,
+ backup_type=table.Backup.BackupType.STANDARD,
+ )
+ )
+ await client.get_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_update_backup_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_backup), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ table.Backup(
+ name="name_value",
+ source_table="source_table_value",
+ source_backup="source_backup_value",
+ size_bytes=1089,
+ state=table.Backup.State.CREATING,
+ backup_type=table.Backup.BackupType.STANDARD,
+ )
+ )
+ await client.update_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_delete_backup_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_backup), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None)
+ await client.delete_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_list_backups_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_backups), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable_table_admin.ListBackupsResponse(
+ next_page_token="next_page_token_value",
+ )
+ )
+ await client.list_backups(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListBackupsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_restore_table_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.restore_table), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.restore_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.RestoreTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_copy_backup_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.copy_backup), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ await client.copy_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CopyBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_get_iam_policy_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
+ )
+ await client.get_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.GetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_set_iam_policy_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
+ )
+ await client.set_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.SetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_test_iam_permissions_empty_call_grpc_asyncio():
+ client = BigtableTableAdminAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.test_iam_permissions), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ iam_policy_pb2.TestIamPermissionsResponse(
+ permissions=["permissions_value"],
+ )
+ )
+ await client.test_iam_permissions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.TestIamPermissionsRequest()
+
+ assert args[0] == request_msg
+
+
+def test_transport_kind_rest():
+ transport = BigtableTableAdminClient.get_transport_class("rest")(
+ credentials=ga_credentials.AnonymousCredentials()
+ )
+ assert transport.kind == "rest"
+
+
+def test_create_table_rest_bad_request(
+ request_type=bigtable_table_admin.CreateTableRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.CreateTableRequest,
+ dict,
+ ],
+)
+def test_create_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = gba_table.Table(
+ name="name_value",
+ granularity=gba_table.Table.TimestampGranularity.MILLIS,
+ deletion_protection=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = gba_table.Table.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_table(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, gba_table.Table)
+ assert response.name == "name_value"
+ assert response.granularity == gba_table.Table.TimestampGranularity.MILLIS
+ assert response.deletion_protection is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_create_table"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_create_table"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.CreateTableRequest.pb(
+ bigtable_table_admin.CreateTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = gba_table.Table.to_json(gba_table.Table())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.CreateTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = gba_table.Table()
+
+ client.create_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_create_table_from_snapshot_rest_bad_request(
+ request_type=bigtable_table_admin.CreateTableFromSnapshotRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_table_from_snapshot(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.CreateTableFromSnapshotRequest,
+ dict,
+ ],
+)
+def test_create_table_from_snapshot_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_table_from_snapshot(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_table_from_snapshot_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_create_table_from_snapshot"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_create_table_from_snapshot"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.CreateTableFromSnapshotRequest.pb(
+ bigtable_table_admin.CreateTableFromSnapshotRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.CreateTableFromSnapshotRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.create_table_from_snapshot(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_tables_rest_bad_request(
+ request_type=bigtable_table_admin.ListTablesRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_tables(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.ListTablesRequest,
+ dict,
+ ],
+)
+def test_list_tables_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.ListTablesResponse(
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListTablesResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_tables(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListTablesPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_tables_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_list_tables"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_list_tables"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.ListTablesRequest.pb(
+ bigtable_table_admin.ListTablesRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_table_admin.ListTablesResponse.to_json(
+ bigtable_table_admin.ListTablesResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.ListTablesRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_table_admin.ListTablesResponse()
+
+ client.list_tables(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_table_rest_bad_request(request_type=bigtable_table_admin.GetTableRequest):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.GetTableRequest,
+ dict,
+ ],
+)
+def test_get_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.Table(
+ name="name_value",
+ granularity=table.Table.TimestampGranularity.MILLIS,
+ deletion_protection=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.Table.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_table(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, table.Table)
+ assert response.name == "name_value"
+ assert response.granularity == table.Table.TimestampGranularity.MILLIS
+ assert response.deletion_protection is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_get_table"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_get_table"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.GetTableRequest.pb(
+ bigtable_table_admin.GetTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = table.Table.to_json(table.Table())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.GetTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = table.Table()
+
+ client.get_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_update_table_rest_bad_request(
+ request_type=bigtable_table_admin.UpdateTableRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "table": {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.update_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.UpdateTableRequest,
+ dict,
+ ],
+)
+def test_update_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "table": {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ }
+ request_init["table"] = {
+ "name": "projects/sample1/instances/sample2/tables/sample3",
+ "cluster_states": {},
+ "column_families": {},
+ "granularity": 1,
+ "restore_info": {
+ "source_type": 1,
+ "backup_info": {
+ "backup": "backup_value",
+ "start_time": {"seconds": 751, "nanos": 543},
+ "end_time": {},
+ "source_table": "source_table_value",
+ "source_backup": "source_backup_value",
+ },
+ },
+ "change_stream_config": {"retention_period": {"seconds": 751, "nanos": 543}},
+ "deletion_protection": True,
+ "automated_backup_policy": {"retention_period": {}, "frequency": {}},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_table_admin.UpdateTableRequest.meta.fields["table"]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["table"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["table"][field])):
+ del request_init["table"][field][i][subfield]
+ else:
+ del request_init["table"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.update_table(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_update_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_update_table"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_update_table"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.UpdateTableRequest.pb(
+ bigtable_table_admin.UpdateTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.UpdateTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.update_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_table_rest_bad_request(
+ request_type=bigtable_table_admin.DeleteTableRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.DeleteTableRequest,
+ dict,
+ ],
+)
+def test_delete_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_table(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_delete_table"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_table_admin.DeleteTableRequest.pb(
+ bigtable_table_admin.DeleteTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_table_admin.DeleteTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_undelete_table_rest_bad_request(
+ request_type=bigtable_table_admin.UndeleteTableRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.undelete_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.UndeleteTableRequest,
+ dict,
+ ],
+)
+def test_undelete_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.undelete_table(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_undelete_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_undelete_table"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_undelete_table"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.UndeleteTableRequest.pb(
+ bigtable_table_admin.UndeleteTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.UndeleteTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.undelete_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_create_authorized_view_rest_bad_request(
+ request_type=bigtable_table_admin.CreateAuthorizedViewRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_authorized_view(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.CreateAuthorizedViewRequest,
+ dict,
+ ],
+)
+def test_create_authorized_view_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
+ request_init["authorized_view"] = {
+ "name": "name_value",
+ "subset_view": {
+ "row_prefixes": [b"row_prefixes_blob1", b"row_prefixes_blob2"],
+ "family_subsets": {},
+ },
+ "etag": "etag_value",
+ "deletion_protection": True,
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_table_admin.CreateAuthorizedViewRequest.meta.fields[
+ "authorized_view"
+ ]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["authorized_view"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["authorized_view"][field])):
+ del request_init["authorized_view"][field][i][subfield]
+ else:
+ del request_init["authorized_view"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_authorized_view(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_authorized_view_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_create_authorized_view"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_create_authorized_view"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.CreateAuthorizedViewRequest.pb(
+ bigtable_table_admin.CreateAuthorizedViewRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.CreateAuthorizedViewRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.create_authorized_view(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_authorized_views_rest_bad_request(
+ request_type=bigtable_table_admin.ListAuthorizedViewsRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_authorized_views(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.ListAuthorizedViewsRequest,
+ dict,
+ ],
+)
+def test_list_authorized_views_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse(
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_authorized_views(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListAuthorizedViewsPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_authorized_views_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_list_authorized_views"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_list_authorized_views"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.ListAuthorizedViewsRequest.pb(
+ bigtable_table_admin.ListAuthorizedViewsRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_table_admin.ListAuthorizedViewsResponse.to_json(
+ bigtable_table_admin.ListAuthorizedViewsResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.ListAuthorizedViewsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_table_admin.ListAuthorizedViewsResponse()
+
+ client.list_authorized_views(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_authorized_view_rest_bad_request(
+ request_type=bigtable_table_admin.GetAuthorizedViewRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_authorized_view(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.GetAuthorizedViewRequest,
+ dict,
+ ],
+)
+def test_get_authorized_view_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.AuthorizedView(
+ name="name_value",
+ etag="etag_value",
+ deletion_protection=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.AuthorizedView.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_authorized_view(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, table.AuthorizedView)
+ assert response.name == "name_value"
+ assert response.etag == "etag_value"
+ assert response.deletion_protection is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_authorized_view_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_get_authorized_view"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_get_authorized_view"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.GetAuthorizedViewRequest.pb(
+ bigtable_table_admin.GetAuthorizedViewRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = table.AuthorizedView.to_json(table.AuthorizedView())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.GetAuthorizedViewRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = table.AuthorizedView()
+
+ client.get_authorized_view(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_update_authorized_view_rest_bad_request(
+ request_type=bigtable_table_admin.UpdateAuthorizedViewRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "authorized_view": {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.update_authorized_view(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.UpdateAuthorizedViewRequest,
+ dict,
+ ],
+)
+def test_update_authorized_view_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "authorized_view": {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ }
+ request_init["authorized_view"] = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4",
+ "subset_view": {
+ "row_prefixes": [b"row_prefixes_blob1", b"row_prefixes_blob2"],
+ "family_subsets": {},
+ },
+ "etag": "etag_value",
+ "deletion_protection": True,
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_table_admin.UpdateAuthorizedViewRequest.meta.fields[
+ "authorized_view"
+ ]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["authorized_view"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["authorized_view"][field])):
+ del request_init["authorized_view"][field][i][subfield]
+ else:
+ del request_init["authorized_view"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.update_authorized_view(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_update_authorized_view_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_update_authorized_view"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_update_authorized_view"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.UpdateAuthorizedViewRequest.pb(
+ bigtable_table_admin.UpdateAuthorizedViewRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.UpdateAuthorizedViewRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.update_authorized_view(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_authorized_view_rest_bad_request(
+ request_type=bigtable_table_admin.DeleteAuthorizedViewRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_authorized_view(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.DeleteAuthorizedViewRequest,
+ dict,
+ ],
+)
+def test_delete_authorized_view_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_authorized_view(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_authorized_view_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_delete_authorized_view"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_table_admin.DeleteAuthorizedViewRequest.pb(
+ bigtable_table_admin.DeleteAuthorizedViewRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_table_admin.DeleteAuthorizedViewRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_authorized_view(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_modify_column_families_rest_bad_request(
+ request_type=bigtable_table_admin.ModifyColumnFamiliesRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.modify_column_families(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.ModifyColumnFamiliesRequest,
+ dict,
+ ],
+)
+def test_modify_column_families_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.Table(
+ name="name_value",
+ granularity=table.Table.TimestampGranularity.MILLIS,
+ deletion_protection=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.Table.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.modify_column_families(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, table.Table)
+ assert response.name == "name_value"
+ assert response.granularity == table.Table.TimestampGranularity.MILLIS
+ assert response.deletion_protection is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_modify_column_families_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_modify_column_families"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_modify_column_families"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.ModifyColumnFamiliesRequest.pb(
+ bigtable_table_admin.ModifyColumnFamiliesRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = table.Table.to_json(table.Table())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.ModifyColumnFamiliesRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = table.Table()
+
+ client.modify_column_families(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_drop_row_range_rest_bad_request(
+ request_type=bigtable_table_admin.DropRowRangeRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.drop_row_range(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.DropRowRangeRequest,
+ dict,
+ ],
+)
+def test_drop_row_range_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.drop_row_range(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_drop_row_range_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_drop_row_range"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_table_admin.DropRowRangeRequest.pb(
+ bigtable_table_admin.DropRowRangeRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_table_admin.DropRowRangeRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.drop_row_range(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_generate_consistency_token_rest_bad_request(
+ request_type=bigtable_table_admin.GenerateConsistencyTokenRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.generate_consistency_token(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.GenerateConsistencyTokenRequest,
+ dict,
+ ],
+)
+def test_generate_consistency_token_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse(
+ consistency_token="consistency_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.pb(
+ return_value
+ )
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.generate_consistency_token(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable_table_admin.GenerateConsistencyTokenResponse)
+ assert response.consistency_token == "consistency_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_generate_consistency_token_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_generate_consistency_token"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_generate_consistency_token"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.GenerateConsistencyTokenRequest.pb(
+ bigtable_table_admin.GenerateConsistencyTokenRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_table_admin.GenerateConsistencyTokenResponse.to_json(
+ bigtable_table_admin.GenerateConsistencyTokenResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.GenerateConsistencyTokenRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_table_admin.GenerateConsistencyTokenResponse()
+
+ client.generate_consistency_token(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_check_consistency_rest_bad_request(
+ request_type=bigtable_table_admin.CheckConsistencyRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.check_consistency(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.CheckConsistencyRequest,
+ dict,
+ ],
+)
+def test_check_consistency_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.CheckConsistencyResponse(
+ consistent=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.CheckConsistencyResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.check_consistency(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable_table_admin.CheckConsistencyResponse)
+ assert response.consistent is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_check_consistency_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_check_consistency"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_check_consistency"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.CheckConsistencyRequest.pb(
+ bigtable_table_admin.CheckConsistencyRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_table_admin.CheckConsistencyResponse.to_json(
+ bigtable_table_admin.CheckConsistencyResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.CheckConsistencyRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_table_admin.CheckConsistencyResponse()
+
+ client.check_consistency(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_snapshot_table_rest_bad_request(
+ request_type=bigtable_table_admin.SnapshotTableRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.snapshot_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.SnapshotTableRequest,
+ dict,
+ ],
+)
+def test_snapshot_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.snapshot_table(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_snapshot_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_snapshot_table"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_snapshot_table"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.SnapshotTableRequest.pb(
+ bigtable_table_admin.SnapshotTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.SnapshotTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.snapshot_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_snapshot_rest_bad_request(
+ request_type=bigtable_table_admin.GetSnapshotRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_snapshot(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.GetSnapshotRequest,
+ dict,
+ ],
+)
+def test_get_snapshot_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.Snapshot(
+ name="name_value",
+ data_size_bytes=1594,
+ state=table.Snapshot.State.READY,
+ description="description_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.Snapshot.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_snapshot(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, table.Snapshot)
+ assert response.name == "name_value"
+ assert response.data_size_bytes == 1594
+ assert response.state == table.Snapshot.State.READY
+ assert response.description == "description_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_snapshot_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_get_snapshot"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_get_snapshot"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.GetSnapshotRequest.pb(
+ bigtable_table_admin.GetSnapshotRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = table.Snapshot.to_json(table.Snapshot())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.GetSnapshotRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = table.Snapshot()
+
+ client.get_snapshot(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_list_snapshots_rest_bad_request(
+ request_type=bigtable_table_admin.ListSnapshotsRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_snapshots(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.ListSnapshotsRequest,
+ dict,
+ ],
+)
+def test_list_snapshots_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.ListSnapshotsResponse(
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListSnapshotsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_snapshots(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListSnapshotsPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_snapshots_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_list_snapshots"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_list_snapshots"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.ListSnapshotsRequest.pb(
+ bigtable_table_admin.ListSnapshotsRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_table_admin.ListSnapshotsResponse.to_json(
+ bigtable_table_admin.ListSnapshotsResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.ListSnapshotsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_table_admin.ListSnapshotsResponse()
+
+ client.list_snapshots(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_snapshot_rest_bad_request(
+ request_type=bigtable_table_admin.DeleteSnapshotRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_snapshot(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.DeleteSnapshotRequest,
+ dict,
+ ],
+)
+def test_delete_snapshot_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/snapshots/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_snapshot(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_snapshot_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_delete_snapshot"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_table_admin.DeleteSnapshotRequest.pb(
+ bigtable_table_admin.DeleteSnapshotRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_table_admin.DeleteSnapshotRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_snapshot(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_create_backup_rest_bad_request(
+ request_type=bigtable_table_admin.CreateBackupRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.create_backup(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.CreateBackupRequest,
+ dict,
+ ],
+)
+def test_create_backup_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request_init["backup"] = {
+ "name": "name_value",
+ "source_table": "source_table_value",
+ "source_backup": "source_backup_value",
+ "expire_time": {"seconds": 751, "nanos": 543},
+ "start_time": {},
+ "end_time": {},
+ "size_bytes": 1089,
+ "state": 1,
+ "encryption_info": {
+ "encryption_type": 1,
+ "encryption_status": {
+ "code": 411,
+ "message": "message_value",
+ "details": [
+ {
+ "type_url": "type.googleapis.com/google.protobuf.Duration",
+ "value": b"\x08\x0c\x10\xdb\x07",
+ }
+ ],
+ },
+ "kms_key_version": "kms_key_version_value",
+ },
+ "backup_type": 1,
+ "hot_to_standard_time": {},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_table_admin.CreateBackupRequest.meta.fields["backup"]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["backup"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["backup"][field])):
+ del request_init["backup"][field][i][subfield]
+ else:
+ del request_init["backup"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.create_backup(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_create_backup_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_create_backup"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_create_backup"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.CreateBackupRequest.pb(
+ bigtable_table_admin.CreateBackupRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.CreateBackupRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.create_backup(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_backup_rest_bad_request(
+ request_type=bigtable_table_admin.GetBackupRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_backup(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.GetBackupRequest,
+ dict,
+ ],
+)
+def test_get_backup_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.Backup(
+ name="name_value",
+ source_table="source_table_value",
+ source_backup="source_backup_value",
+ size_bytes=1089,
+ state=table.Backup.State.CREATING,
+ backup_type=table.Backup.BackupType.STANDARD,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.Backup.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_backup(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, table.Backup)
+ assert response.name == "name_value"
+ assert response.source_table == "source_table_value"
+ assert response.source_backup == "source_backup_value"
+ assert response.size_bytes == 1089
+ assert response.state == table.Backup.State.CREATING
+ assert response.backup_type == table.Backup.BackupType.STANDARD
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_get_backup_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_get_backup"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_get_backup"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.GetBackupRequest.pb(
+ bigtable_table_admin.GetBackupRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = table.Backup.to_json(table.Backup())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.GetBackupRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = table.Backup()
+
+ client.get_backup(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_update_backup_rest_bad_request(
+ request_type=bigtable_table_admin.UpdateBackupRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "backup": {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.update_backup(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.UpdateBackupRequest,
+ dict,
+ ],
+)
+def test_update_backup_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "backup": {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ }
+ request_init["backup"] = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4",
+ "source_table": "source_table_value",
+ "source_backup": "source_backup_value",
+ "expire_time": {"seconds": 751, "nanos": 543},
+ "start_time": {},
+ "end_time": {},
+ "size_bytes": 1089,
+ "state": 1,
+ "encryption_info": {
+ "encryption_type": 1,
+ "encryption_status": {
+ "code": 411,
+ "message": "message_value",
+ "details": [
+ {
+ "type_url": "type.googleapis.com/google.protobuf.Duration",
+ "value": b"\x08\x0c\x10\xdb\x07",
+ }
+ ],
+ },
+ "kms_key_version": "kms_key_version_value",
+ },
+ "backup_type": 1,
+ "hot_to_standard_time": {},
+ }
+ # The version of a generated dependency at test runtime may differ from the version used during generation.
+ # Delete any fields which are not present in the current runtime dependency
+ # See https://github.com/googleapis/gapic-generator-python/issues/1748
+
+ # Determine if the message type is proto-plus or protobuf
+ test_field = bigtable_table_admin.UpdateBackupRequest.meta.fields["backup"]
+
+ def get_message_fields(field):
+ # Given a field which is a message (composite type), return a list with
+ # all the fields of the message.
+ # If the field is not a composite type, return an empty list.
+ message_fields = []
+
+ if hasattr(field, "message") and field.message:
+ is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR")
+
+ if is_field_type_proto_plus_type:
+ message_fields = field.message.meta.fields.values()
+ # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types
+ else: # pragma: NO COVER
+ message_fields = field.message.DESCRIPTOR.fields
+ return message_fields
+
+ runtime_nested_fields = [
+ (field.name, nested_field.name)
+ for field in get_message_fields(test_field)
+ for nested_field in get_message_fields(field)
+ ]
+
+ subfields_not_in_runtime = []
+
+ # For each item in the sample request, create a list of sub fields which are not present at runtime
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for field, value in request_init["backup"].items(): # pragma: NO COVER
+ result = None
+ is_repeated = False
+ # For repeated fields
+ if isinstance(value, list) and len(value):
+ is_repeated = True
+ result = value[0]
+ # For fields where the type is another message
+ if isinstance(value, dict):
+ result = value
+
+ if result and hasattr(result, "keys"):
+ for subfield in result.keys():
+ if (field, subfield) not in runtime_nested_fields:
+ subfields_not_in_runtime.append(
+ {
+ "field": field,
+ "subfield": subfield,
+ "is_repeated": is_repeated,
+ }
+ )
+
+ # Remove fields from the sample request which are not present in the runtime version of the dependency
+ # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime
+ for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER
+ field = subfield_to_delete.get("field")
+ field_repeated = subfield_to_delete.get("is_repeated")
+ subfield = subfield_to_delete.get("subfield")
+ if subfield:
+ if field_repeated:
+ for i in range(0, len(request_init["backup"][field])):
+ del request_init["backup"][field][i][subfield]
+ else:
+ del request_init["backup"][field][subfield]
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = table.Backup(
+ name="name_value",
+ source_table="source_table_value",
+ source_backup="source_backup_value",
+ size_bytes=1089,
+ state=table.Backup.State.CREATING,
+ backup_type=table.Backup.BackupType.STANDARD,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = table.Backup.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.update_backup(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, table.Backup)
+ assert response.name == "name_value"
+ assert response.source_table == "source_table_value"
+ assert response.source_backup == "source_backup_value"
+ assert response.size_bytes == 1089
+ assert response.state == table.Backup.State.CREATING
+ assert response.backup_type == table.Backup.BackupType.STANDARD
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_update_backup_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_update_backup"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_update_backup"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.UpdateBackupRequest.pb(
+ bigtable_table_admin.UpdateBackupRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = table.Backup.to_json(table.Backup())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.UpdateBackupRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = table.Backup()
+
+ client.update_backup(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_delete_backup_rest_bad_request(
+ request_type=bigtable_table_admin.DeleteBackupRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.delete_backup(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.DeleteBackupRequest,
+ dict,
+ ],
+)
+def test_delete_backup_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {
+ "name": "projects/sample1/instances/sample2/clusters/sample3/backups/sample4"
+ }
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = None
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = ""
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.delete_backup(request)
+
+ # Establish that the response is the type that we expect.
+ assert response is None
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_delete_backup_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_delete_backup"
+ ) as pre:
+ pre.assert_not_called()
+ pb_message = bigtable_table_admin.DeleteBackupRequest.pb(
+ bigtable_table_admin.DeleteBackupRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+
+ request = bigtable_table_admin.DeleteBackupRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+
+ client.delete_backup(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+
+
+def test_list_backups_rest_bad_request(
+ request_type=bigtable_table_admin.ListBackupsRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.list_backups(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.ListBackupsRequest,
+ dict,
+ ],
+)
+def test_list_backups_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable_table_admin.ListBackupsResponse(
+ next_page_token="next_page_token_value",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable_table_admin.ListBackupsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.list_backups(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListBackupsPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_list_backups_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_list_backups"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_list_backups"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.ListBackupsRequest.pb(
+ bigtable_table_admin.ListBackupsRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable_table_admin.ListBackupsResponse.to_json(
+ bigtable_table_admin.ListBackupsResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.ListBackupsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable_table_admin.ListBackupsResponse()
- response_value = Response()
- response_value.status_code = 200
+ client.list_backups(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
- json_return_value = json_format.MessageToJson(return_value)
+ pre.assert_called_once()
+ post.assert_called_once()
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.get_iam_policy(request)
+def test_restore_table_rest_bad_request(
+ request_type=bigtable_table_admin.RestoreTableRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.restore_table(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.RestoreTableRequest,
+ dict,
+ ],
+)
+def test_restore_table_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.restore_table(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_restore_table_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_restore_table"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_restore_table"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.RestoreTableRequest.pb(
+ bigtable_table_admin.RestoreTableRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.RestoreTableRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.restore_table(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_copy_backup_rest_bad_request(
+ request_type=bigtable_table_admin.CopyBackupRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.copy_backup(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable_table_admin.CopyBackupRequest,
+ dict,
+ ],
+)
+def test_copy_backup_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"parent": "projects/sample1/instances/sample2/clusters/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = operations_pb2.Operation(name="operations/spam")
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.copy_backup(request)
+
+ # Establish that the response is the type that we expect.
+ json_return_value = json_format.MessageToJson(return_value)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_copy_backup_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ operation.Operation, "_set_result_from_operation"
+ ), mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_copy_backup"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_copy_backup"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable_table_admin.CopyBackupRequest.pb(
+ bigtable_table_admin.CopyBackupRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(operations_pb2.Operation())
+ req.return_value.content = return_value
+
+ request = bigtable_table_admin.CopyBackupRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = operations_pb2.Operation()
+
+ client.copy_backup(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_get_iam_policy_rest_bad_request(
+ request_type=iam_policy_pb2.GetIamPolicyRequest,
+):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.get_iam_policy(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ iam_policy_pb2.GetIamPolicyRequest,
+ dict,
+ ],
+)
+def test_get_iam_policy_rest_call_success(request_type):
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
- expected_params = [("$alt", "json;enum-encoding=int")]
- actual_params = req.call_args.kwargs["params"]
- assert expected_params == actual_params
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
+ )
-def test_get_iam_policy_rest_unset_required_fields():
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials
- )
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.get_iam_policy(request)
- unset_fields = transport.get_iam_policy._get_unset_required_fields({})
- assert set(unset_fields) == (set(()) & set(("resource",)))
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, policy_pb2.Policy)
+ assert response.version == 774
+ assert response.etag == b"etag_blob"
@pytest.mark.parametrize("null_interceptor", [True, False])
@@ -22565,6 +23078,7 @@ def test_get_iam_policy_rest_interceptors(null_interceptor):
else transports.BigtableTableAdminRestInterceptor(),
)
client = BigtableTableAdminClient(transport=transport)
+
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
@@ -22584,10 +23098,10 @@ def test_get_iam_policy_rest_interceptors(null_interceptor):
"query_params": pb_message,
}
- req.return_value = Response()
+ req.return_value = mock.Mock()
req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(policy_pb2.Policy())
+ return_value = json_format.MessageToJson(policy_pb2.Policy())
+ req.return_value.content = return_value
request = iam_policy_pb2.GetIamPolicyRequest()
metadata = [
@@ -22609,14 +23123,12 @@ def test_get_iam_policy_rest_interceptors(null_interceptor):
post.assert_called_once()
-def test_get_iam_policy_rest_bad_request(
- transport: str = "rest", request_type=iam_policy_pb2.GetIamPolicyRequest
+def test_set_iam_policy_rest_bad_request(
+ request_type=iam_policy_pb2.SetIamPolicyRequest,
):
client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
-
# send a request that will satisfy transcoding
request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
request = request_type(**request_init)
@@ -22626,74 +23138,13 @@ def test_get_iam_policy_rest_bad_request(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
- response_value = Response()
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.get_iam_policy(request)
-
-
-def test_get_iam_policy_rest_flattened():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "resource": "projects/sample1/instances/sample2/tables/sample3"
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- resource="resource_value",
- )
- mock_args.update(sample_request)
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
- response_value._content = json_return_value.encode("UTF-8")
+ response_value.request = mock.Mock()
req.return_value = response_value
-
- client.get_iam_policy(**mock_args)
-
- # Establish that the underlying call was made with the expected
- # request object values.
- assert len(req.mock_calls) == 1
- _, args, _ = req.mock_calls[0]
- assert path_template.validate(
- "%s/v2/{resource=projects/*/instances/*/tables/*}:getIamPolicy"
- % client.transport._host,
- args[1],
- )
-
-
-def test_get_iam_policy_rest_flattened_error(transport: str = "rest"):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # Attempting to call a method with both a request object and flattened
- # fields is an error.
- with pytest.raises(ValueError):
- client.get_iam_policy(
- iam_policy_pb2.GetIamPolicyRequest(),
- resource="resource_value",
- )
-
-
-def test_get_iam_policy_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+ client.set_iam_policy(request)
@pytest.mark.parametrize(
@@ -22703,163 +23154,35 @@ def test_get_iam_policy_rest_error():
dict,
],
)
-def test_set_iam_policy_rest(request_type):
+def test_set_iam_policy_rest_call_success(request_type):
client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
# send a request that will satisfy transcoding
request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
request = request_type(**request_init)
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy(
- version=774,
- etag=b"etag_blob",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.set_iam_policy(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, policy_pb2.Policy)
- assert response.version == 774
- assert response.etag == b"etag_blob"
-
-
-def test_set_iam_policy_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
-
- # Ensure method has been cached
- assert client._transport.set_iam_policy in client._transport._wrapped_methods
-
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[client._transport.set_iam_policy] = mock_rpc
-
- request = {}
- client.set_iam_policy(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert mock_rpc.call_count == 1
-
- client.set_iam_policy(request)
-
- # Establish that a new wrapper was not created for this call
- assert wrapper_fn.call_count == 0
- assert mock_rpc.call_count == 2
-
-
-def test_set_iam_policy_rest_required_fields(
- request_type=iam_policy_pb2.SetIamPolicyRequest,
-):
- transport_class = transports.BigtableTableAdminRestTransport
-
- request_init = {}
- request_init["resource"] = ""
- request = request_type(**request_init)
- pb_request = request
- jsonified_request = json.loads(
- json_format.MessageToJson(pb_request, use_integers_for_enums=False)
- )
-
- # verify fields with default values are dropped
-
- unset_fields = transport_class(
- credentials=ga_credentials.AnonymousCredentials()
- ).set_iam_policy._get_unset_required_fields(jsonified_request)
- jsonified_request.update(unset_fields)
-
- # verify required fields with default values are now present
-
- jsonified_request["resource"] = "resource_value"
-
- unset_fields = transport_class(
- credentials=ga_credentials.AnonymousCredentials()
- ).set_iam_policy._get_unset_required_fields(jsonified_request)
- jsonified_request.update(unset_fields)
-
- # verify required fields with non-default values are left alone
- assert "resource" in jsonified_request
- assert jsonified_request["resource"] == "resource_value"
-
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
- request = request_type(**request_init)
-
- # Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy()
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # We need to mock transcode() because providing default values
- # for required fields will fail the real version if the http_options
- # expect actual values for those fields.
- with mock.patch.object(path_template, "transcode") as transcode:
- # A uri without fields and an empty body will force all the
- # request fields to show up in the query_params.
- pb_request = request
- transcode_result = {
- "uri": "v1/sample_method",
- "method": "post",
- "query_params": pb_request,
- }
- transcode_result["body"] = pb_request
- transcode.return_value = transcode_result
-
- response_value = Response()
- response_value.status_code = 200
-
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
-
- response = client.set_iam_policy(request)
-
- expected_params = [("$alt", "json;enum-encoding=int")]
- actual_params = req.call_args.kwargs["params"]
- assert expected_params == actual_params
-
-
-def test_set_iam_policy_rest_unset_required_fields():
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials
- )
-
- unset_fields = transport.set_iam_policy._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(())
- & set(
- (
- "resource",
- "policy",
- )
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = policy_pb2.Policy(
+ version=774,
+ etag=b"etag_blob",
)
- )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.set_iam_policy(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, policy_pb2.Policy)
+ assert response.version == 774
+ assert response.etag == b"etag_blob"
@pytest.mark.parametrize("null_interceptor", [True, False])
@@ -22871,6 +23194,7 @@ def test_set_iam_policy_rest_interceptors(null_interceptor):
else transports.BigtableTableAdminRestInterceptor(),
)
client = BigtableTableAdminClient(transport=transport)
+
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
@@ -22890,10 +23214,10 @@ def test_set_iam_policy_rest_interceptors(null_interceptor):
"query_params": pb_message,
}
- req.return_value = Response()
+ req.return_value = mock.Mock()
req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(policy_pb2.Policy())
+ return_value = json_format.MessageToJson(policy_pb2.Policy())
+ req.return_value.content = return_value
request = iam_policy_pb2.SetIamPolicyRequest()
metadata = [
@@ -22915,14 +23239,12 @@ def test_set_iam_policy_rest_interceptors(null_interceptor):
post.assert_called_once()
-def test_set_iam_policy_rest_bad_request(
- transport: str = "rest", request_type=iam_policy_pb2.SetIamPolicyRequest
+def test_test_iam_permissions_rest_bad_request(
+ request_type=iam_policy_pb2.TestIamPermissionsRequest,
):
client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
-
# send a request that will satisfy transcoding
request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
request = request_type(**request_init)
@@ -22932,496 +23254,749 @@ def test_set_iam_policy_rest_bad_request(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
- response_value = Response()
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
response_value.status_code = 400
- response_value.request = Request()
+ response_value.request = mock.Mock()
req.return_value = response_value
- client.set_iam_policy(request)
+ client.test_iam_permissions(request)
-def test_set_iam_policy_rest_flattened():
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ iam_policy_pb2.TestIamPermissionsRequest,
+ dict,
+ ],
+)
+def test_test_iam_permissions_rest_call_success(request_type):
client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
+ # send a request that will satisfy transcoding
+ request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
- return_value = policy_pb2.Policy()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "resource": "projects/sample1/instances/sample2/tables/sample3"
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- resource="resource_value",
+ return_value = iam_policy_pb2.TestIamPermissionsResponse(
+ permissions=["permissions_value"],
)
- mock_args.update(sample_request)
# Wrap the value into a proper Response obj
- response_value = Response()
+ response_value = mock.Mock()
response_value.status_code = 200
json_return_value = json_format.MessageToJson(return_value)
- response_value._content = json_return_value.encode("UTF-8")
+ response_value.content = json_return_value.encode("UTF-8")
req.return_value = response_value
+ response = client.test_iam_permissions(request)
- client.set_iam_policy(**mock_args)
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
+ assert response.permissions == ["permissions_value"]
- # Establish that the underlying call was made with the expected
- # request object values.
- assert len(req.mock_calls) == 1
- _, args, _ = req.mock_calls[0]
- assert path_template.validate(
- "%s/v2/{resource=projects/*/instances/*/tables/*}:setIamPolicy"
- % client.transport._host,
- args[1],
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_test_iam_permissions_rest_interceptors(null_interceptor):
+ transport = transports.BigtableTableAdminRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None
+ if null_interceptor
+ else transports.BigtableTableAdminRestInterceptor(),
+ )
+ client = BigtableTableAdminClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "post_test_iam_permissions"
+ ) as post, mock.patch.object(
+ transports.BigtableTableAdminRestInterceptor, "pre_test_iam_permissions"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = iam_policy_pb2.TestIamPermissionsRequest()
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = json_format.MessageToJson(
+ iam_policy_pb2.TestIamPermissionsResponse()
+ )
+ req.return_value.content = return_value
+
+ request = iam_policy_pb2.TestIamPermissionsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+
+ client.test_iam_permissions(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
)
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_initialize_client_w_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_table_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_table), "__call__") as call:
+ client.create_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_table_from_snapshot_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_table_from_snapshot), "__call__"
+ ) as call:
+ client.create_table_from_snapshot(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateTableFromSnapshotRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_tables_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_tables), "__call__") as call:
+ client.list_tables(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListTablesRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_table_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_table), "__call__") as call:
+ client.get_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_table_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_table), "__call__") as call:
+ client.update_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_table_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_table), "__call__") as call:
+ client.delete_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_undelete_table_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.undelete_table), "__call__") as call:
+ client.undelete_table(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UndeleteTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_authorized_view_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.create_authorized_view), "__call__"
+ ) as call:
+ client.create_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateAuthorizedViewRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_authorized_views_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_authorized_views), "__call__"
+ ) as call:
+ client.list_authorized_views(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListAuthorizedViewsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_authorized_view_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.get_authorized_view), "__call__"
+ ) as call:
+ client.get_authorized_view(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetAuthorizedViewRequest()
+
+ assert args[0] == request_msg
-def test_set_iam_policy_rest_flattened_error(transport: str = "rest"):
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_authorized_view_empty_call_rest():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # Attempting to call a method with both a request object and flattened
- # fields is an error.
- with pytest.raises(ValueError):
- client.set_iam_policy(
- iam_policy_pb2.SetIamPolicyRequest(),
- resource="resource_value",
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_authorized_view), "__call__"
+ ) as call:
+ client.update_authorized_view(request=None)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateAuthorizedViewRequest()
-def test_set_iam_policy_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+ assert args[0] == request_msg
-@pytest.mark.parametrize(
- "request_type",
- [
- iam_policy_pb2.TestIamPermissionsRequest,
- dict,
- ],
-)
-def test_test_iam_permissions_rest(request_type):
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_authorized_view_empty_call_rest():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_authorized_view), "__call__"
+ ) as call:
+ client.delete_authorized_view(request=None)
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = iam_policy_pb2.TestIamPermissionsResponse(
- permissions=["permissions_value"],
- )
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteAuthorizedViewRequest()
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
+ assert args[0] == request_msg
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.test_iam_permissions(request)
- # Establish that the response is the type that we expect.
- assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse)
- assert response.permissions == ["permissions_value"]
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_modify_column_families_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.modify_column_families), "__call__"
+ ) as call:
+ client.modify_column_families(request=None)
-def test_test_iam_permissions_rest_use_cached_wrapped_rpc():
- # Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
- # instead of constructing them on each call
- with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn:
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ModifyColumnFamiliesRequest()
- # Should wrap all calls on client creation
- assert wrapper_fn.call_count > 0
- wrapper_fn.reset_mock()
+ assert args[0] == request_msg
- # Ensure method has been cached
- assert (
- client._transport.test_iam_permissions in client._transport._wrapped_methods
- )
- # Replace cached wrapped function with mock
- mock_rpc = mock.Mock()
- mock_rpc.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client._transport._wrapped_methods[
- client._transport.test_iam_permissions
- ] = mock_rpc
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_drop_row_range_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- request = {}
- client.test_iam_permissions(request)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.drop_row_range), "__call__") as call:
+ client.drop_row_range(request=None)
- # Establish that the underlying gRPC stub method was called.
- assert mock_rpc.call_count == 1
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DropRowRangeRequest()
- client.test_iam_permissions(request)
+ assert args[0] == request_msg
- # Establish that a new wrapper was not created for this call
- assert wrapper_fn.call_count == 0
- assert mock_rpc.call_count == 2
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_generate_consistency_token_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
-def test_test_iam_permissions_rest_required_fields(
- request_type=iam_policy_pb2.TestIamPermissionsRequest,
-):
- transport_class = transports.BigtableTableAdminRestTransport
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.generate_consistency_token), "__call__"
+ ) as call:
+ client.generate_consistency_token(request=None)
- request_init = {}
- request_init["resource"] = ""
- request_init["permissions"] = ""
- request = request_type(**request_init)
- pb_request = request
- jsonified_request = json.loads(
- json_format.MessageToJson(pb_request, use_integers_for_enums=False)
- )
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GenerateConsistencyTokenRequest()
- # verify fields with default values are dropped
+ assert args[0] == request_msg
- unset_fields = transport_class(
- credentials=ga_credentials.AnonymousCredentials()
- ).test_iam_permissions._get_unset_required_fields(jsonified_request)
- jsonified_request.update(unset_fields)
- # verify required fields with default values are now present
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_check_consistency_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- jsonified_request["resource"] = "resource_value"
- jsonified_request["permissions"] = "permissions_value"
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_consistency), "__call__"
+ ) as call:
+ client.check_consistency(request=None)
- unset_fields = transport_class(
- credentials=ga_credentials.AnonymousCredentials()
- ).test_iam_permissions._get_unset_required_fields(jsonified_request)
- jsonified_request.update(unset_fields)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CheckConsistencyRequest()
- # verify required fields with non-default values are left alone
- assert "resource" in jsonified_request
- assert jsonified_request["resource"] == "resource_value"
- assert "permissions" in jsonified_request
- assert jsonified_request["permissions"] == "permissions_value"
+ assert args[0] == request_msg
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_snapshot_table_empty_call_rest():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
- request = request_type(**request_init)
- # Designate an appropriate value for the returned response.
- return_value = iam_policy_pb2.TestIamPermissionsResponse()
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(Session, "request") as req:
- # We need to mock transcode() because providing default values
- # for required fields will fail the real version if the http_options
- # expect actual values for those fields.
- with mock.patch.object(path_template, "transcode") as transcode:
- # A uri without fields and an empty body will force all the
- # request fields to show up in the query_params.
- pb_request = request
- transcode_result = {
- "uri": "v1/sample_method",
- "method": "post",
- "query_params": pb_request,
- }
- transcode_result["body"] = pb_request
- transcode.return_value = transcode_result
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.snapshot_table), "__call__") as call:
+ client.snapshot_table(request=None)
- response_value = Response()
- response_value.status_code = 200
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.SnapshotTableRequest()
- json_return_value = json_format.MessageToJson(return_value)
+ assert args[0] == request_msg
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.test_iam_permissions(request)
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_snapshot_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- expected_params = [("$alt", "json;enum-encoding=int")]
- actual_params = req.call_args.kwargs["params"]
- assert expected_params == actual_params
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_snapshot), "__call__") as call:
+ client.get_snapshot(request=None)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetSnapshotRequest()
-def test_test_iam_permissions_rest_unset_required_fields():
- transport = transports.BigtableTableAdminRestTransport(
- credentials=ga_credentials.AnonymousCredentials
- )
+ assert args[0] == request_msg
- unset_fields = transport.test_iam_permissions._get_unset_required_fields({})
- assert set(unset_fields) == (
- set(())
- & set(
- (
- "resource",
- "permissions",
- )
- )
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_snapshots_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_snapshots), "__call__") as call:
+ client.list_snapshots(request=None)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_test_iam_permissions_rest_interceptors(null_interceptor):
- transport = transports.BigtableTableAdminRestTransport(
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListSnapshotsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_snapshot_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None
- if null_interceptor
- else transports.BigtableTableAdminRestInterceptor(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "post_test_iam_permissions"
- ) as post, mock.patch.object(
- transports.BigtableTableAdminRestInterceptor, "pre_test_iam_permissions"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = iam_policy_pb2.TestIamPermissionsRequest()
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = json_format.MessageToJson(
- iam_policy_pb2.TestIamPermissionsResponse()
- )
- request = iam_policy_pb2.TestIamPermissionsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = iam_policy_pb2.TestIamPermissionsResponse()
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_snapshot), "__call__") as call:
+ client.delete_snapshot(request=None)
- client.test_iam_permissions(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteSnapshotRequest()
- pre.assert_called_once()
- post.assert_called_once()
+ assert args[0] == request_msg
-def test_test_iam_permissions_rest_bad_request(
- transport: str = "rest", request_type=iam_policy_pb2.TestIamPermissionsRequest
-):
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_create_backup_empty_call_rest():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # send a request that will satisfy transcoding
- request_init = {"resource": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.create_backup), "__call__") as call:
+ client.create_backup(request=None)
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.test_iam_permissions(request)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CreateBackupRequest()
+ assert args[0] == request_msg
-def test_test_iam_permissions_rest_flattened():
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_backup_empty_call_rest():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = iam_policy_pb2.TestIamPermissionsResponse()
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_backup), "__call__") as call:
+ client.get_backup(request=None)
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "resource": "projects/sample1/instances/sample2/tables/sample3"
- }
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.GetBackupRequest()
- # get truthy value for each flattened field
- mock_args = dict(
- resource="resource_value",
- permissions=["permissions_value"],
- )
- mock_args.update(sample_request)
+ assert args[0] == request_msg
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- json_return_value = json_format.MessageToJson(return_value)
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- client.test_iam_permissions(**mock_args)
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_update_backup_empty_call_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
- # Establish that the underlying call was made with the expected
- # request object values.
- assert len(req.mock_calls) == 1
- _, args, _ = req.mock_calls[0]
- assert path_template.validate(
- "%s/v2/{resource=projects/*/instances/*/tables/*}:testIamPermissions"
- % client.transport._host,
- args[1],
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.update_backup), "__call__") as call:
+ client.update_backup(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.UpdateBackupRequest()
+ assert args[0] == request_msg
-def test_test_iam_permissions_rest_flattened_error(transport: str = "rest"):
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_delete_backup_empty_call_rest():
client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # Attempting to call a method with both a request object and flattened
- # fields is an error.
- with pytest.raises(ValueError):
- client.test_iam_permissions(
- iam_policy_pb2.TestIamPermissionsRequest(),
- resource="resource_value",
- permissions=["permissions_value"],
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.delete_backup), "__call__") as call:
+ client.delete_backup(request=None)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.DeleteBackupRequest()
-def test_test_iam_permissions_rest_error():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
+ assert args[0] == request_msg
-def test_credentials_transport_error():
- # It is an error to provide credentials and a transport instance.
- transport = transports.BigtableTableAdminGrpcTransport(
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_list_backups_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- with pytest.raises(ValueError):
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
- # It is an error to provide a credentials file and a transport instance.
- transport = transports.BigtableTableAdminGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- with pytest.raises(ValueError):
- client = BigtableTableAdminClient(
- client_options={"credentials_file": "credentials.json"},
- transport=transport,
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.list_backups), "__call__") as call:
+ client.list_backups(request=None)
- # It is an error to provide an api_key and a transport instance.
- transport = transports.BigtableTableAdminGrpcTransport(
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.ListBackupsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_restore_table_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- options = client_options.ClientOptions()
- options.api_key = "api_key"
- with pytest.raises(ValueError):
- client = BigtableTableAdminClient(
- client_options=options,
- transport=transport,
- )
- # It is an error to provide an api_key and a credential.
- options = client_options.ClientOptions()
- options.api_key = "api_key"
- with pytest.raises(ValueError):
- client = BigtableTableAdminClient(
- client_options=options, credentials=ga_credentials.AnonymousCredentials()
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.restore_table), "__call__") as call:
+ client.restore_table(request=None)
- # It is an error to provide scopes and a transport instance.
- transport = transports.BigtableTableAdminGrpcTransport(
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.RestoreTableRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_copy_backup_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- with pytest.raises(ValueError):
- client = BigtableTableAdminClient(
- client_options={"scopes": ["1", "2"]},
- transport=transport,
- )
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.copy_backup), "__call__") as call:
+ client.copy_backup(request=None)
-def test_transport_instance():
- # A client may be instantiated with a custom transport instance.
- transport = transports.BigtableTableAdminGrpcTransport(
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable_table_admin.CopyBackupRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_get_iam_policy_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- client = BigtableTableAdminClient(transport=transport)
- assert client.transport is transport
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call:
+ client.get_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.GetIamPolicyRequest()
-def test_transport_get_channel():
- # A client may be instantiated with a custom transport instance.
- transport = transports.BigtableTableAdminGrpcTransport(
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_set_iam_policy_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- channel = transport.grpc_channel
- assert channel
- transport = transports.BigtableTableAdminGrpcAsyncIOTransport(
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call:
+ client.set_iam_policy(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.SetIamPolicyRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_test_iam_permissions_empty_call_rest():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- channel = transport.grpc_channel
- assert channel
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.test_iam_permissions), "__call__"
+ ) as call:
+ client.test_iam_permissions(request=None)
-@pytest.mark.parametrize(
- "transport_class",
- [
- transports.BigtableTableAdminGrpcTransport,
- transports.BigtableTableAdminGrpcAsyncIOTransport,
- transports.BigtableTableAdminRestTransport,
- ],
-)
-def test_transport_adc(transport_class):
- # Test default credentials are used if not provided.
- with mock.patch.object(google.auth, "default") as adc:
- adc.return_value = (ga_credentials.AnonymousCredentials(), None)
- transport_class()
- adc.assert_called_once()
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = iam_policy_pb2.TestIamPermissionsRequest()
+ assert args[0] == request_msg
-@pytest.mark.parametrize(
- "transport_name",
- [
- "grpc",
- "rest",
- ],
-)
-def test_transport_kind(transport_name):
- transport = BigtableTableAdminClient.get_transport_class(transport_name)(
+
+def test_bigtable_table_admin_rest_lro_client():
+ client = BigtableTableAdminClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+ transport = client.transport
+
+ # Ensure that we have an api-core operations client.
+ assert isinstance(
+ transport.operations_client,
+ operations_v1.AbstractOperationsClient,
)
- assert transport.kind == transport_name
+
+ # Ensure that subsequent calls to the property send the exact same object.
+ assert transport.operations_client is transport.operations_client
def test_transport_grpc_default():
@@ -23717,23 +24292,6 @@ def test_bigtable_table_admin_http_transport_client_cert_source_for_mtls():
mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback)
-def test_bigtable_table_admin_rest_lro_client():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
- transport = client.transport
-
- # Ensure that we have a api-core operations client.
- assert isinstance(
- transport.operations_client,
- operations_v1.AbstractOperationsClient,
- )
-
- # Ensure that subsequent calls to the property send the exact same object.
- assert transport.operations_client is transport.operations_client
-
-
@pytest.mark.parametrize(
"transport_name",
[
@@ -24375,36 +24933,41 @@ def test_client_with_default_client_info():
prep.assert_called_once_with(client_info)
+def test_transport_close_grpc():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc"
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "_grpc_channel")), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
+
+
@pytest.mark.asyncio
-async def test_transport_close_async():
+async def test_transport_close_grpc_asyncio():
client = BigtableTableAdminAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
+ credentials=async_anonymous_credentials(), transport="grpc_asyncio"
)
with mock.patch.object(
- type(getattr(client.transport, "grpc_channel")), "close"
+ type(getattr(client.transport, "_grpc_channel")), "close"
) as close:
async with client:
close.assert_not_called()
close.assert_called_once()
-def test_transport_close():
- transports = {
- "rest": "_session",
- "grpc": "_grpc_channel",
- }
-
- for transport, close_name in transports.items():
- client = BigtableTableAdminClient(
- credentials=ga_credentials.AnonymousCredentials(), transport=transport
- )
- with mock.patch.object(
- type(getattr(client.transport, close_name)), "close"
- ) as close:
- with client:
- close.assert_not_called()
- close.assert_called_once()
+def test_transport_close_rest():
+ client = BigtableTableAdminClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "_session")), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
def test_client_ctx():
diff --git a/tests/unit/gapic/bigtable_v2/test_bigtable.py b/tests/unit/gapic/bigtable_v2/test_bigtable.py
index 2be864732..37b4bbfca 100644
--- a/tests/unit/gapic/bigtable_v2/test_bigtable.py
+++ b/tests/unit/gapic/bigtable_v2/test_bigtable.py
@@ -24,7 +24,7 @@
import grpc
from grpc.experimental import aio
-from collections.abc import Iterable
+from collections.abc import Iterable, AsyncIterable
from google.protobuf import json_format
import json
import math
@@ -37,6 +37,13 @@
from requests.sessions import Session
from google.protobuf import json_format
+try:
+ from google.auth.aio import credentials as ga_credentials_async
+
+ HAS_GOOGLE_AUTH_AIO = True
+except ImportError: # pragma: NO COVER
+ HAS_GOOGLE_AUTH_AIO = False
+
from google.api_core import client_options
from google.api_core import exceptions as core_exceptions
from google.api_core import gapic_v1
@@ -60,10 +67,24 @@
import google.auth
+async def mock_async_gen(data, chunk_size=1):
+ for i in range(0, len(data)): # pragma: NO COVER
+ chunk = data[i : i + chunk_size]
+ yield chunk.encode("utf-8")
+
+
def client_cert_source_callback():
return b"cert bytes", b"key bytes"
+# TODO: use async auth anon credentials by default once the minimum version of google-auth is upgraded.
+# See related issue: https://github.com/googleapis/gapic-generator-python/issues/2107.
+def async_anonymous_credentials():
+ if HAS_GOOGLE_AUTH_AIO:
+ return ga_credentials_async.AnonymousCredentials()
+ return ga_credentials.AnonymousCredentials()
+
+
# If default endpoint is localhost, then default mtls endpoint will be the same.
# This method modifies the default endpoint so the client can produce a different
# mtls endpoint for endpoint testing purposes.
@@ -275,86 +296,6 @@ def test__get_universe_domain():
assert str(excinfo.value) == "Universe Domain cannot be an empty string."
-@pytest.mark.parametrize(
- "client_class,transport_class,transport_name",
- [
- (BigtableClient, transports.BigtableGrpcTransport, "grpc"),
- (BigtableClient, transports.BigtableRestTransport, "rest"),
- ],
-)
-def test__validate_universe_domain(client_class, transport_class, transport_name):
- client = client_class(
- transport=transport_class(credentials=ga_credentials.AnonymousCredentials())
- )
- assert client._validate_universe_domain() == True
-
- # Test the case when universe is already validated.
- assert client._validate_universe_domain() == True
-
- if transport_name == "grpc":
- # Test the case where credentials are provided by the
- # `local_channel_credentials`. The default universes in both match.
- channel = grpc.secure_channel(
- "http://localhost/", grpc.local_channel_credentials()
- )
- client = client_class(transport=transport_class(channel=channel))
- assert client._validate_universe_domain() == True
-
- # Test the case where credentials do not exist: e.g. a transport is provided
- # with no credentials. Validation should still succeed because there is no
- # mismatch with non-existent credentials.
- channel = grpc.secure_channel(
- "http://localhost/", grpc.local_channel_credentials()
- )
- transport = transport_class(channel=channel)
- transport._credentials = None
- client = client_class(transport=transport)
- assert client._validate_universe_domain() == True
-
- # TODO: This is needed to cater for older versions of google-auth
- # Make this test unconditional once the minimum supported version of
- # google-auth becomes 2.23.0 or higher.
- google_auth_major, google_auth_minor = [
- int(part) for part in google.auth.__version__.split(".")[0:2]
- ]
- if google_auth_major > 2 or (google_auth_major == 2 and google_auth_minor >= 23):
- credentials = ga_credentials.AnonymousCredentials()
- credentials._universe_domain = "foo.com"
- # Test the case when there is a universe mismatch from the credentials.
- client = client_class(transport=transport_class(credentials=credentials))
- with pytest.raises(ValueError) as excinfo:
- client._validate_universe_domain()
- assert (
- str(excinfo.value)
- == "The configured universe domain (googleapis.com) does not match the universe domain found in the credentials (foo.com). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
- )
-
- # Test the case when there is a universe mismatch from the client.
- #
- # TODO: Make this test unconditional once the minimum supported version of
- # google-api-core becomes 2.15.0 or higher.
- api_core_major, api_core_minor = [
- int(part) for part in api_core_version.__version__.split(".")[0:2]
- ]
- if api_core_major > 2 or (api_core_major == 2 and api_core_minor >= 15):
- client = client_class(
- client_options={"universe_domain": "bar.com"},
- transport=transport_class(
- credentials=ga_credentials.AnonymousCredentials(),
- ),
- )
- with pytest.raises(ValueError) as excinfo:
- client._validate_universe_domain()
- assert (
- str(excinfo.value)
- == "The configured universe domain (bar.com) does not match the universe domain found in the credentials (googleapis.com). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
- )
-
- # Test that ValueError is raised if universe_domain is provided via client options and credentials is None
- with pytest.raises(ValueError):
- client._compare_universes("foo.bar", None)
-
-
@pytest.mark.parametrize(
"client_class,transport_name",
[
@@ -1110,25 +1051,6 @@ def test_read_rows(request_type, transport: str = "grpc"):
assert isinstance(message, bigtable.ReadRowsResponse)
-def test_read_rows_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.read_rows()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ReadRowsRequest()
-
-
def test_read_rows_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1196,35 +1118,13 @@ def test_read_rows_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_read_rows_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
- call.return_value.read = mock.AsyncMock(
- side_effect=[bigtable.ReadRowsResponse()]
- )
- response = await client.read_rows()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ReadRowsRequest()
-
-
@pytest.mark.asyncio
async def test_read_rows_async_use_cached_wrapped_rpc(transport: str = "grpc_asyncio"):
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1263,7 +1163,7 @@ async def test_read_rows_async(
transport: str = "grpc_asyncio", request_type=bigtable.ReadRowsRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1296,70 +1196,6 @@ async def test_read_rows_async_from_dict():
await test_read_rows_async(request_type=dict)
-def test_read_rows_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ReadRowsRequest(
- **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
- call.return_value = iter([bigtable.ReadRowsResponse()])
- client.read_rows(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ReadRowsRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
- call.return_value = iter([bigtable.ReadRowsResponse()])
- client.read_rows(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ReadRowsRequest(
- **{
- "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
- call.return_value = iter([bigtable.ReadRowsResponse()])
- client.read_rows(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_read_rows_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -1406,7 +1242,7 @@ def test_read_rows_flattened_error():
@pytest.mark.asyncio
async def test_read_rows_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -1437,7 +1273,7 @@ async def test_read_rows_flattened_async():
@pytest.mark.asyncio
async def test_read_rows_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -1484,25 +1320,6 @@ def test_sample_row_keys(request_type, transport: str = "grpc"):
assert isinstance(message, bigtable.SampleRowKeysResponse)
-def test_sample_row_keys_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.sample_row_keys()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.SampleRowKeysRequest()
-
-
def test_sample_row_keys_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1570,28 +1387,6 @@ def test_sample_row_keys_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_sample_row_keys_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
- call.return_value.read = mock.AsyncMock(
- side_effect=[bigtable.SampleRowKeysResponse()]
- )
- response = await client.sample_row_keys()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.SampleRowKeysRequest()
-
-
@pytest.mark.asyncio
async def test_sample_row_keys_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -1600,7 +1395,7 @@ async def test_sample_row_keys_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1639,7 +1434,7 @@ async def test_sample_row_keys_async(
transport: str = "grpc_asyncio", request_type=bigtable.SampleRowKeysRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -1672,70 +1467,6 @@ async def test_sample_row_keys_async_from_dict():
await test_sample_row_keys_async(request_type=dict)
-def test_sample_row_keys_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.SampleRowKeysRequest(
- **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
- call.return_value = iter([bigtable.SampleRowKeysResponse()])
- client.sample_row_keys(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.SampleRowKeysRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
- call.return_value = iter([bigtable.SampleRowKeysResponse()])
- client.sample_row_keys(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.SampleRowKeysRequest(
- **{
- "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
- call.return_value = iter([bigtable.SampleRowKeysResponse()])
- client.sample_row_keys(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_sample_row_keys_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -1782,7 +1513,7 @@ def test_sample_row_keys_flattened_error():
@pytest.mark.asyncio
async def test_sample_row_keys_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -1813,7 +1544,7 @@ async def test_sample_row_keys_flattened_async():
@pytest.mark.asyncio
async def test_sample_row_keys_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -1859,25 +1590,6 @@ def test_mutate_row(request_type, transport: str = "grpc"):
assert isinstance(response, bigtable.MutateRowResponse)
-def test_mutate_row_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.mutate_row()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.MutateRowRequest()
-
-
def test_mutate_row_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -1945,34 +1657,13 @@ def test_mutate_row_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_mutate_row_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable.MutateRowResponse()
- )
- response = await client.mutate_row()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.MutateRowRequest()
-
-
@pytest.mark.asyncio
async def test_mutate_row_async_use_cached_wrapped_rpc(transport: str = "grpc_asyncio"):
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2011,7 +1702,7 @@ async def test_mutate_row_async(
transport: str = "grpc_asyncio", request_type=bigtable.MutateRowRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2042,78 +1733,14 @@ async def test_mutate_row_async_from_dict():
await test_mutate_row_async(request_type=dict)
-def test_mutate_row_routing_parameters():
+def test_mutate_row_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
)
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.MutateRowRequest(
- **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- )
-
# Mock the actual call within the gRPC stub, and fake the request.
with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
- call.return_value = bigtable.MutateRowResponse()
- client.mutate_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.MutateRowRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
- call.return_value = bigtable.MutateRowResponse()
- client.mutate_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.MutateRowRequest(
- **{
- "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
- call.return_value = bigtable.MutateRowResponse()
- client.mutate_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
-def test_mutate_row_flattened():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
- # Designate an appropriate return value for the call.
+ # Designate an appropriate return value for the call.
call.return_value = bigtable.MutateRowResponse()
# Call the method with a truthy value for each flattened field,
# using the keyword arguments to the method.
@@ -2174,7 +1801,7 @@ def test_mutate_row_flattened_error():
@pytest.mark.asyncio
async def test_mutate_row_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2223,7 +1850,7 @@ async def test_mutate_row_flattened_async():
@pytest.mark.asyncio
async def test_mutate_row_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2276,25 +1903,6 @@ def test_mutate_rows(request_type, transport: str = "grpc"):
assert isinstance(message, bigtable.MutateRowsResponse)
-def test_mutate_rows_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.mutate_rows()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.MutateRowsRequest()
-
-
def test_mutate_rows_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2362,28 +1970,6 @@ def test_mutate_rows_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_mutate_rows_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
- call.return_value.read = mock.AsyncMock(
- side_effect=[bigtable.MutateRowsResponse()]
- )
- response = await client.mutate_rows()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.MutateRowsRequest()
-
-
@pytest.mark.asyncio
async def test_mutate_rows_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -2392,7 +1978,7 @@ async def test_mutate_rows_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2431,7 +2017,7 @@ async def test_mutate_rows_async(
transport: str = "grpc_asyncio", request_type=bigtable.MutateRowsRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2464,70 +2050,6 @@ async def test_mutate_rows_async_from_dict():
await test_mutate_rows_async(request_type=dict)
-def test_mutate_rows_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.MutateRowsRequest(
- **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
- call.return_value = iter([bigtable.MutateRowsResponse()])
- client.mutate_rows(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.MutateRowsRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
- call.return_value = iter([bigtable.MutateRowsResponse()])
- client.mutate_rows(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.MutateRowsRequest(
- **{
- "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
- call.return_value = iter([bigtable.MutateRowsResponse()])
- client.mutate_rows(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_mutate_rows_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -2579,7 +2101,7 @@ def test_mutate_rows_flattened_error():
@pytest.mark.asyncio
async def test_mutate_rows_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -2614,7 +2136,7 @@ async def test_mutate_rows_flattened_async():
@pytest.mark.asyncio
async def test_mutate_rows_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -2666,27 +2188,6 @@ def test_check_and_mutate_row(request_type, transport: str = "grpc"):
assert response.predicate_matched is True
-def test_check_and_mutate_row_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_and_mutate_row), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.check_and_mutate_row()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.CheckAndMutateRowRequest()
-
-
def test_check_and_mutate_row_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -2760,31 +2261,6 @@ def test_check_and_mutate_row_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_check_and_mutate_row_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_and_mutate_row), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable.CheckAndMutateRowResponse(
- predicate_matched=True,
- )
- )
- response = await client.check_and_mutate_row()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.CheckAndMutateRowRequest()
-
-
@pytest.mark.asyncio
async def test_check_and_mutate_row_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -2793,7 +2269,7 @@ async def test_check_and_mutate_row_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2832,7 +2308,7 @@ async def test_check_and_mutate_row_async(
transport: str = "grpc_asyncio", request_type=bigtable.CheckAndMutateRowRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -2868,76 +2344,6 @@ async def test_check_and_mutate_row_async_from_dict():
await test_check_and_mutate_row_async(request_type=dict)
-def test_check_and_mutate_row_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.CheckAndMutateRowRequest(
- **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_and_mutate_row), "__call__"
- ) as call:
- call.return_value = bigtable.CheckAndMutateRowResponse()
- client.check_and_mutate_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.CheckAndMutateRowRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_and_mutate_row), "__call__"
- ) as call:
- call.return_value = bigtable.CheckAndMutateRowResponse()
- client.check_and_mutate_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.CheckAndMutateRowRequest(
- **{
- "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.check_and_mutate_row), "__call__"
- ) as call:
- call.return_value = bigtable.CheckAndMutateRowResponse()
- client.check_and_mutate_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_check_and_mutate_row_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -3058,7 +2464,7 @@ def test_check_and_mutate_row_flattened_error():
@pytest.mark.asyncio
async def test_check_and_mutate_row_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3143,7 +2549,7 @@ async def test_check_and_mutate_row_flattened_async():
@pytest.mark.asyncio
async def test_check_and_mutate_row_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3211,25 +2617,6 @@ def test_ping_and_warm(request_type, transport: str = "grpc"):
assert isinstance(response, bigtable.PingAndWarmResponse)
-def test_ping_and_warm_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.ping_and_warm()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.PingAndWarmRequest()
-
-
def test_ping_and_warm_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3295,27 +2682,6 @@ def test_ping_and_warm_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_ping_and_warm_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable.PingAndWarmResponse()
- )
- response = await client.ping_and_warm()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.PingAndWarmRequest()
-
-
@pytest.mark.asyncio
async def test_ping_and_warm_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3324,7 +2690,7 @@ async def test_ping_and_warm_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3363,7 +2729,7 @@ async def test_ping_and_warm_async(
transport: str = "grpc_asyncio", request_type=bigtable.PingAndWarmRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3394,49 +2760,6 @@ async def test_ping_and_warm_async_from_dict():
await test_ping_and_warm_async(request_type=dict)
-def test_ping_and_warm_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.PingAndWarmRequest(
- **{"name": "projects/sample1/instances/sample2"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
- call.return_value = bigtable.PingAndWarmResponse()
- client.ping_and_warm(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.PingAndWarmRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
- call.return_value = bigtable.PingAndWarmResponse()
- client.ping_and_warm(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_ping_and_warm_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -3483,7 +2806,7 @@ def test_ping_and_warm_flattened_error():
@pytest.mark.asyncio
async def test_ping_and_warm_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3516,7 +2839,7 @@ async def test_ping_and_warm_flattened_async():
@pytest.mark.asyncio
async def test_ping_and_warm_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3564,27 +2887,6 @@ def test_read_modify_write_row(request_type, transport: str = "grpc"):
assert isinstance(response, bigtable.ReadModifyWriteRowResponse)
-def test_read_modify_write_row_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_modify_write_row), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.read_modify_write_row()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ReadModifyWriteRowRequest()
-
-
def test_read_modify_write_row_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -3659,29 +2961,6 @@ def test_read_modify_write_row_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_read_modify_write_row_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_modify_write_row), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
- bigtable.ReadModifyWriteRowResponse()
- )
- response = await client.read_modify_write_row()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ReadModifyWriteRowRequest()
-
-
@pytest.mark.asyncio
async def test_read_modify_write_row_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -3690,7 +2969,7 @@ async def test_read_modify_write_row_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3729,7 +3008,7 @@ async def test_read_modify_write_row_async(
transport: str = "grpc_asyncio", request_type=bigtable.ReadModifyWriteRowRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -3762,76 +3041,6 @@ async def test_read_modify_write_row_async_from_dict():
await test_read_modify_write_row_async(request_type=dict)
-def test_read_modify_write_row_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ReadModifyWriteRowRequest(
- **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_modify_write_row), "__call__"
- ) as call:
- call.return_value = bigtable.ReadModifyWriteRowResponse()
- client.read_modify_write_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ReadModifyWriteRowRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_modify_write_row), "__call__"
- ) as call:
- call.return_value = bigtable.ReadModifyWriteRowResponse()
- client.read_modify_write_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ReadModifyWriteRowRequest(
- **{
- "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
- }
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_modify_write_row), "__call__"
- ) as call:
- call.return_value = bigtable.ReadModifyWriteRowResponse()
- client.read_modify_write_row(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_read_modify_write_row_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -3890,7 +3099,7 @@ def test_read_modify_write_row_flattened_error():
@pytest.mark.asyncio
async def test_read_modify_write_row_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -3933,7 +3142,7 @@ async def test_read_modify_write_row_flattened_async():
@pytest.mark.asyncio
async def test_read_modify_write_row_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -3990,27 +3199,6 @@ def test_generate_initial_change_stream_partitions(
)
-def test_generate_initial_change_stream_partitions_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.generate_initial_change_stream_partitions), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.generate_initial_change_stream_partitions()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.GenerateInitialChangeStreamPartitionsRequest()
-
-
def test_generate_initial_change_stream_partitions_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4083,30 +3271,6 @@ def test_generate_initial_change_stream_partitions_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_generate_initial_change_stream_partitions_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.generate_initial_change_stream_partitions), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
- call.return_value.read = mock.AsyncMock(
- side_effect=[bigtable.GenerateInitialChangeStreamPartitionsResponse()]
- )
- response = await client.generate_initial_change_stream_partitions()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.GenerateInitialChangeStreamPartitionsRequest()
-
-
@pytest.mark.asyncio
async def test_generate_initial_change_stream_partitions_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4115,7 +3279,7 @@ async def test_generate_initial_change_stream_partitions_async_use_cached_wrappe
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4155,7 +3319,7 @@ async def test_generate_initial_change_stream_partitions_async(
request_type=bigtable.GenerateInitialChangeStreamPartitionsRequest,
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4226,7 +3390,7 @@ def test_generate_initial_change_stream_partitions_field_headers():
@pytest.mark.asyncio
async def test_generate_initial_change_stream_partitions_field_headers_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4308,7 +3472,7 @@ def test_generate_initial_change_stream_partitions_flattened_error():
@pytest.mark.asyncio
async def test_generate_initial_change_stream_partitions_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4343,7 +3507,7 @@ async def test_generate_initial_change_stream_partitions_flattened_async():
@pytest.mark.asyncio
async def test_generate_initial_change_stream_partitions_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4392,27 +3556,6 @@ def test_read_change_stream(request_type, transport: str = "grpc"):
assert isinstance(message, bigtable.ReadChangeStreamResponse)
-def test_read_change_stream_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_change_stream), "__call__"
- ) as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.read_change_stream()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ReadChangeStreamRequest()
-
-
def test_read_change_stream_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4484,30 +3627,6 @@ def test_read_change_stream_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_read_change_stream_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(
- type(client.transport.read_change_stream), "__call__"
- ) as call:
- # Designate an appropriate return value for the call.
- call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
- call.return_value.read = mock.AsyncMock(
- side_effect=[bigtable.ReadChangeStreamResponse()]
- )
- response = await client.read_change_stream()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ReadChangeStreamRequest()
-
-
@pytest.mark.asyncio
async def test_read_change_stream_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4516,7 +3635,7 @@ async def test_read_change_stream_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4555,7 +3674,7 @@ async def test_read_change_stream_async(
transport: str = "grpc_asyncio", request_type=bigtable.ReadChangeStreamRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4624,7 +3743,7 @@ def test_read_change_stream_field_headers():
@pytest.mark.asyncio
async def test_read_change_stream_field_headers_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Any value that is part of the HTTP/1.1 URI should be sent as
@@ -4704,7 +3823,7 @@ def test_read_change_stream_flattened_error():
@pytest.mark.asyncio
async def test_read_change_stream_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -4737,7 +3856,7 @@ async def test_read_change_stream_flattened_async():
@pytest.mark.asyncio
async def test_read_change_stream_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -4784,25 +3903,6 @@ def test_execute_query(request_type, transport: str = "grpc"):
assert isinstance(message, bigtable.ExecuteQueryResponse)
-def test_execute_query_empty_call():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
- call.return_value.name = (
- "foo" # operation_request.operation in compute client(s) expect a string.
- )
- client.execute_query()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ExecuteQueryRequest()
-
-
def test_execute_query_non_empty_request_with_auto_populated_field():
# This test is a coverage failsafe to make sure that UUID4 fields are
# automatically populated, according to AIP-4235, with non-empty requests.
@@ -4870,28 +3970,6 @@ def test_execute_query_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.asyncio
-async def test_execute_query_empty_call_async():
- # This test is a coverage failsafe to make sure that totally empty calls,
- # i.e. request == None and no flattened fields passed, work.
- client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
- # Designate an appropriate return value for the call.
- call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
- call.return_value.read = mock.AsyncMock(
- side_effect=[bigtable.ExecuteQueryResponse()]
- )
- response = await client.execute_query()
- call.assert_called()
- _, args, _ = call.mock_calls[0]
- assert args[0] == bigtable.ExecuteQueryRequest()
-
-
@pytest.mark.asyncio
async def test_execute_query_async_use_cached_wrapped_rpc(
transport: str = "grpc_asyncio",
@@ -4900,7 +3978,7 @@ async def test_execute_query_async_use_cached_wrapped_rpc(
# instead of constructing them on each call
with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn:
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4939,7 +4017,7 @@ async def test_execute_query_async(
transport: str = "grpc_asyncio", request_type=bigtable.ExecuteQueryRequest
):
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
transport=transport,
)
@@ -4972,49 +4050,6 @@ async def test_execute_query_async_from_dict():
await test_execute_query_async(request_type=dict)
-def test_execute_query_routing_parameters():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- )
-
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ExecuteQueryRequest(
- **{"instance_name": "projects/sample1/instances/sample2"}
- )
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
- call.return_value = iter([bigtable.ExecuteQueryResponse()])
- client.execute_query(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
- # Any value that is part of the HTTP/1.1 URI should be sent as
- # a field header. Set these to a non-empty value.
- request = bigtable.ExecuteQueryRequest(**{"app_profile_id": "sample1"})
-
- # Mock the actual call within the gRPC stub, and fake the request.
- with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
- call.return_value = iter([bigtable.ExecuteQueryResponse()])
- client.execute_query(request)
-
- # Establish that the underlying gRPC stub method was called.
- assert len(call.mock_calls) == 1
- _, args, _ = call.mock_calls[0]
- assert args[0] == request
-
- _, _, kw = call.mock_calls[0]
- # This test doesn't assert anything useful.
- assert kw["metadata"]
-
-
def test_execute_query_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -5066,7 +4101,7 @@ def test_execute_query_flattened_error():
@pytest.mark.asyncio
async def test_execute_query_flattened_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Mock the actual call within the gRPC stub, and fake the request.
@@ -5101,7 +4136,7 @@ async def test_execute_query_flattened_async():
@pytest.mark.asyncio
async def test_execute_query_flattened_error_async():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
+ credentials=async_anonymous_credentials(),
)
# Attempting to call a method with both a request object and flattened
@@ -5115,53 +4150,6 @@ async def test_execute_query_flattened_error_async():
)
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.ReadRowsRequest,
- dict,
- ],
-)
-def test_read_rows_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.ReadRowsResponse(
- last_scanned_row_key=b"last_scanned_row_key_blob",
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.ReadRowsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- json_return_value = "[{}]".format(json_return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- response = client.read_rows(request)
-
- assert isinstance(response, Iterable)
- response = next(response)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.ReadRowsResponse)
- assert response.last_scanned_row_key == b"last_scanned_row_key_blob"
-
-
def test_read_rows_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -5198,84 +4186,6 @@ def test_read_rows_rest_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_read_rows_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
- )
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_read_rows"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_read_rows"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.ReadRowsRequest.pb(bigtable.ReadRowsRequest())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.ReadRowsResponse.to_json(
- bigtable.ReadRowsResponse()
- )
- req.return_value._content = "[{}]".format(req.return_value._content)
-
- request = bigtable.ReadRowsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.ReadRowsResponse()
-
- client.read_rows(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_read_rows_rest_bad_request(
- transport: str = "rest", request_type=bigtable.ReadRowsRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.read_rows(request)
-
-
def test_read_rows_rest_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -5340,61 +4250,6 @@ def test_read_rows_rest_flattened_error(transport: str = "rest"):
)
-def test_read_rows_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.SampleRowKeysRequest,
- dict,
- ],
-)
-def test_sample_row_keys_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.SampleRowKeysResponse(
- row_key=b"row_key_blob",
- offset_bytes=1293,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.SampleRowKeysResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- json_return_value = "[{}]".format(json_return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- response = client.sample_row_keys(request)
-
- assert isinstance(response, Iterable)
- response = next(response)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.SampleRowKeysResponse)
- assert response.row_key == b"row_key_blob"
- assert response.offset_bytes == 1293
-
-
def test_sample_row_keys_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -5431,104 +4286,26 @@ def test_sample_row_keys_rest_use_cached_wrapped_rpc():
assert mock_rpc.call_count == 2
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_sample_row_keys_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
+def test_sample_row_keys_rest_flattened():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ transport="rest",
)
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_sample_row_keys"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_sample_row_keys"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.SampleRowKeysRequest.pb(bigtable.SampleRowKeysRequest())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.SampleRowKeysResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
}
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.SampleRowKeysResponse.to_json(
- bigtable.SampleRowKeysResponse()
- )
- req.return_value._content = "[{}]".format(req.return_value._content)
-
- request = bigtable.SampleRowKeysRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.SampleRowKeysResponse()
-
- client.sample_row_keys(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_sample_row_keys_rest_bad_request(
- transport: str = "rest", request_type=bigtable.SampleRowKeysRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.sample_row_keys(request)
-
-
-def test_sample_row_keys_rest_flattened():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.SampleRowKeysResponse()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "table_name": "projects/sample1/instances/sample2/tables/sample3"
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- table_name="table_name_value",
- app_profile_id="app_profile_id_value",
+ # get truthy value for each flattened field
+ mock_args = dict(
+ table_name="table_name_value",
+ app_profile_id="app_profile_id_value",
)
mock_args.update(sample_request)
@@ -5573,49 +4350,6 @@ def test_sample_row_keys_rest_flattened_error(transport: str = "rest"):
)
-def test_sample_row_keys_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.MutateRowRequest,
- dict,
- ],
-)
-def test_mutate_row_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.MutateRowResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.MutateRowResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.mutate_row(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.MutateRowResponse)
-
-
def test_mutate_row_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -5742,83 +4476,6 @@ def test_mutate_row_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_mutate_row_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
- )
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_mutate_row"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_mutate_row"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.MutateRowRequest.pb(bigtable.MutateRowRequest())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.MutateRowResponse.to_json(
- bigtable.MutateRowResponse()
- )
-
- request = bigtable.MutateRowRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.MutateRowResponse()
-
- client.mutate_row(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_mutate_row_rest_bad_request(
- transport: str = "rest", request_type=bigtable.MutateRowRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.mutate_row(request)
-
-
def test_mutate_row_rest_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -5892,56 +4549,6 @@ def test_mutate_row_rest_flattened_error(transport: str = "rest"):
)
-def test_mutate_row_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.MutateRowsRequest,
- dict,
- ],
-)
-def test_mutate_rows_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.MutateRowsResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.MutateRowsResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- json_return_value = "[{}]".format(json_return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- response = client.mutate_rows(request)
-
- assert isinstance(response, Iterable)
- response = next(response)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.MutateRowsResponse)
-
-
def test_mutate_rows_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -6058,94 +4665,16 @@ def test_mutate_rows_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("entries",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_mutate_rows_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
+def test_mutate_rows_rest_flattened():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ transport="rest",
)
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_mutate_rows"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_mutate_rows"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.MutateRowsRequest.pb(bigtable.MutateRowsRequest())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.MutateRowsResponse.to_json(
- bigtable.MutateRowsResponse()
- )
- req.return_value._content = "[{}]".format(req.return_value._content)
-
- request = bigtable.MutateRowsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.MutateRowsResponse()
-
- client.mutate_rows(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_mutate_rows_rest_bad_request(
- transport: str = "rest", request_type=bigtable.MutateRowsRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.mutate_rows(request)
-
-
-def test_mutate_rows_rest_flattened():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.MutateRowsResponse()
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.MutateRowsResponse()
# get arguments that satisfy an http rule for this method
sample_request = {
@@ -6202,52 +4731,6 @@ def test_mutate_rows_rest_flattened_error(transport: str = "rest"):
)
-def test_mutate_rows_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.CheckAndMutateRowRequest,
- dict,
- ],
-)
-def test_check_and_mutate_row_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.CheckAndMutateRowResponse(
- predicate_matched=True,
- )
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.CheckAndMutateRowResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.check_and_mutate_row(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.CheckAndMutateRowResponse)
- assert response.predicate_matched is True
-
-
def test_check_and_mutate_row_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -6372,85 +4855,6 @@ def test_check_and_mutate_row_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("rowKey",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_check_and_mutate_row_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
- )
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_check_and_mutate_row"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_check_and_mutate_row"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.CheckAndMutateRowRequest.pb(
- bigtable.CheckAndMutateRowRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.CheckAndMutateRowResponse.to_json(
- bigtable.CheckAndMutateRowResponse()
- )
-
- request = bigtable.CheckAndMutateRowRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.CheckAndMutateRowResponse()
-
- client.check_and_mutate_row(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_check_and_mutate_row_rest_bad_request(
- transport: str = "rest", request_type=bigtable.CheckAndMutateRowRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.check_and_mutate_row(request)
-
-
def test_check_and_mutate_row_rest_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -6556,49 +4960,6 @@ def test_check_and_mutate_row_rest_flattened_error(transport: str = "rest"):
)
-def test_check_and_mutate_row_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.PingAndWarmRequest,
- dict,
- ],
-)
-def test_ping_and_warm_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.PingAndWarmResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.PingAndWarmResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.ping_and_warm(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.PingAndWarmResponse)
-
-
def test_ping_and_warm_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -6717,96 +5078,19 @@ def test_ping_and_warm_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("name",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_ping_and_warm_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
+def test_ping_and_warm_rest_flattened():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ transport="rest",
)
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_ping_and_warm"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_ping_and_warm"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.PingAndWarmRequest.pb(bigtable.PingAndWarmRequest())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.PingAndWarmResponse.to_json(
- bigtable.PingAndWarmResponse()
- )
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.PingAndWarmResponse()
- request = bigtable.PingAndWarmRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.PingAndWarmResponse()
-
- client.ping_and_warm(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_ping_and_warm_rest_bad_request(
- transport: str = "rest", request_type=bigtable.PingAndWarmRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.ping_and_warm(request)
-
-
-def test_ping_and_warm_rest_flattened():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.PingAndWarmResponse()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {"name": "projects/sample1/instances/sample2"}
+ # get arguments that satisfy an http rule for this method
+ sample_request = {"name": "projects/sample1/instances/sample2"}
# get truthy value for each flattened field
mock_args = dict(
@@ -6851,49 +5135,6 @@ def test_ping_and_warm_rest_flattened_error(transport: str = "rest"):
)
-def test_ping_and_warm_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.ReadModifyWriteRowRequest,
- dict,
- ],
-)
-def test_read_modify_write_row_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.ReadModifyWriteRowResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.ReadModifyWriteRowResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- response = client.read_modify_write_row(request)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.ReadModifyWriteRowResponse)
-
-
def test_read_modify_write_row_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -7027,85 +5268,6 @@ def test_read_modify_write_row_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_read_modify_write_row_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
- )
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_read_modify_write_row"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_read_modify_write_row"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.ReadModifyWriteRowRequest.pb(
- bigtable.ReadModifyWriteRowRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.ReadModifyWriteRowResponse.to_json(
- bigtable.ReadModifyWriteRowResponse()
- )
-
- request = bigtable.ReadModifyWriteRowRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.ReadModifyWriteRowResponse()
-
- client.read_modify_write_row(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_read_modify_write_row_rest_bad_request(
- transport: str = "rest", request_type=bigtable.ReadModifyWriteRowRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.read_modify_write_row(request)
-
-
def test_read_modify_write_row_rest_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -7171,58 +5333,6 @@ def test_read_modify_write_row_rest_flattened_error(transport: str = "rest"):
)
-def test_read_modify_write_row_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.GenerateInitialChangeStreamPartitionsRequest,
- dict,
- ],
-)
-def test_generate_initial_change_stream_partitions_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse.pb(
- return_value
- )
- json_return_value = json_format.MessageToJson(return_value)
-
- json_return_value = "[{}]".format(json_return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- response = client.generate_initial_change_stream_partitions(request)
-
- assert isinstance(response, Iterable)
- response = next(response)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.GenerateInitialChangeStreamPartitionsResponse)
-
-
def test_generate_initial_change_stream_partitions_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -7361,113 +5471,28 @@ def test_generate_initial_change_stream_partitions_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("tableName",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_generate_initial_change_stream_partitions_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
+def test_generate_initial_change_stream_partitions_rest_flattened():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ transport="rest",
)
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor,
- "post_generate_initial_change_stream_partitions",
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor,
- "pre_generate_initial_change_stream_partitions",
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.GenerateInitialChangeStreamPartitionsRequest.pb(
- bigtable.GenerateInitialChangeStreamPartitionsRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
}
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = (
- bigtable.GenerateInitialChangeStreamPartitionsResponse.to_json(
- bigtable.GenerateInitialChangeStreamPartitionsResponse()
- )
+ # get truthy value for each flattened field
+ mock_args = dict(
+ table_name="table_name_value",
+ app_profile_id="app_profile_id_value",
)
- req.return_value._content = "[{}]".format(req.return_value._content)
-
- request = bigtable.GenerateInitialChangeStreamPartitionsRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse()
-
- client.generate_initial_change_stream_partitions(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_generate_initial_change_stream_partitions_rest_bad_request(
- transport: str = "rest",
- request_type=bigtable.GenerateInitialChangeStreamPartitionsRequest,
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.generate_initial_change_stream_partitions(request)
-
-
-def test_generate_initial_change_stream_partitions_rest_flattened():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {
- "table_name": "projects/sample1/instances/sample2/tables/sample3"
- }
-
- # get truthy value for each flattened field
- mock_args = dict(
- table_name="table_name_value",
- app_profile_id="app_profile_id_value",
- )
- mock_args.update(sample_request)
+ mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
@@ -7514,56 +5539,6 @@ def test_generate_initial_change_stream_partitions_rest_flattened_error(
)
-def test_generate_initial_change_stream_partitions_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.ReadChangeStreamRequest,
- dict,
- ],
-)
-def test_read_change_stream_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.ReadChangeStreamResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.ReadChangeStreamResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- json_return_value = "[{}]".format(json_return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- response = client.read_change_stream(request)
-
- assert isinstance(response, Iterable)
- response = next(response)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.ReadChangeStreamResponse)
-
-
def test_read_change_stream_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -7691,86 +5666,6 @@ def test_read_change_stream_rest_unset_required_fields():
assert set(unset_fields) == (set(()) & set(("tableName",)))
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_read_change_stream_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
- )
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_read_change_stream"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_read_change_stream"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.ReadChangeStreamRequest.pb(
- bigtable.ReadChangeStreamRequest()
- )
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
- }
-
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.ReadChangeStreamResponse.to_json(
- bigtable.ReadChangeStreamResponse()
- )
- req.return_value._content = "[{}]".format(req.return_value._content)
-
- request = bigtable.ReadChangeStreamRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.ReadChangeStreamResponse()
-
- client.read_change_stream(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
-
- pre.assert_called_once()
- post.assert_called_once()
-
-
-def test_read_change_stream_rest_bad_request(
- transport: str = "rest", request_type=bigtable.ReadChangeStreamRequest
-):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
- )
-
- # send a request that will satisfy transcoding
- request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.read_change_stream(request)
-
-
def test_read_change_stream_rest_flattened():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
@@ -7835,56 +5730,6 @@ def test_read_change_stream_rest_flattened_error(transport: str = "rest"):
)
-def test_read_change_stream_rest_error():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
- )
-
-
-@pytest.mark.parametrize(
- "request_type",
- [
- bigtable.ExecuteQueryRequest,
- dict,
- ],
-)
-def test_execute_query_rest(request_type):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="rest",
- )
-
- # send a request that will satisfy transcoding
- request_init = {"instance_name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
-
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.ExecuteQueryResponse()
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.ExecuteQueryResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
-
- json_return_value = "[{}]".format(json_return_value)
-
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- response = client.execute_query(request)
-
- assert isinstance(response, Iterable)
- response = next(response)
-
- # Establish that the response is the type that we expect.
- assert isinstance(response, bigtable.ExecuteQueryResponse)
-
-
def test_execute_query_rest_use_cached_wrapped_rpc():
# Clients should use _prep_wrapped_messages to create cached wrapped rpcs,
# instead of constructing them on each call
@@ -8019,258 +5864,4084 @@ def test_execute_query_rest_unset_required_fields():
)
-@pytest.mark.parametrize("null_interceptor", [True, False])
-def test_execute_query_rest_interceptors(null_interceptor):
- transport = transports.BigtableRestTransport(
+def test_execute_query_rest_flattened():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ transport="rest",
)
- client = BigtableClient(transport=transport)
- with mock.patch.object(
- type(client.transport._session), "request"
- ) as req, mock.patch.object(
- path_template, "transcode"
- ) as transcode, mock.patch.object(
- transports.BigtableRestInterceptor, "post_execute_query"
- ) as post, mock.patch.object(
- transports.BigtableRestInterceptor, "pre_execute_query"
- ) as pre:
- pre.assert_not_called()
- post.assert_not_called()
- pb_message = bigtable.ExecuteQueryRequest.pb(bigtable.ExecuteQueryRequest())
- transcode.return_value = {
- "method": "post",
- "uri": "my_uri",
- "body": pb_message,
- "query_params": pb_message,
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.ExecuteQueryResponse()
+
+ # get arguments that satisfy an http rule for this method
+ sample_request = {"instance_name": "projects/sample1/instances/sample2"}
+
+ # get truthy value for each flattened field
+ mock_args = dict(
+ instance_name="instance_name_value",
+ query="query_value",
+ app_profile_id="app_profile_id_value",
+ )
+ mock_args.update(sample_request)
+
+ # Wrap the value into a proper Response obj
+ response_value = Response()
+ response_value.status_code = 200
+ # Convert return value to protobuf type
+ return_value = bigtable.ExecuteQueryResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value._content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+
+ with mock.patch.object(response_value, "iter_content") as iter_content:
+ iter_content.return_value = iter(json_return_value)
+ client.execute_query(**mock_args)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(req.mock_calls) == 1
+ _, args, _ = req.mock_calls[0]
+ assert path_template.validate(
+ "%s/v2/{instance_name=projects/*/instances/*}:executeQuery"
+ % client.transport._host,
+ args[1],
+ )
+
+
+def test_execute_query_rest_flattened_error(transport: str = "rest"):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.execute_query(
+ bigtable.ExecuteQueryRequest(),
+ instance_name="instance_name_value",
+ query="query_value",
+ app_profile_id="app_profile_id_value",
+ )
+
+
+def test_credentials_transport_error():
+ # It is an error to provide credentials and a transport instance.
+ transport = transports.BigtableGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport=transport,
+ )
+
+ # It is an error to provide a credentials file and a transport instance.
+ transport = transports.BigtableGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = BigtableClient(
+ client_options={"credentials_file": "credentials.json"},
+ transport=transport,
+ )
+
+ # It is an error to provide an api_key and a transport instance.
+ transport = transports.BigtableGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ options = client_options.ClientOptions()
+ options.api_key = "api_key"
+ with pytest.raises(ValueError):
+ client = BigtableClient(
+ client_options=options,
+ transport=transport,
+ )
+
+ # It is an error to provide an api_key and a credential.
+ options = client_options.ClientOptions()
+ options.api_key = "api_key"
+ with pytest.raises(ValueError):
+ client = BigtableClient(
+ client_options=options, credentials=ga_credentials.AnonymousCredentials()
+ )
+
+ # It is an error to provide scopes and a transport instance.
+ transport = transports.BigtableGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = BigtableClient(
+ client_options={"scopes": ["1", "2"]},
+ transport=transport,
+ )
+
+
+def test_transport_instance():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.BigtableGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ client = BigtableClient(transport=transport)
+ assert client.transport is transport
+
+
+def test_transport_get_channel():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.BigtableGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
+
+ transport = transports.BigtableGrpcAsyncIOTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
+
+
+@pytest.mark.parametrize(
+ "transport_class",
+ [
+ transports.BigtableGrpcTransport,
+ transports.BigtableGrpcAsyncIOTransport,
+ transports.BigtableRestTransport,
+ ],
+)
+def test_transport_adc(transport_class):
+ # Test default credentials are used if not provided.
+ with mock.patch.object(google.auth, "default") as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport_class()
+ adc.assert_called_once()
+
+
+def test_transport_kind_grpc():
+ transport = BigtableClient.get_transport_class("grpc")(
+ credentials=ga_credentials.AnonymousCredentials()
+ )
+ assert transport.kind == "grpc"
+
+
+def test_initialize_client_w_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_read_rows_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ call.return_value = iter([bigtable.ReadRowsResponse()])
+ client.read_rows(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_sample_row_keys_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ call.return_value = iter([bigtable.SampleRowKeysResponse()])
+ client.sample_row_keys(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_mutate_row_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ call.return_value = bigtable.MutateRowResponse()
+ client.mutate_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_mutate_rows_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ call.return_value = iter([bigtable.MutateRowsResponse()])
+ client.mutate_rows(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_check_and_mutate_row_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.CheckAndMutateRowResponse()
+ client.check_and_mutate_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_ping_and_warm_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ call.return_value = bigtable.PingAndWarmResponse()
+ client.ping_and_warm(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_read_modify_write_row_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.ReadModifyWriteRowResponse()
+ client.read_modify_write_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_generate_initial_change_stream_partitions_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.generate_initial_change_stream_partitions), "__call__"
+ ) as call:
+ call.return_value = iter(
+ [bigtable.GenerateInitialChangeStreamPartitionsResponse()]
+ )
+ client.generate_initial_change_stream_partitions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.GenerateInitialChangeStreamPartitionsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_read_change_stream_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_change_stream), "__call__"
+ ) as call:
+ call.return_value = iter([bigtable.ReadChangeStreamResponse()])
+ client.read_change_stream(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadChangeStreamRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_execute_query_empty_call_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ call.return_value = iter([bigtable.ExecuteQueryResponse()])
+ client.execute_query(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest()
+
+ assert args[0] == request_msg
+
+
+def test_read_rows_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ call.return_value = iter([bigtable.ReadRowsResponse()])
+ client.read_rows(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_read_rows_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ call.return_value = iter([bigtable.ReadRowsResponse()])
+ client.read_rows(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_read_rows_routing_parameters_request_3_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ call.return_value = iter([bigtable.ReadRowsResponse()])
+ client.read_rows(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_sample_row_keys_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ call.return_value = iter([bigtable.SampleRowKeysResponse()])
+ client.sample_row_keys(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_sample_row_keys_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ call.return_value = iter([bigtable.SampleRowKeysResponse()])
+ client.sample_row_keys(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_sample_row_keys_routing_parameters_request_3_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ call.return_value = iter([bigtable.SampleRowKeysResponse()])
+ client.sample_row_keys(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_row_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ call.return_value = bigtable.MutateRowResponse()
+ client.mutate_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_row_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ call.return_value = bigtable.MutateRowResponse()
+ client.mutate_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_row_routing_parameters_request_3_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ call.return_value = bigtable.MutateRowResponse()
+ client.mutate_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_rows_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ call.return_value = iter([bigtable.MutateRowsResponse()])
+ client.mutate_rows(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_rows_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ call.return_value = iter([bigtable.MutateRowsResponse()])
+ client.mutate_rows(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_rows_routing_parameters_request_3_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ call.return_value = iter([bigtable.MutateRowsResponse()])
+ client.mutate_rows(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_check_and_mutate_row_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.CheckAndMutateRowResponse()
+ client.check_and_mutate_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_check_and_mutate_row_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.CheckAndMutateRowResponse()
+ client.check_and_mutate_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_check_and_mutate_row_routing_parameters_request_3_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.CheckAndMutateRowResponse()
+ client.check_and_mutate_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_ping_and_warm_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ call.return_value = bigtable.PingAndWarmResponse()
+ client.ping_and_warm(request={"name": "projects/sample1/instances/sample2"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest(
+ **{"name": "projects/sample1/instances/sample2"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {"name": "projects/sample1/instances/sample2"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_ping_and_warm_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ call.return_value = bigtable.PingAndWarmResponse()
+ client.ping_and_warm(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_read_modify_write_row_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.ReadModifyWriteRowResponse()
+ client.read_modify_write_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_read_modify_write_row_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.ReadModifyWriteRowResponse()
+ client.read_modify_write_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{"app_profile_id": "sample1"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_read_modify_write_row_routing_parameters_request_3_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ call.return_value = bigtable.ReadModifyWriteRowResponse()
+ client.read_modify_write_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_execute_query_routing_parameters_request_1_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ call.return_value = iter([bigtable.ExecuteQueryResponse()])
+ client.execute_query(
+ request={"instance_name": "projects/sample1/instances/sample2"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest(
+ **{"instance_name": "projects/sample1/instances/sample2"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {"name": "projects/sample1/instances/sample2"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_execute_query_routing_parameters_request_2_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="grpc",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ call.return_value = iter([bigtable.ExecuteQueryResponse()])
+ client.execute_query(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_transport_kind_grpc_asyncio():
+ transport = BigtableAsyncClient.get_transport_class("grpc_asyncio")(
+ credentials=async_anonymous_credentials()
+ )
+ assert transport.kind == "grpc_asyncio"
+
+
+def test_initialize_client_w_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(), transport="grpc_asyncio"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_read_rows_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ReadRowsResponse()]
+ )
+ await client.read_rows(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_sample_row_keys_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.SampleRowKeysResponse()]
+ )
+ await client.sample_row_keys(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_mutate_row_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.MutateRowResponse()
+ )
+ await client.mutate_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_mutate_rows_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.MutateRowsResponse()]
+ )
+ await client.mutate_rows(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_check_and_mutate_row_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.CheckAndMutateRowResponse(
+ predicate_matched=True,
+ )
+ )
+ await client.check_and_mutate_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_ping_and_warm_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.PingAndWarmResponse()
+ )
+ await client.ping_and_warm(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_read_modify_write_row_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.ReadModifyWriteRowResponse()
+ )
+ await client.read_modify_write_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_generate_initial_change_stream_partitions_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.generate_initial_change_stream_partitions), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.GenerateInitialChangeStreamPartitionsResponse()]
+ )
+ await client.generate_initial_change_stream_partitions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.GenerateInitialChangeStreamPartitionsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_read_change_stream_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_change_stream), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ReadChangeStreamResponse()]
+ )
+ await client.read_change_stream(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadChangeStreamRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+@pytest.mark.asyncio
+async def test_execute_query_empty_call_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ExecuteQueryResponse()]
+ )
+ await client.execute_query(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest()
+
+ assert args[0] == request_msg
+
+
+@pytest.mark.asyncio
+async def test_read_rows_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ReadRowsResponse()]
+ )
+ await client.read_rows(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_read_rows_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ReadRowsResponse()]
+ )
+ await client.read_rows(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_read_rows_routing_parameters_request_3_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ReadRowsResponse()]
+ )
+ await client.read_rows(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_sample_row_keys_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.SampleRowKeysResponse()]
+ )
+ await client.sample_row_keys(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_sample_row_keys_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.SampleRowKeysResponse()]
+ )
+ await client.sample_row_keys(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_sample_row_keys_routing_parameters_request_3_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.SampleRowKeysResponse()]
+ )
+ await client.sample_row_keys(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_mutate_row_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.MutateRowResponse()
+ )
+ await client.mutate_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_mutate_row_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.MutateRowResponse()
+ )
+ await client.mutate_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_mutate_row_routing_parameters_request_3_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.MutateRowResponse()
+ )
+ await client.mutate_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_mutate_rows_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.MutateRowsResponse()]
+ )
+ await client.mutate_rows(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_mutate_rows_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.MutateRowsResponse()]
+ )
+ await client.mutate_rows(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_mutate_rows_routing_parameters_request_3_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.MutateRowsResponse()]
+ )
+ await client.mutate_rows(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_check_and_mutate_row_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.CheckAndMutateRowResponse(
+ predicate_matched=True,
+ )
+ )
+ await client.check_and_mutate_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_check_and_mutate_row_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.CheckAndMutateRowResponse(
+ predicate_matched=True,
+ )
+ )
+ await client.check_and_mutate_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_check_and_mutate_row_routing_parameters_request_3_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.CheckAndMutateRowResponse(
+ predicate_matched=True,
+ )
+ )
+ await client.check_and_mutate_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_ping_and_warm_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.PingAndWarmResponse()
+ )
+ await client.ping_and_warm(
+ request={"name": "projects/sample1/instances/sample2"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest(
+ **{"name": "projects/sample1/instances/sample2"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {"name": "projects/sample1/instances/sample2"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_ping_and_warm_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.PingAndWarmResponse()
+ )
+ await client.ping_and_warm(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_read_modify_write_row_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.ReadModifyWriteRowResponse()
+ )
+ await client.read_modify_write_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_read_modify_write_row_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.ReadModifyWriteRowResponse()
+ )
+ await client.read_modify_write_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{"app_profile_id": "sample1"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_read_modify_write_row_routing_parameters_request_3_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ bigtable.ReadModifyWriteRowResponse()
+ )
+ await client.read_modify_write_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_execute_query_routing_parameters_request_1_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ExecuteQueryResponse()]
+ )
+ await client.execute_query(
+ request={"instance_name": "projects/sample1/instances/sample2"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest(
+ **{"instance_name": "projects/sample1/instances/sample2"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {"name": "projects/sample1/instances/sample2"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_execute_query_routing_parameters_request_2_grpc_asyncio():
+ client = BigtableAsyncClient(
+ credentials=async_anonymous_credentials(),
+ transport="grpc_asyncio",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = mock.Mock(aio.UnaryStreamCall, autospec=True)
+ call.return_value.read = mock.AsyncMock(
+ side_effect=[bigtable.ExecuteQueryResponse()]
+ )
+ await client.execute_query(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_transport_kind_rest():
+ transport = BigtableClient.get_transport_class("rest")(
+ credentials=ga_credentials.AnonymousCredentials()
+ )
+ assert transport.kind == "rest"
+
+
+def test_read_rows_rest_bad_request(request_type=bigtable.ReadRowsRequest):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.read_rows(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.ReadRowsRequest,
+ dict,
+ ],
+)
+def test_read_rows_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.ReadRowsResponse(
+ last_scanned_row_key=b"last_scanned_row_key_blob",
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.ReadRowsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value.iter_content = mock.Mock(return_value=iter(json_return_value))
+ req.return_value = response_value
+ response = client.read_rows(request)
+
+ assert isinstance(response, Iterable)
+ response = next(response)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.ReadRowsResponse)
+ assert response.last_scanned_row_key == b"last_scanned_row_key_blob"
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_read_rows_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_read_rows"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_read_rows"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.ReadRowsRequest.pb(bigtable.ReadRowsRequest())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.ReadRowsResponse.to_json(bigtable.ReadRowsResponse())
+ req.return_value.iter_content = mock.Mock(return_value=iter(return_value))
+
+ request = bigtable.ReadRowsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.ReadRowsResponse()
+
+ client.read_rows(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_sample_row_keys_rest_bad_request(request_type=bigtable.SampleRowKeysRequest):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.sample_row_keys(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.SampleRowKeysRequest,
+ dict,
+ ],
+)
+def test_sample_row_keys_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.SampleRowKeysResponse(
+ row_key=b"row_key_blob",
+ offset_bytes=1293,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.SampleRowKeysResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value.iter_content = mock.Mock(return_value=iter(json_return_value))
+ req.return_value = response_value
+ response = client.sample_row_keys(request)
+
+ assert isinstance(response, Iterable)
+ response = next(response)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.SampleRowKeysResponse)
+ assert response.row_key == b"row_key_blob"
+ assert response.offset_bytes == 1293
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_sample_row_keys_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_sample_row_keys"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_sample_row_keys"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.SampleRowKeysRequest.pb(bigtable.SampleRowKeysRequest())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.SampleRowKeysResponse.to_json(
+ bigtable.SampleRowKeysResponse()
+ )
+ req.return_value.iter_content = mock.Mock(return_value=iter(return_value))
+
+ request = bigtable.SampleRowKeysRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.SampleRowKeysResponse()
+
+ client.sample_row_keys(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_mutate_row_rest_bad_request(request_type=bigtable.MutateRowRequest):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.mutate_row(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.MutateRowRequest,
+ dict,
+ ],
+)
+def test_mutate_row_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.MutateRowResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.MutateRowResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.mutate_row(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.MutateRowResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_mutate_row_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_mutate_row"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_mutate_row"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.MutateRowRequest.pb(bigtable.MutateRowRequest())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.MutateRowResponse.to_json(bigtable.MutateRowResponse())
+ req.return_value.content = return_value
+
+ request = bigtable.MutateRowRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.MutateRowResponse()
+
+ client.mutate_row(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_mutate_rows_rest_bad_request(request_type=bigtable.MutateRowsRequest):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.mutate_rows(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.MutateRowsRequest,
+ dict,
+ ],
+)
+def test_mutate_rows_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.MutateRowsResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.MutateRowsResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value.iter_content = mock.Mock(return_value=iter(json_return_value))
+ req.return_value = response_value
+ response = client.mutate_rows(request)
+
+ assert isinstance(response, Iterable)
+ response = next(response)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.MutateRowsResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_mutate_rows_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_mutate_rows"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_mutate_rows"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.MutateRowsRequest.pb(bigtable.MutateRowsRequest())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.MutateRowsResponse.to_json(
+ bigtable.MutateRowsResponse()
+ )
+ req.return_value.iter_content = mock.Mock(return_value=iter(return_value))
+
+ request = bigtable.MutateRowsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.MutateRowsResponse()
+
+ client.mutate_rows(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_check_and_mutate_row_rest_bad_request(
+ request_type=bigtable.CheckAndMutateRowRequest,
+):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.check_and_mutate_row(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.CheckAndMutateRowRequest,
+ dict,
+ ],
+)
+def test_check_and_mutate_row_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.CheckAndMutateRowResponse(
+ predicate_matched=True,
+ )
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.CheckAndMutateRowResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.check_and_mutate_row(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.CheckAndMutateRowResponse)
+ assert response.predicate_matched is True
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_check_and_mutate_row_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_check_and_mutate_row"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_check_and_mutate_row"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.CheckAndMutateRowRequest.pb(
+ bigtable.CheckAndMutateRowRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.CheckAndMutateRowResponse.to_json(
+ bigtable.CheckAndMutateRowResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable.CheckAndMutateRowRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.CheckAndMutateRowResponse()
+
+ client.check_and_mutate_row(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_ping_and_warm_rest_bad_request(request_type=bigtable.PingAndWarmRequest):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.ping_and_warm(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.PingAndWarmRequest,
+ dict,
+ ],
+)
+def test_ping_and_warm_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.PingAndWarmResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.PingAndWarmResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.ping_and_warm(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.PingAndWarmResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_ping_and_warm_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_ping_and_warm"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_ping_and_warm"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.PingAndWarmRequest.pb(bigtable.PingAndWarmRequest())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.PingAndWarmResponse.to_json(
+ bigtable.PingAndWarmResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable.PingAndWarmRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.PingAndWarmResponse()
+
+ client.ping_and_warm(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_read_modify_write_row_rest_bad_request(
+ request_type=bigtable.ReadModifyWriteRowRequest,
+):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.read_modify_write_row(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.ReadModifyWriteRowRequest,
+ dict,
+ ],
+)
+def test_read_modify_write_row_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.ReadModifyWriteRowResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.ReadModifyWriteRowResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ response_value.content = json_return_value.encode("UTF-8")
+ req.return_value = response_value
+ response = client.read_modify_write_row(request)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.ReadModifyWriteRowResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_read_modify_write_row_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_read_modify_write_row"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_read_modify_write_row"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.ReadModifyWriteRowRequest.pb(
+ bigtable.ReadModifyWriteRowRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.ReadModifyWriteRowResponse.to_json(
+ bigtable.ReadModifyWriteRowResponse()
+ )
+ req.return_value.content = return_value
+
+ request = bigtable.ReadModifyWriteRowRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.ReadModifyWriteRowResponse()
+
+ client.read_modify_write_row(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_generate_initial_change_stream_partitions_rest_bad_request(
+ request_type=bigtable.GenerateInitialChangeStreamPartitionsRequest,
+):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.generate_initial_change_stream_partitions(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.GenerateInitialChangeStreamPartitionsRequest,
+ dict,
+ ],
+)
+def test_generate_initial_change_stream_partitions_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse.pb(
+ return_value
+ )
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value.iter_content = mock.Mock(return_value=iter(json_return_value))
+ req.return_value = response_value
+ response = client.generate_initial_change_stream_partitions(request)
+
+ assert isinstance(response, Iterable)
+ response = next(response)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.GenerateInitialChangeStreamPartitionsResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_generate_initial_change_stream_partitions_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor,
+ "post_generate_initial_change_stream_partitions",
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor,
+ "pre_generate_initial_change_stream_partitions",
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.GenerateInitialChangeStreamPartitionsRequest.pb(
+ bigtable.GenerateInitialChangeStreamPartitionsRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse.to_json(
+ bigtable.GenerateInitialChangeStreamPartitionsResponse()
+ )
+ req.return_value.iter_content = mock.Mock(return_value=iter(return_value))
+
+ request = bigtable.GenerateInitialChangeStreamPartitionsRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.GenerateInitialChangeStreamPartitionsResponse()
+
+ client.generate_initial_change_stream_partitions(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_read_change_stream_rest_bad_request(
+ request_type=bigtable.ReadChangeStreamRequest,
+):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.read_change_stream(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.ReadChangeStreamRequest,
+ dict,
+ ],
+)
+def test_read_change_stream_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.ReadChangeStreamResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.ReadChangeStreamResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value.iter_content = mock.Mock(return_value=iter(json_return_value))
+ req.return_value = response_value
+ response = client.read_change_stream(request)
+
+ assert isinstance(response, Iterable)
+ response = next(response)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.ReadChangeStreamResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_read_change_stream_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_read_change_stream"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_read_change_stream"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.ReadChangeStreamRequest.pb(
+ bigtable.ReadChangeStreamRequest()
+ )
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.ReadChangeStreamResponse.to_json(
+ bigtable.ReadChangeStreamResponse()
+ )
+ req.return_value.iter_content = mock.Mock(return_value=iter(return_value))
+
+ request = bigtable.ReadChangeStreamRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.ReadChangeStreamResponse()
+
+ client.read_change_stream(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_execute_query_rest_bad_request(request_type=bigtable.ExecuteQueryRequest):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ # send a request that will satisfy transcoding
+ request_init = {"instance_name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a BadRequest error.
+ with mock.patch.object(Session, "request") as req, pytest.raises(
+ core_exceptions.BadRequest
+ ):
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ json_return_value = ""
+ response_value.json = mock.Mock(return_value={})
+ response_value.status_code = 400
+ response_value.request = mock.Mock()
+ req.return_value = response_value
+ client.execute_query(request)
+
+
+@pytest.mark.parametrize(
+ "request_type",
+ [
+ bigtable.ExecuteQueryRequest,
+ dict,
+ ],
+)
+def test_execute_query_rest_call_success(request_type):
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+
+ # send a request that will satisfy transcoding
+ request_init = {"instance_name": "projects/sample1/instances/sample2"}
+ request = request_type(**request_init)
+
+ # Mock the http request call within the method and fake a response.
+ with mock.patch.object(type(client.transport._session), "request") as req:
+ # Designate an appropriate value for the returned response.
+ return_value = bigtable.ExecuteQueryResponse()
+
+ # Wrap the value into a proper Response obj
+ response_value = mock.Mock()
+ response_value.status_code = 200
+
+ # Convert return value to protobuf type
+ return_value = bigtable.ExecuteQueryResponse.pb(return_value)
+ json_return_value = json_format.MessageToJson(return_value)
+ json_return_value = "[{}]".format(json_return_value)
+ response_value.iter_content = mock.Mock(return_value=iter(json_return_value))
+ req.return_value = response_value
+ response = client.execute_query(request)
+
+ assert isinstance(response, Iterable)
+ response = next(response)
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, bigtable.ExecuteQueryResponse)
+
+
+@pytest.mark.parametrize("null_interceptor", [True, False])
+def test_execute_query_rest_interceptors(null_interceptor):
+ transport = transports.BigtableRestTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ interceptor=None if null_interceptor else transports.BigtableRestInterceptor(),
+ )
+ client = BigtableClient(transport=transport)
+
+ with mock.patch.object(
+ type(client.transport._session), "request"
+ ) as req, mock.patch.object(
+ path_template, "transcode"
+ ) as transcode, mock.patch.object(
+ transports.BigtableRestInterceptor, "post_execute_query"
+ ) as post, mock.patch.object(
+ transports.BigtableRestInterceptor, "pre_execute_query"
+ ) as pre:
+ pre.assert_not_called()
+ post.assert_not_called()
+ pb_message = bigtable.ExecuteQueryRequest.pb(bigtable.ExecuteQueryRequest())
+ transcode.return_value = {
+ "method": "post",
+ "uri": "my_uri",
+ "body": pb_message,
+ "query_params": pb_message,
+ }
+
+ req.return_value = mock.Mock()
+ req.return_value.status_code = 200
+ return_value = bigtable.ExecuteQueryResponse.to_json(
+ bigtable.ExecuteQueryResponse()
+ )
+ req.return_value.iter_content = mock.Mock(return_value=iter(return_value))
+
+ request = bigtable.ExecuteQueryRequest()
+ metadata = [
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ]
+ pre.return_value = request, metadata
+ post.return_value = bigtable.ExecuteQueryResponse()
+
+ client.execute_query(
+ request,
+ metadata=[
+ ("key", "val"),
+ ("cephalopod", "squid"),
+ ],
+ )
+
+ pre.assert_called_once()
+ post.assert_called_once()
+
+
+def test_initialize_client_w_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ assert client is not None
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_read_rows_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ client.read_rows(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_sample_row_keys_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ client.sample_row_keys(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_mutate_row_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ client.mutate_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_mutate_rows_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ client.mutate_rows(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_check_and_mutate_row_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ client.check_and_mutate_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_ping_and_warm_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ client.ping_and_warm(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_read_modify_write_row_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ client.read_modify_write_row(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_generate_initial_change_stream_partitions_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.generate_initial_change_stream_partitions), "__call__"
+ ) as call:
+ client.generate_initial_change_stream_partitions(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.GenerateInitialChangeStreamPartitionsRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_read_change_stream_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_change_stream), "__call__"
+ ) as call:
+ client.read_change_stream(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ReadChangeStreamRequest()
+
+ assert args[0] == request_msg
+
+
+# This test is a coverage failsafe to make sure that totally empty calls,
+# i.e. request == None and no flattened fields passed, work.
+def test_execute_query_empty_call_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ client.execute_query(request=None)
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest()
+
+ assert args[0] == request_msg
+
+
+def test_read_rows_routing_parameters_request_1_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ client.read_rows(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
- req.return_value = Response()
- req.return_value.status_code = 200
- req.return_value.request = PreparedRequest()
- req.return_value._content = bigtable.ExecuteQueryResponse.to_json(
- bigtable.ExecuteQueryResponse()
+
+def test_read_rows_routing_parameters_request_2_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ client.read_rows(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
)
- req.return_value._content = "[{}]".format(req.return_value._content)
- request = bigtable.ExecuteQueryRequest()
- metadata = [
- ("key", "val"),
- ("cephalopod", "squid"),
- ]
- pre.return_value = request, metadata
- post.return_value = bigtable.ExecuteQueryResponse()
- client.execute_query(
- request,
- metadata=[
- ("key", "val"),
- ("cephalopod", "squid"),
- ],
- )
+def test_read_rows_routing_parameters_request_3_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.read_rows), "__call__") as call:
+ client.read_rows(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadRowsRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_sample_row_keys_routing_parameters_request_1_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ client.sample_row_keys(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_sample_row_keys_routing_parameters_request_2_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ client.sample_row_keys(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_sample_row_keys_routing_parameters_request_3_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.sample_row_keys), "__call__") as call:
+ client.sample_row_keys(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.SampleRowKeysRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_row_routing_parameters_request_1_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ client.mutate_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_row_routing_parameters_request_2_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ client.mutate_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_row_routing_parameters_request_3_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_row), "__call__") as call:
+ client.mutate_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_rows_routing_parameters_request_1_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ client.mutate_rows(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_rows_routing_parameters_request_2_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ client.mutate_rows(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_mutate_rows_routing_parameters_request_3_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.mutate_rows), "__call__") as call:
+ client.mutate_rows(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.MutateRowsRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_check_and_mutate_row_routing_parameters_request_1_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ client.check_and_mutate_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
+
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_check_and_mutate_row_routing_parameters_request_2_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
+ )
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ client.check_and_mutate_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
- pre.assert_called_once()
- post.assert_called_once()
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
-def test_execute_query_rest_bad_request(
- transport: str = "rest", request_type=bigtable.ExecuteQueryRequest
-):
+def test_check_and_mutate_row_routing_parameters_request_3_rest():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # send a request that will satisfy transcoding
- request_init = {"instance_name": "projects/sample1/instances/sample2"}
- request = request_type(**request_init)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.check_and_mutate_row), "__call__"
+ ) as call:
+ client.check_and_mutate_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
- # Mock the http request call within the method and fake a BadRequest error.
- with mock.patch.object(Session, "request") as req, pytest.raises(
- core_exceptions.BadRequest
- ):
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 400
- response_value.request = Request()
- req.return_value = response_value
- client.execute_query(request)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.CheckAndMutateRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
+ assert args[0] == request_msg
-def test_execute_query_rest_flattened():
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_ping_and_warm_routing_parameters_request_1_rest():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
transport="rest",
)
- # Mock the http request call within the method and fake a response.
- with mock.patch.object(type(client.transport._session), "request") as req:
- # Designate an appropriate value for the returned response.
- return_value = bigtable.ExecuteQueryResponse()
-
- # get arguments that satisfy an http rule for this method
- sample_request = {"instance_name": "projects/sample1/instances/sample2"}
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ client.ping_and_warm(request={"name": "projects/sample1/instances/sample2"})
- # get truthy value for each flattened field
- mock_args = dict(
- instance_name="instance_name_value",
- query="query_value",
- app_profile_id="app_profile_id_value",
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest(
+ **{"name": "projects/sample1/instances/sample2"}
)
- mock_args.update(sample_request)
-
- # Wrap the value into a proper Response obj
- response_value = Response()
- response_value.status_code = 200
- # Convert return value to protobuf type
- return_value = bigtable.ExecuteQueryResponse.pb(return_value)
- json_return_value = json_format.MessageToJson(return_value)
- json_return_value = "[{}]".format(json_return_value)
- response_value._content = json_return_value.encode("UTF-8")
- req.return_value = response_value
- with mock.patch.object(response_value, "iter_content") as iter_content:
- iter_content.return_value = iter(json_return_value)
- client.execute_query(**mock_args)
+ assert args[0] == request_msg
- # Establish that the underlying call was made with the expected
- # request object values.
- assert len(req.mock_calls) == 1
- _, args, _ = req.mock_calls[0]
- assert path_template.validate(
- "%s/v2/{instance_name=projects/*/instances/*}:executeQuery"
- % client.transport._host,
- args[1],
+ expected_headers = {"name": "projects/sample1/instances/sample2"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
)
-def test_execute_query_rest_flattened_error(transport: str = "rest"):
+def test_ping_and_warm_routing_parameters_request_2_rest():
client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ transport="rest",
)
- # Attempting to call a method with both a request object and flattened
- # fields is an error.
- with pytest.raises(ValueError):
- client.execute_query(
- bigtable.ExecuteQueryRequest(),
- instance_name="instance_name_value",
- query="query_value",
- app_profile_id="app_profile_id_value",
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.ping_and_warm), "__call__") as call:
+ client.ping_and_warm(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.PingAndWarmRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
)
-def test_execute_query_rest_error():
+def test_read_modify_write_row_routing_parameters_request_1_rest():
client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ client.read_modify_write_row(
+ request={"table_name": "projects/sample1/instances/sample2/tables/sample3"}
+ )
-def test_credentials_transport_error():
- # It is an error to provide credentials and a transport instance.
- transport = transports.BigtableGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- with pytest.raises(ValueError):
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport=transport,
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{"table_name": "projects/sample1/instances/sample2/tables/sample3"}
)
- # It is an error to provide a credentials file and a transport instance.
- transport = transports.BigtableGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- with pytest.raises(ValueError):
- client = BigtableClient(
- client_options={"credentials_file": "credentials.json"},
- transport=transport,
+ assert args[0] == request_msg
+
+ expected_headers = {
+ "table_name": "projects/sample1/instances/sample2/tables/sample3"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
)
- # It is an error to provide an api_key and a transport instance.
- transport = transports.BigtableGrpcTransport(
+
+def test_read_modify_write_row_routing_parameters_request_2_rest():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- options = client_options.ClientOptions()
- options.api_key = "api_key"
- with pytest.raises(ValueError):
- client = BigtableClient(
- client_options=options,
- transport=transport,
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ client.read_modify_write_row(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{"app_profile_id": "sample1"}
)
- # It is an error to provide an api_key and a credential.
- options = client_options.ClientOptions()
- options.api_key = "api_key"
- with pytest.raises(ValueError):
- client = BigtableClient(
- client_options=options, credentials=ga_credentials.AnonymousCredentials()
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
)
- # It is an error to provide scopes and a transport instance.
- transport = transports.BigtableGrpcTransport(
+
+def test_read_modify_write_row_routing_parameters_request_3_rest():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- with pytest.raises(ValueError):
- client = BigtableClient(
- client_options={"scopes": ["1", "2"]},
- transport=transport,
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(
+ type(client.transport.read_modify_write_row), "__call__"
+ ) as call:
+ client.read_modify_write_row(
+ request={
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
)
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ReadModifyWriteRowRequest(
+ **{
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ )
-def test_transport_instance():
- # A client may be instantiated with a custom transport instance.
- transport = transports.BigtableGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- client = BigtableClient(transport=transport)
- assert client.transport is transport
+ assert args[0] == request_msg
+ expected_headers = {
+ "authorized_view_name": "projects/sample1/instances/sample2/tables/sample3/authorizedViews/sample4"
+ }
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
-def test_transport_get_channel():
- # A client may be instantiated with a custom transport instance.
- transport = transports.BigtableGrpcTransport(
- credentials=ga_credentials.AnonymousCredentials(),
- )
- channel = transport.grpc_channel
- assert channel
- transport = transports.BigtableGrpcAsyncIOTransport(
+def test_execute_query_routing_parameters_request_1_rest():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- channel = transport.grpc_channel
- assert channel
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ client.execute_query(
+ request={"instance_name": "projects/sample1/instances/sample2"}
+ )
-@pytest.mark.parametrize(
- "transport_class",
- [
- transports.BigtableGrpcTransport,
- transports.BigtableGrpcAsyncIOTransport,
- transports.BigtableRestTransport,
- ],
-)
-def test_transport_adc(transport_class):
- # Test default credentials are used if not provided.
- with mock.patch.object(google.auth, "default") as adc:
- adc.return_value = (ga_credentials.AnonymousCredentials(), None)
- transport_class()
- adc.assert_called_once()
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest(
+ **{"instance_name": "projects/sample1/instances/sample2"}
+ )
+ assert args[0] == request_msg
-@pytest.mark.parametrize(
- "transport_name",
- [
- "grpc",
- "rest",
- ],
-)
-def test_transport_kind(transport_name):
- transport = BigtableClient.get_transport_class(transport_name)(
+ expected_headers = {"name": "projects/sample1/instances/sample2"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
+
+
+def test_execute_query_routing_parameters_request_2_rest():
+ client = BigtableClient(
credentials=ga_credentials.AnonymousCredentials(),
+ transport="rest",
)
- assert transport.kind == transport_name
+
+ # Mock the actual call, and fake the request.
+ with mock.patch.object(type(client.transport.execute_query), "__call__") as call:
+ client.execute_query(request={"app_profile_id": "sample1"})
+
+ # Establish that the underlying stub method was called.
+ call.assert_called()
+ _, args, kw = call.mock_calls[0]
+ request_msg = bigtable.ExecuteQueryRequest(**{"app_profile_id": "sample1"})
+
+ assert args[0] == request_msg
+
+ expected_headers = {"app_profile_id": "sample1"}
+ assert (
+ gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"]
+ )
def test_transport_grpc_default():
@@ -8955,36 +10626,41 @@ def test_client_with_default_client_info():
prep.assert_called_once_with(client_info)
+def test_transport_close_grpc():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc"
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "_grpc_channel")), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
+
+
@pytest.mark.asyncio
-async def test_transport_close_async():
+async def test_transport_close_grpc_asyncio():
client = BigtableAsyncClient(
- credentials=ga_credentials.AnonymousCredentials(),
- transport="grpc_asyncio",
+ credentials=async_anonymous_credentials(), transport="grpc_asyncio"
)
with mock.patch.object(
- type(getattr(client.transport, "grpc_channel")), "close"
+ type(getattr(client.transport, "_grpc_channel")), "close"
) as close:
async with client:
close.assert_not_called()
close.assert_called_once()
-def test_transport_close():
- transports = {
- "rest": "_session",
- "grpc": "_grpc_channel",
- }
-
- for transport, close_name in transports.items():
- client = BigtableClient(
- credentials=ga_credentials.AnonymousCredentials(), transport=transport
- )
- with mock.patch.object(
- type(getattr(client.transport, close_name)), "close"
- ) as close:
- with client:
- close.assert_not_called()
- close.assert_called_once()
+def test_transport_close_rest():
+ client = BigtableClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="rest"
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "_session")), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
def test_client_ctx():