def test_update_expire_time_success(self):
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.protobuf import field_mask_pb2
client = _Client()
api = client._table_admin_client = self._make_table_admin_client()
api.update_backup.return_type = table.Backup(name=self.BACKUP_NAME)
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID,
instance,
cluster_id=self.CLUSTER_ID)
expire_time = self._make_timestamp()
backup.update_expire_time(expire_time)
backup_update = table.Backup(
name=self.BACKUP_NAME,
expire_time=_datetime_to_pb_timestamp(expire_time),
)
update_mask = field_mask_pb2.FieldMask(paths=["expire_time"])
api.update_backup.assert_called_once_with(request={
"backup": backup_update,
"update_mask": update_mask
})
def test_create_grpc_error(self):
from google.api_core.exceptions import GoogleAPICallError
from google.api_core.exceptions import Unknown
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
client = _Client()
api = client._table_admin_client = self._make_table_admin_client()
api.create_backup.side_effect = Unknown("testing")
timestamp = self._make_timestamp()
backup = self._make_one(
self.BACKUP_ID,
_Instance(self.INSTANCE_NAME, client=client),
table_id=self.TABLE_ID,
expire_time=timestamp,
)
backup_pb = table.Backup(
source_table=self.TABLE_NAME,
expire_time=_datetime_to_pb_timestamp(timestamp),
)
with self.assertRaises(GoogleAPICallError):
backup.create(self.CLUSTER_ID)
api.create_backup.assert_called_once_with(
request={
"parent": self.CLUSTER_NAME,
"backup_id": self.BACKUP_ID,
"backup": backup_pb,
})
def test_from_pb_success(self):
from google.cloud.bigtable_admin_v2.types import table
from google.cloud._helpers import _datetime_to_pb_timestamp
client = _Client()
instance = _Instance(self.INSTANCE_NAME, client)
timestamp = _datetime_to_pb_timestamp(self._make_timestamp())
size_bytes = 1234
state = table.Backup.State.READY
backup_pb = table.Backup(
name=self.BACKUP_NAME,
source_table=self.TABLE_NAME,
expire_time=timestamp,
start_time=timestamp,
end_time=timestamp,
size_bytes=size_bytes,
state=state,
)
klasse = self._get_target_class()
backup = klasse.from_pb(backup_pb, instance)
self.assertTrue(isinstance(backup, klasse))
self.assertEqual(backup._instance, instance)
self.assertEqual(backup.backup_id, self.BACKUP_ID)
self.assertEqual(backup.cluster, self.CLUSTER_ID)
self.assertEqual(backup.table_id, self.TABLE_ID)
self.assertEqual(backup._expire_time, timestamp)
self.assertEqual(backup.start_time, timestamp)
self.assertEqual(backup.end_time, timestamp)
self.assertEqual(backup._size_bytes, size_bytes)
self.assertEqual(backup._state, state)
def test_create_success(self):
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.bigtable import Client
op_future = object()
credentials = _make_credentials()
client = Client(project=self.PROJECT_ID, credentials=credentials, admin=True)
api = client._table_admin_client = self._make_table_admin_client()
api.create_backup.return_value = op_future
timestamp = self._make_timestamp()
backup = self._make_one(
self.BACKUP_ID,
_Instance(self.INSTANCE_NAME, client=client),
table_id=self.TABLE_ID,
expire_time=timestamp,
)
backup_pb = table.Backup(
source_table=self.TABLE_NAME,
expire_time=_datetime_to_pb_timestamp(timestamp),
)
future = backup.create(self.CLUSTER_ID)
self.assertEqual(backup._cluster, self.CLUSTER_ID)
self.assertIs(future, op_future)
api.create_backup.assert_called_once_with(
request={
"parent": self.CLUSTER_NAME,
"backup_id": self.BACKUP_ID,
"backup": backup_pb,
}
)
def test_backup_update_expire_time_w_grpc_error():
from google.api_core.exceptions import Unknown
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.protobuf import field_mask_pb2
client = _Client()
api = client.table_admin_client = _make_table_admin_client()
api.update_backup.side_effect = Unknown("testing")
instance = _Instance(INSTANCE_NAME, client=client)
backup = _make_backup(BACKUP_ID, instance, cluster_id=CLUSTER_ID)
expire_time = _make_timestamp()
with pytest.raises(Unknown):
backup.update_expire_time(expire_time)
backup_update = table.Backup(
name=BACKUP_NAME,
expire_time=_datetime_to_pb_timestamp(expire_time),
)
update_mask = field_mask_pb2.FieldMask(paths=["expire_time"])
api.update_backup.assert_called_once_with(request={
"backup": backup_update,
"update_mask": update_mask
})
def test_reload(self):
from google.cloud.bigtable_admin_v2.types import table
from google.cloud._helpers import _datetime_to_pb_timestamp
timestamp = _datetime_to_pb_timestamp(self._make_timestamp())
state = table.Backup.State.READY
client = _Client()
backup_pb = table.Backup(
name=self.BACKUP_NAME,
source_table=self.TABLE_NAME,
expire_time=timestamp,
start_time=timestamp,
end_time=timestamp,
size_bytes=0,
state=state,
)
api = client.table_admin_client = self._make_table_admin_client()
api.get_backup.return_value = backup_pb
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID, instance, cluster_id=self.CLUSTER_ID)
backup.reload()
self.assertEqual(backup._source_table, self.TABLE_NAME)
self.assertEqual(backup._expire_time, timestamp)
self.assertEqual(backup._start_time, timestamp)
self.assertEqual(backup._end_time, timestamp)
self.assertEqual(backup._size_bytes, 0)
self.assertEqual(backup._state, state)
def test_backup_reload():
from google.cloud.bigtable_admin_v2.types import table
from google.cloud._helpers import _datetime_to_pb_timestamp
timestamp = _datetime_to_pb_timestamp(_make_timestamp())
state = table.Backup.State.READY
client = _Client()
backup_pb = table.Backup(
name=BACKUP_NAME,
source_table=TABLE_NAME,
expire_time=timestamp,
start_time=timestamp,
end_time=timestamp,
size_bytes=0,
state=state,
)
api = client.table_admin_client = _make_table_admin_client()
api.get_backup.return_value = backup_pb
instance = _Instance(INSTANCE_NAME, client=client)
backup = _make_backup(BACKUP_ID, instance, cluster_id=CLUSTER_ID)
backup.reload()
assert backup._source_table == TABLE_NAME
assert backup._expire_time == timestamp
assert backup._start_time == timestamp
assert backup._end_time == timestamp
assert backup._size_bytes == 0
assert backup._state == state
def test_backup_create_success():
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.bigtable import Client
op_future = object()
credentials = _make_credentials()
client = Client(project=PROJECT_ID, credentials=credentials, admin=True)
api = client._table_admin_client = _make_table_admin_client()
api.create_backup.return_value = op_future
timestamp = _make_timestamp()
backup = _make_backup(
BACKUP_ID,
_Instance(INSTANCE_NAME, client=client),
table_id=TABLE_ID,
expire_time=timestamp,
)
backup_pb = table.Backup(
source_table=TABLE_NAME,
expire_time=_datetime_to_pb_timestamp(timestamp),
)
future = backup.create(CLUSTER_ID)
assert backup._cluster == CLUSTER_ID
assert future is op_future
api.create_backup.assert_called_once_with(request={
"parent": CLUSTER_NAME,
"backup_id": BACKUP_ID,
"backup": backup_pb
})
def test_backup_create_w_already_exists():
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.exceptions import Conflict
client = _Client()
api = client.table_admin_client = _make_table_admin_client()
api.create_backup.side_effect = Conflict("testing")
timestamp = _make_timestamp()
backup = _make_backup(
BACKUP_ID,
_Instance(INSTANCE_NAME, client=client),
table_id=TABLE_ID,
expire_time=timestamp,
)
backup_pb = table.Backup(
source_table=TABLE_NAME,
expire_time=_datetime_to_pb_timestamp(timestamp),
)
with pytest.raises(Conflict):
backup.create(CLUSTER_ID)
api.create_backup.assert_called_once_with(request={
"parent": CLUSTER_NAME,
"backup_id": BACKUP_ID,
"backup": backup_pb
})
def test_create_instance_not_found(self):
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.exceptions import NotFound
client = _Client()
api = client.table_admin_client = self._make_table_admin_client()
api.create_backup.side_effect = NotFound("testing")
timestamp = self._make_timestamp()
backup = self._make_one(
self.BACKUP_ID,
_Instance(self.INSTANCE_NAME, client=client),
table_id=self.TABLE_ID,
expire_time=timestamp,
)
backup_pb = table.Backup(
source_table=self.TABLE_NAME,
expire_time=_datetime_to_pb_timestamp(timestamp),
)
with self.assertRaises(NotFound):
backup.create(self.CLUSTER_ID)
api.create_backup.assert_called_once_with(
request={
"parent": self.CLUSTER_NAME,
"backup_id": self.BACKUP_ID,
"backup": backup_pb,
}
)
def test_update_expire_time_not_found(self):
from google.api_core.exceptions import NotFound
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.protobuf import field_mask_pb2
client = _Client()
api = client._table_admin_client = self._make_table_admin_client()
api.update_backup.side_effect = NotFound("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID,
instance,
cluster_id=self.CLUSTER_ID)
expire_time = self._make_timestamp()
with self.assertRaises(NotFound):
backup.update_expire_time(expire_time)
backup_update = table.Backup(
name=self.BACKUP_NAME,
expire_time=_datetime_to_pb_timestamp(expire_time),
)
update_mask = field_mask_pb2.FieldMask(paths=["expire_time"])
api.update_backup.assert_called_once_with(request={
"backup": backup_update,
"update_mask": update_mask
})
def test_backup_from_pb_w_bad_name():
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.bigtable.backup import Backup
client = _Client()
instance = _Instance(INSTANCE_NAME, client)
backup_pb = table.Backup(name="invalid_name")
with pytest.raises(ValueError):
Backup.from_pb(backup_pb, instance)
def test_from_pb_bad_name(self):
from google.cloud.bigtable_admin_v2.types import table
client = _Client()
instance = _Instance(self.INSTANCE_NAME, client)
backup_pb = table.Backup(name="invalid_name")
klasse = self._get_target_class()
with self.assertRaises(ValueError):
klasse.from_pb(backup_pb, instance)
def test_backup_from_pb_w_project_mismatch():
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.bigtable.backup import Backup
alt_project_id = "alt-project-id"
client = _Client(project=alt_project_id)
instance = _Instance(INSTANCE_NAME, client)
backup_pb = table.Backup(name=BACKUP_NAME)
with pytest.raises(ValueError):
Backup.from_pb(backup_pb, instance)
def test_from_pb_instance_mismatch(self):
from google.cloud.bigtable_admin_v2.types import table
alt_instance = "/projects/%s/instances/alt-instance" % self.PROJECT_ID
client = _Client()
instance = _Instance(alt_instance, client)
backup_pb = table.Backup(name=self.BACKUP_NAME)
klasse = self._get_target_class()
with self.assertRaises(ValueError):
klasse.from_pb(backup_pb, instance)
def test_from_pb_project_mismatch(self):
from google.cloud.bigtable_admin_v2.types import table
alt_project_id = "alt-project-id"
client = _Client(project=alt_project_id)
instance = _Instance(self.INSTANCE_NAME, client)
backup_pb = table.Backup(name=self.BACKUP_NAME)
klasse = self._get_target_class()
with self.assertRaises(ValueError):
klasse.from_pb(backup_pb, instance)
def test_backup_from_pb_w_instance_mismatch():
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.bigtable.backup import Backup
alt_instance = "/projects/%s/instances/alt-instance" % PROJECT_ID
client = _Client()
instance = _Instance(alt_instance, client)
backup_pb = table.Backup(name=BACKUP_NAME)
with pytest.raises(ValueError):
Backup.from_pb(backup_pb, instance)
def update_expire_time(self, new_expire_time):
"""Update the expire time of this Backup.
:type new_expire_time: :class:`datetime.datetime`
:param new_expire_time: the new expiration time timestamp
"""
backup_update = table.Backup(
name=self.name, expire_time=_datetime_to_pb_timestamp(new_expire_time),
)
update_mask = field_mask_pb2.FieldMask(paths=["expire_time"])
api = self._instance._client.table_admin_client
api.update_backup(request={"backup": backup_update, "update_mask": update_mask})
self._expire_time = new_expire_time
def test_from_pb_success(self):
from google.cloud.bigtable.encryption_info import EncryptionInfo
from google.cloud.bigtable.error import Status
from google.cloud.bigtable_admin_v2.types import table
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.rpc.code_pb2 import Code
client = _Client()
instance = _Instance(self.INSTANCE_NAME, client)
timestamp = _datetime_to_pb_timestamp(self._make_timestamp())
size_bytes = 1234
state = table.Backup.State.READY
GOOGLE_DEFAULT_ENCRYPTION = (
table.EncryptionInfo.EncryptionType.GOOGLE_DEFAULT_ENCRYPTION
)
backup_pb = table.Backup(
name=self.BACKUP_NAME,
source_table=self.TABLE_NAME,
expire_time=timestamp,
start_time=timestamp,
end_time=timestamp,
size_bytes=size_bytes,
state=state,
encryption_info=table.EncryptionInfo(
encryption_type=GOOGLE_DEFAULT_ENCRYPTION,
encryption_status=_StatusPB(Code.OK, "Status OK"),
kms_key_version="2",
),
)
klasse = self._get_target_class()
backup = klasse.from_pb(backup_pb, instance)
self.assertTrue(isinstance(backup, klasse))
self.assertEqual(backup._instance, instance)
self.assertEqual(backup.backup_id, self.BACKUP_ID)
self.assertEqual(backup.cluster, self.CLUSTER_ID)
self.assertEqual(backup.table_id, self.TABLE_ID)
self.assertEqual(backup._expire_time, timestamp)
self.assertEqual(backup.start_time, timestamp)
self.assertEqual(backup.end_time, timestamp)
self.assertEqual(backup._size_bytes, size_bytes)
self.assertEqual(backup._state, state)
self.assertEqual(
backup.encryption_info,
EncryptionInfo(
encryption_type=GOOGLE_DEFAULT_ENCRYPTION,
encryption_status=Status(_StatusPB(Code.OK, "Status OK")),
kms_key_version="2",
),
)
def test_exists_success(self):
from google.cloud.bigtable_admin_v2.types import table
client = _Client()
backup_pb = table.Backup(name=self.BACKUP_NAME)
api = client.table_admin_client = self._make_table_admin_client()
api.get_backup.return_value = backup_pb
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID, instance, cluster_id=self.CLUSTER_ID)
self.assertTrue(backup.exists())
api.get_backup.assert_called_once_with(request={"name": self.BACKUP_NAME})
def test_backup_from_pb_success():
from google.cloud.bigtable.encryption_info import EncryptionInfo
from google.cloud.bigtable.error import Status
from google.cloud.bigtable_admin_v2.types import table
from google.cloud.bigtable.backup import Backup
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.rpc.code_pb2 import Code
client = _Client()
instance = _Instance(INSTANCE_NAME, client)
timestamp = _datetime_to_pb_timestamp(_make_timestamp())
size_bytes = 1234
state = table.Backup.State.READY
GOOGLE_DEFAULT_ENCRYPTION = (
table.EncryptionInfo.EncryptionType.GOOGLE_DEFAULT_ENCRYPTION)
backup_pb = table.Backup(
name=BACKUP_NAME,
source_table=TABLE_NAME,
expire_time=timestamp,
start_time=timestamp,
end_time=timestamp,
size_bytes=size_bytes,
state=state,
encryption_info=table.EncryptionInfo(
encryption_type=GOOGLE_DEFAULT_ENCRYPTION,
encryption_status=_StatusPB(Code.OK, "Status OK"),
kms_key_version="2",
),
)
backup = Backup.from_pb(backup_pb, instance)
assert isinstance(backup, Backup)
assert backup._instance == instance
assert backup.backup_id == BACKUP_ID
assert backup.cluster == CLUSTER_ID
assert backup.table_id == TABLE_ID
assert backup._expire_time == timestamp
assert backup.start_time == timestamp
assert backup.end_time == timestamp
assert backup._size_bytes == size_bytes
assert backup._state == state
expected_info = EncryptionInfo(
encryption_type=GOOGLE_DEFAULT_ENCRYPTION,
encryption_status=Status(_StatusPB(Code.OK, "Status OK")),
kms_key_version="2",
)
assert backup.encryption_info == expected_info
def create(self, cluster_id=None):
"""Creates this backup within its instance.
:type cluster_id: str
:param cluster_id: (Optional) The ID of the Cluster for the newly
created Backup.
:rtype: :class:`~google.api_core.operation.Operation`
:returns: :class:`~google.cloud.bigtable_admin_v2.types._OperationFuture`
instance, to be used to poll the status of the 'create' request
:raises Conflict: if the Backup already exists
:raises NotFound: if the Instance owning the Backup does not exist
:raises BadRequest: if the `table` or `expire_time` values are invalid,
or `expire_time` is not set
"""
if not self._expire_time:
raise ValueError('"expire_time" parameter must be set')
# TODO: Consider implementing a method that sets a default value of
# `expire_time`, e.g. 1 week from the creation of the Backup.
if not self.table_id:
raise ValueError('"table" parameter must be set')
if cluster_id:
self._cluster = cluster_id
if not self._cluster:
raise ValueError('"cluster" parameter must be set')
backup = table.Backup(
source_table=self.source_table,
expire_time=_datetime_to_pb_timestamp(self.expire_time),
)
api = self._instance._client.table_admin_client
return api.create_backup(
request={
"parent": self.parent,
"backup_id": self.backup_id,
"backup": backup,
}
)
