def test_delete(self):
from google.protobuf import empty_pb2
from google.cloud.bigtable._generated import (bigtable_table_admin_pb2
as table_admin_v2_pb2)
from unit_tests.bigtable._testing import _FakeStub
project_id = 'project-id'
zone = 'zone'
cluster_id = 'cluster-id'
table_id = 'table-id'
column_family_id = 'column-family-id'
table_name = ('projects/' + project_id + '/zones/' + zone +
'/clusters/' + cluster_id + '/tables/' + table_id)
client = _Client()
table = _Table(table_name, client=client)
column_family = self._makeOne(column_family_id, table)
# Create request_pb
request_pb = table_admin_v2_pb2.ModifyColumnFamiliesRequest(
name=table_name)
request_pb.modifications.add(id=column_family_id, drop=True)
# Create response_pb
response_pb = empty_pb2.Empty()
# Patch the stub used by the API method.
client._table_stub = stub = _FakeStub(response_pb)
# Create expected_result.
expected_result = None # delete() has no return value.
# Perform the method and check the result.
self.assertEqual(stub.results, (response_pb, ))
result = column_family.delete()
self.assertEqual(stub.results, ())
self.assertEqual(result, expected_result)
self.assertEqual(stub.method_calls, [(
'ModifyColumnFamilies',
(request_pb, ),
{},
)])
def JoinGroup(self, request, context):
with session_scope() as session:
cluster = session.execute(
select(Cluster).where(~Cluster.is_official_cluster).where(Cluster.id == request.group_id)
).scalar_one_or_none()
if not cluster:
context.abort(grpc.StatusCode.NOT_FOUND, errors.GROUP_NOT_FOUND)
user_in_group = cluster.members.where(User.id == context.user_id).one_or_none()
if user_in_group:
context.abort(grpc.StatusCode.FAILED_PRECONDITION, errors.ALREADY_IN_GROUP)
cluster.cluster_subscriptions.append(
ClusterSubscription(
user_id=context.user_id,
role=ClusterRole.member,
)
)
return empty_pb2.Empty()
def get(self, ip):
with grpc.insecure_channel(target=ip + ":50051",
options=[("grpc.enable_retries", 0),
("grpc.keepalive_timeout_ms",
10000)]) as channel:
grpc_client = nfd_agent_pb2_grpc.NFDRouterAgentStub(channel)
grpc_res = grpc_client.NLSRLsdbList(empty_pb2.Empty())
lsdbs = grpc_res.lsdbs
result = []
if grpc_res.ack.ack_code == 'ok':
result = list(
map(
lambda lsdb: {
"origin_router": lsdb.origin_router,
"prefix": lsdb.prefix
}, lsdbs))
return {"lsdb_list": result}
def test_start_upload(self):
# Setup Expected Response
upload_url = 'uploadUrl-242738639'
expected_response = {'upload_url': upload_url}
expected_response = resources_pb2.UploadRef(**expected_response)
# Mock the API response
channel = ChannelStub(responses=[expected_response])
patch = mock.patch('google.api_core.grpc_helpers.create_channel')
with patch as create_channel:
create_channel.return_value = channel
client = publish_v1.StreetViewPublishServiceClient()
response = client.start_upload()
assert expected_response == response
assert len(channel.requests) == 1
expected_request = empty_pb2.Empty()
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def LeaveGroup(self, request, context):
with session_scope() as session:
cluster = (session.query(Cluster).filter(
~Cluster.is_official_cluster).filter(
Cluster.id == request.group_id).one_or_none())
if not cluster:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.GROUP_NOT_FOUND)
current_membership = cluster.members.filter(
User.id == context.user_id).one_or_none()
if not current_membership:
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.NOT_IN_GROUP)
session.query(ClusterSubscription).filter(
ClusterSubscription.user_id == context.user_id).delete()
return empty_pb2.Empty()
def CompletePasswordReset(self, request, context):
"""
Completes the password reset: just clears the user's password
"""
with session_scope() as session:
res = (
session.query(PasswordResetToken, User)
.join(User, User.id == PasswordResetToken.user_id)
.filter(PasswordResetToken.token == request.password_reset_token)
.filter(PasswordResetToken.is_valid)
.one_or_none()
)
if res:
password_reset_token, user = res
session.delete(password_reset_token)
user.hashed_password = None
session.commit()
return empty_pb2.Empty()
else:
context.abort(grpc.StatusCode.NOT_FOUND, errors.INVALID_TOKEN)
def ModifyAckDeadline(
self,
request: pubsub_pb2.ModifyAckDeadlineRequest,
context: grpc.ServicerContext,
) -> empty_pb2.Empty: # noqa: D403
"""ModifyAckDeadline implementation."""
self.logger.debug("ModifyAckDeadline(%s)", LazyFormat(request))
try:
subscription = self.subscriptions[request.subscription]
except KeyError:
context.abort(grpc.StatusCode.NOT_FOUND, "Subscription not found")
# deadline is not tracked so only handle expiration when set to 0
if request.ack_deadline_seconds == 0:
for ack_id in request.ack_ids:
try:
# move message from pulled back to published
subscription.published.append(subscription.pulled.pop(ack_id))
except KeyError:
context.abort(grpc.StatusCode.NOT_FOUND, "Ack ID not found")
return empty_pb2.Empty()
async def create_organization(request: Request):
new_organization = model.Organization(
name=request.parsed.name,
address=request.parsed.address,
data=dict(**request.parsed.data),
timetable=request.parsed.timetable.SerializeToString(),
)
new_permission = model.Permission(
user_id=request.user.id,
permission_type='OWNER',
)
new_organization.admins.append(new_permission)
request.connection.add(new_organization)
with contextlib.suppress(Exception):
await caches.get('redis').delete(f'user_{request.user.email}', timeout=0.5)
return ProtobufResponse(empty_pb2.Empty())
def MarkLastSeenGroupChat(self, request, context):
with session_scope() as session:
subscription = session.execute(
select(GroupChatSubscription)
.where(GroupChatSubscription.group_chat_id == request.group_chat_id)
.where(GroupChatSubscription.user_id == context.user_id)
.where(GroupChatSubscription.left == None)
).scalar_one_or_none()
if not subscription:
context.abort(grpc.StatusCode.NOT_FOUND, errors.CHAT_NOT_FOUND)
if not subscription.last_seen_message_id <= request.last_seen_message_id:
context.abort(grpc.StatusCode.FAILED_PRECONDITION, errors.CANT_UNSEE_MESSAGES)
subscription.last_seen_message_id = request.last_seen_message_id
# TODO: notify
return empty_pb2.Empty()
def OnTopicEvent(self, request, context):
"""Subscribes events from Pubsub."""
pubsub_topic = request.pubsub_name + DELIMITER + request.topic
if pubsub_topic not in self._topic_map:
context.set_code(grpc.StatusCode.UNIMPLEMENTED) # type: ignore
raise NotImplementedError(
f'topic {request.topic} is not implemented!')
event = v1.Event()
event.SetEventType(request.type)
event.SetEventID(request.id)
event.SetSource(request.source)
event.SetData(request.data)
event.SetContentType(request.data_content_type)
# TODO: add metadata from context to CE envelope
self._topic_map[pubsub_topic](event)
return empty_pb2.Empty()
def test_le_ad_scan_dut_scans(self):
with EventCallbackStream(
# DUT Scans
self.device_under_test.hci_le_scanning_manager.StartScan(
empty_proto.Empty())) as advertising_event_stream:
hci_event_asserts = EventAsserts(advertising_event_stream)
# CERT Advertises
gap_name = hci_packets.GapData()
gap_name.data_type = hci_packets.GapDataType.COMPLETE_LOCAL_NAME
gap_name.data = list(bytes(b'Im_The_CERT!'))
gap_data = le_advertising_facade.GapDataMsg(
data=bytes(gap_name.Serialize()))
config = le_advertising_facade.AdvertisingConfig(
advertisement=[gap_data],
random_address=common.BluetoothAddress(
address=bytes(b'A6:A5:A4:A3:A2:A1')),
interval_min=512,
interval_max=768,
event_type=le_advertising_facade.AdvertisingEventType.ADV_IND,
address_type=common.RANDOM_DEVICE_ADDRESS,
peer_address_type=common.PUBLIC_DEVICE_OR_IDENTITY_ADDRESS,
peer_address=common.BluetoothAddress(
address=bytes(b'0C:05:04:03:02:01')),
channel_map=7,
filter_policy=le_advertising_facade.AdvertisingFilterPolicy.
ALL_DEVICES)
request = le_advertising_facade.CreateAdvertiserRequest(
config=config)
create_response = self.cert_device.hci_le_advertising_manager.CreateAdvertiser(
request)
hci_event_asserts.assert_event_occurs(
lambda packet: b'Im_The_CERT' in packet.event)
remove_request = le_advertising_facade.RemoveAdvertiserRequest(
advertiser_id=create_response.advertiser_id)
self.cert_device.hci_le_advertising_manager.RemoveAdvertiser(
remove_request)
def SendHostRequestMessage(self, request, context):
if request.text == "":
context.abort(grpc.StatusCode.INVALID_ARGUMENT,
errors.INVALID_MESSAGE)
with session_scope() as session:
host_request = (session.query(HostRequest).filter(
HostRequest.conversation_id ==
request.host_request_id).one_or_none())
if not host_request:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.HOST_REQUEST_NOT_FOUND)
if host_request.from_user_id != context.user_id and host_request.to_user_id != context.user_id:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.HOST_REQUEST_NOT_FOUND)
# TODO: It is not very user-friendly to prevent messages for confirmed requests
# but we also don't want people to use requests as normal messages...
if (host_request.status == HostRequestStatus.rejected
or host_request.status == HostRequestStatus.confirmed
or host_request.status == HostRequestStatus.cancelled):
context.abort(grpc.StatusCode.PERMISSION_DENIED,
errors.HOST_REQUEST_CLOSED)
message = Message()
message.conversation_id = host_request.conversation_id
message.author_id = context.user_id
message.message_type = MessageType.text
message.text = request.text
session.add(message)
session.flush()
if host_request.from_user_id == context.user_id:
host_request.from_last_seen_message_id = message.id
else:
host_request.to_last_seen_message_id = message.id
session.commit()
return empty_pb2.Empty()
def RequestJoinPartition(self, request, context):
response = dj_pb.RawDataResponse()
meta_status = self._check_data_source_meta(request.data_source_meta)
if meta_status.code != 0:
response.status.MergeFrom(meta_status)
return response
rank_status = self._check_rank_id(request.rank_id)
if rank_status.code != 0:
response.status.MergeFrom(rank_status)
return response
data_source = self._fsm.get_data_source()
if data_source.state != common_pb.DataSourceState.Processing:
response.status.code = -3
response.status.error_message = \
"data source is not at processing state"
else:
manifest_manager = self._fsm.get_mainifest_manager()
rank_id = request.rank_id
manifest = None
partition_id = None if request.partition_id < 0 \
else request.partition_id
if request.HasField('sync_example_id'):
manifest = manifest_manager.alloc_sync_exampld_id(
rank_id, partition_id
)
elif request.HasField('join_example'):
manifest = manifest_manager.alloc_join_example(
rank_id, partition_id
)
else:
response.status.code = -4
response.status.error_message = "request not support"
if response.status.code == 0:
if manifest is not None:
response.manifest.MergeFrom(manifest)
else:
assert partition_id is None, \
"only the request without appoint partition "\
"support response no manifest"
response.finished.MergeFrom(empty_pb2.Empty())
return response
def peer_list(self):
"""list peer on the chain
return a list of peer nodes currently connected to the target peer.
The returned message structure is defined inside api_pb2.proto
and fabric_pb2.proto.
```
message PeersMessage {
repeated PeerEndpoint peers = 1;
}
message PeerEndpoint {
PeerID ID = 1;
string address = 2;
enum Type {
UNDEFINED = 0;
VALIDATOR = 1;
NON_VALIDATOR = 2;
}
Type type = 3;
bytes pkiID = 4;
}
message PeerID {
string name = 1;
}
```
:param:empty
:return:The peer list on the chain
"""
peer_response = self.peer_stub.GetPeers(
google_dot_protobuf_dot_empty__pb2.Empty())
for peer_message in peer_response.peers:
self.logger.debug(
"peer information:--IDName:{0}--address:{1}--type:{2}\n".
format(peer_message.ID.name, peer_message.address,
peer_message.type))
return peer_response
def call(self, peer_id, email, headers=None):
"""Mocks pRPC environment and calls the interceptor.
Returns:
CapturedState with info about auth context inside the handler.
MockContext as it is after the request finishes.
"""
api.reset_local_state()
headers = (headers or {}).copy()
if email:
headers['Authorization'] = 'Bearer %s' % email
metadata = [(k.lower(), v) for k, v in sorted(headers.items())]
if email != 'BROKEN':
ident = model.Anonymous
if email:
ident = model.Identity(model.IDENTITY_USER, email)
self.mock(api, 'check_oauth_access_token', lambda _: (ident, False))
else:
def raise_exc(_):
raise api.AuthenticationError('OMG, bad token')
self.mock(api, 'check_oauth_access_token', raise_exc)
ctx = MockContext(peer_id, metadata)
call_details = prpclib.HandlerCallDetails('service.Method', metadata)
state = []
def continuation(request, context, call_details):
state.append(CapturedState(
current_identity=api.get_current_identity().to_bytes(),
is_superuser=api.is_superuser(),
peer_identity=api.get_peer_identity().to_bytes(),
peer_ip=api.get_peer_ip(),
delegation_token=api.get_delegation_token(),
))
return empty_pb2.Empty()
prpc.prpc_interceptor(empty_pb2.Empty(), ctx, call_details, continuation)
self.assertTrue(len(state) <= 1)
return state[0] if state else None, ctx
def LeaveCommunity(self, request, context):
with session_scope() as session:
node = session.execute(select(Node).where(Node.id == request.community_id)).scalar_one_or_none()
if not node:
context.abort(grpc.StatusCode.NOT_FOUND, errors.COMMUNITY_NOT_FOUND)
current_membership = node.official_cluster.members.where(User.id == context.user_id).one_or_none()
if not current_membership:
context.abort(grpc.StatusCode.FAILED_PRECONDITION, errors.NOT_IN_COMMUNITY)
if context.user_id in node.contained_user_ids:
context.abort(grpc.StatusCode.FAILED_PRECONDITION, errors.CANNOT_LEAVE_CONTAINING_COMMUNITY)
session.execute(
delete(ClusterSubscription)
.where(ClusterSubscription.cluster_id == node.official_cluster.id)
.where(ClusterSubscription.user_id == context.user_id)
)
return empty_pb2.Empty()
def JoinCommunity(self, request, context):
with session_scope() as session:
node = session.query(Node).filter(
Node.id == request.community_id).one_or_none()
if not node:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.COMMUNITY_NOT_FOUND)
current_membership = node.official_cluster.members.filter(
User.id == context.user_id).one_or_none()
if current_membership:
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.ALREADY_IN_COMMUNITY)
node.official_cluster.cluster_subscriptions.append(
ClusterSubscription(
user_id=context.user_id,
role=ClusterRole.member,
))
return empty_pb2.Empty()
def UploadConfirmation(self, request, context):
with session_scope() as session:
initiated_upload = (session.query(InitiatedUpload).filter(
InitiatedUpload.key == request.key).filter(
InitiatedUpload.is_valid).one_or_none())
if not initiated_upload:
context.abort(grpc.StatusCode.NOT_FOUND, "Upload not found.")
# move it to a completed upload
upload = Upload(
key=request.key,
filename=request.filename,
creator_user_id=initiated_upload.initiator_user_id,
)
session.add(upload)
# delete the old upload
session.delete(initiated_upload)
return empty_pb2.Empty()
def test_local_hci_cmd_and_event(self):
# Loopback mode responds with ACL and SCO connection complete
self.register_for_event(hci_packets.EventCode.CONNECTION_COMPLETE)
self.register_for_event(hci_packets.EventCode.LOOPBACK_COMMAND)
self.register_for_event(
hci_packets.EventCode.CONNECTION_PACKET_TYPE_CHANGED)
with EventCallbackStream(
self.device_under_test.hci.FetchEvents(
empty_proto.Empty())) as hci_event_stream:
hci_event_asserts = EventAsserts(hci_event_stream)
self.enqueue_hci_command(
hci_packets.WriteLoopbackModeBuilder(
hci_packets.LoopbackMode.ENABLE_LOCAL), True)
cmd2loop = hci_packets.ReadLocalNameBuilder()
self.enqueue_hci_command(cmd2loop, True)
looped_bytes = bytes(cmd2loop.Serialize())
hci_event_asserts.assert_event_occurs(
lambda packet: looped_bytes in packet.event)
def test_servicer_persistence(self):
"""Basic test which ensures the servicer state persists."""
headers = self.make_headers(encoding.Encoding.BINARY)
req = test_pb2.GiveRequest(m=3333)
raw_resp = self.app.post(
'/prpc/test.Test/Give',
req.SerializeToString(),
headers,
).body
self.assertEqual(len(raw_resp), 0)
req = empty_pb2.Empty()
raw_resp = self.app.post(
'/prpc/test.Test/Take',
req.SerializeToString(),
headers,
).body
resp = test_pb2.TakeResponse()
test_pb2.TakeResponse.ParseFromString(resp, raw_resp)
self.assertEqual(resp.k, 3333)
def test_write_entries_single(self):
channel, api = self.make_logging_api()
channel.WriteLogEntries.response = empty_pb2.Empty()
entry = {
"logName": self.LOG_PATH,
"resource": {"type": "global"},
"textPayload": "text",
}
api.write_entries([entry])
# Check the request
assert len(channel.WriteLogEntries.requests) == 1
request = channel.WriteLogEntries.requests[0]
assert request.partial_success is False
assert len(request.entries) == 1
assert request.entries[0].log_name == entry["logName"]
assert request.entries[0].resource.type == entry["resource"]["type"]
assert request.entries[0].text_payload == "text"
def Delete(self, request, context):
# Check to see if they already exist:
index = getUsersIndex(request.id)
if index == -1:
context.set_code(grpc.StatusCode.UNKNOWN)
return
if int(USERS[index]['id']) != int(request.id):
context.set_code(grpc.StatusCode.NOT_FOUND)
return
del USERS[index]
user = getUserByID(request.id)
if user:
context.set_code(grpc.StatusCode.UNKNOWN)
return
print("Deleted user {}".format(request.id))
return empty_pb2.Empty()
def setup_test(self):
super().setup_test()
self.dut_address = self.dut.hci_controller.GetMacAddressSimple()
cert_address = common.BluetoothAddress(
address=self.cert.controller_read_only_property.ReadLocalAddress(
empty_proto.Empty()).address)
self.dut_l2cap = PyL2cap(self.dut, cert_address)
self.cert_l2cap = CertL2cap(self.cert)
self.dut_le_l2cap = PyLeL2cap(self.dut)
self.cert_le_l2cap = CertLeL2cap(self.cert)
self.dut_le_address = common.BluetoothAddressWithType(
address=common.BluetoothAddress(
address=bytes(b'D0:05:04:03:02:01')),
type=common.RANDOM_DEVICE_ADDRESS)
self.cert_address = common.BluetoothAddressWithType(
address=common.BluetoothAddress(
address=bytes(b'C0:11:FF:AA:33:22')),
type=common.RANDOM_DEVICE_ADDRESS)
dut_privacy_policy = le_initiator_address_facade.PrivacyPolicy(
address_policy=le_initiator_address_facade.AddressPolicy.
USE_STATIC_ADDRESS,
address_with_type=self.dut_le_address,
rotation_irk=
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
minimum_rotation_time=0,
maximum_rotation_time=0)
self.dut_l2cap._device.hci_le_initiator_address.SetPrivacyPolicyForInitiatorAddress(
dut_privacy_policy)
privacy_policy = le_initiator_address_facade.PrivacyPolicy(
address_policy=le_initiator_address_facade.AddressPolicy.
USE_STATIC_ADDRESS,
address_with_type=self.cert_address,
rotation_irk=
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
minimum_rotation_time=0,
maximum_rotation_time=0)
self.cert_le_l2cap._device.hci_le_initiator_address.SetPrivacyPolicyForInitiatorAddress(
privacy_policy)
def MakeGroupChatAdmin(self, request, context):
with session_scope(self._Session) as session:
your_subscription = (session.query(GroupChatSubscription).filter(
GroupChatSubscription.group_chat_id == request.group_chat_id
).filter(GroupChatSubscription.user_id == context.user_id).filter(
GroupChatSubscription.left == None).one_or_none())
if not your_subscription:
context.abort(grpc.StatusCode.NOT_FOUND, errors.CHAT_NOT_FOUND)
if your_subscription.role != GroupChatRole.admin:
context.abort(grpc.StatusCode.PERMISSION_DENIED,
errors.ONLY_ADMIN_CAN_MAKE_ADMIN)
if request.user_id == context.user_id:
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.CANT_MAKE_SELF_ADMIN)
their_subscription = (session.query(GroupChatSubscription).filter(
GroupChatSubscription.group_chat_id == request.group_chat_id
).filter(GroupChatSubscription.user_id == request.user_id).filter(
GroupChatSubscription.left == None).one_or_none())
if not their_subscription:
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.USER_NOT_IN_CHAT)
if their_subscription.role != GroupChatRole.participant:
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.ALREADY_ADMIN)
their_subscription.role = GroupChatRole.admin
_add_message_to_subscription(
session,
your_subscription,
message_type=MessageType.user_made_admin,
target_id=request.user_id)
return empty_pb2.Empty()
def SendFriendRequest(self, request, context):
if context.user_id == request.user_id:
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.CANT_FRIEND_SELF)
with session_scope() as session:
user = session.query(User).filter(User.id == context.user_id).one()
to_user = session.query(User).filter(
User.id == request.user_id).one_or_none()
if not to_user:
context.abort(grpc.StatusCode.NOT_FOUND, errors.USER_NOT_FOUND)
if (session.query(FriendRelationship).filter(
or_(
and_(
FriendRelationship.from_user_id == context.user_id,
FriendRelationship.to_user_id == request.user_id,
),
and_(
FriendRelationship.from_user_id == request.user_id,
FriendRelationship.to_user_id == context.user_id,
),
)).filter(
or_(
FriendRelationship.status == FriendStatus.accepted,
FriendRelationship.status == FriendStatus.pending,
)).one_or_none() is not None):
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.FRIENDS_ALREADY_OR_PENDING)
# TODO: Race condition where we can create two friend reqs, needs db constraint! See comment in table
friend_relationship = FriendRelationship(
from_user=user, to_user=to_user, status=FriendStatus.pending)
session.add(friend_relationship)
send_friend_request_email(friend_relationship)
return empty_pb2.Empty()
def SendHostRequestMessage(self, request, context):
if request.text == "":
context.abort(grpc.StatusCode.INVALID_ARGUMENT,
errors.INVALID_MESSAGE)
with session_scope() as session:
host_request = (session.query(HostRequest).filter(
HostRequest.conversation_id ==
request.host_request_id).one_or_none())
if not host_request:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.HOST_REQUEST_NOT_FOUND)
if host_request.from_user_id != context.user_id and host_request.to_user_id != context.user_id:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.HOST_REQUEST_NOT_FOUND)
if host_request.status == HostRequestStatus.rejected or host_request.status == HostRequestStatus.cancelled:
context.abort(grpc.StatusCode.PERMISSION_DENIED,
errors.HOST_REQUEST_CLOSED)
if host_request.end_time < now():
context.abort(grpc.StatusCode.INVALID_ARGUMENT,
errors.HOST_REQUEST_IN_PAST)
message = Message()
message.conversation_id = host_request.conversation_id
message.author_id = context.user_id
message.message_type = MessageType.text
message.text = request.text
session.add(message)
session.flush()
if host_request.from_user_id == context.user_id:
host_request.from_last_seen_message_id = message.id
else:
host_request.to_last_seen_message_id = message.id
session.commit()
return empty_pb2.Empty()
def test_delete(self):
from google.protobuf import empty_pb2
from gcloud.bigtable._generated import (
bigtable_table_service_messages_pb2 as messages_pb2)
from gcloud.bigtable._testing import _FakeStub
project_id = 'project-id'
zone = 'zone'
cluster_id = 'cluster-id'
table_id = 'table-id'
timeout_seconds = 871
cluster_name = ('projects/' + project_id + '/zones/' + zone +
'/clusters/' + cluster_id)
client = _Client(timeout_seconds=timeout_seconds)
cluster = _Cluster(cluster_name, client=client)
table = self._makeOne(table_id, cluster)
# Create request_pb
table_name = cluster_name + '/tables/' + table_id
request_pb = messages_pb2.DeleteTableRequest(name=table_name)
# Create response_pb
response_pb = empty_pb2.Empty()
# Patch the stub used by the API method.
client._table_stub = stub = _FakeStub(response_pb)
# Create expected_result.
expected_result = None # delete() has no return value.
# Perform the method and check the result.
result = table.delete()
self.assertEqual(result, expected_result)
self.assertEqual(stub.method_calls, [(
'DeleteTable',
(request_pb, timeout_seconds),
{},
)])
def LeaveGroupChat(self, request, context):
with session_scope(self._Session) as session:
subscription = (session.query(GroupChatSubscription).filter(
GroupChatSubscription.group_chat_id == request.group_chat_id
).filter(GroupChatSubscription.user_id == context.user_id).filter(
GroupChatSubscription.left == None).one_or_none())
if not subscription:
context.abort(grpc.StatusCode.NOT_FOUND, errors.CHAT_NOT_FOUND)
if subscription.role == GroupChatRole.admin:
other_admins_count = (session.query(
GroupChatSubscription.id).filter(
GroupChatSubscription.group_chat_id ==
request.group_chat_id).filter(
GroupChatSubscription.user_id != context.user_id
).filter(
GroupChatSubscription.role == GroupChatRole.admin
).filter(GroupChatSubscription.left == None).count())
participants_count = (session.query(
GroupChatSubscription.id).filter(
GroupChatSubscription.group_chat_id ==
request.group_chat_id).filter(
GroupChatSubscription.user_id != context.user_id
).filter(
GroupChatSubscription.role ==
GroupChatRole.participant).filter(
GroupChatSubscription.left == None).count())
if not (other_admins_count > 0 or participants_count == 0):
context.abort(grpc.StatusCode.FAILED_PRECONDITION,
errors.LAST_ADMIN_CANT_LEAVE)
_add_message_to_subscription(session,
subscription,
message_type=MessageType.user_left)
subscription.left = func.now()
return empty_pb2.Empty()
def DeletePhoto(self, request, context):
"""Deletes a photo.
gRPC calls this method when clients call the DeletePhoto rpc (method).
Arguments:
request (DeletePhotoRequest): The incoming request.
context: The gRPC connection context.
Returns:
an Empty gRPC message.
"""
name = request.name
try:
model.delete_photo(name)
except ValueError:
return error_handler.throw_exception(
grpc_context=context,
code=grpc.StatusCode.NOT_FOUND,
details='NOT_FOUND: Cannot find specified photo.')
return empty_pb2.Empty()
def _make_transaction(txn_id, **txn_kwargs):
from google.protobuf import empty_pb2
from google.cloud.firestore_v1.types import firestore
from google.cloud.firestore_v1.types import write
from google.cloud.firestore_v1.async_transaction import AsyncTransaction
# Create a fake GAPIC ...
firestore_api = AsyncMock()
# ... with a dummy ``BeginTransactionResponse`` result ...
begin_response = firestore.BeginTransactionResponse(transaction=txn_id)
firestore_api.begin_transaction.return_value = begin_response
# ... and a dummy ``Rollback`` result ...
firestore_api.rollback.return_value = empty_pb2.Empty()
# ... and a dummy ``Commit`` result.
commit_response = firestore.CommitResponse(write_results=[write.WriteResult()])
firestore_api.commit.return_value = commit_response
# Attach the fake GAPIC to a real client.
client = _make_client()
client._firestore_api_internal = firestore_api
return AsyncTransaction(client, **txn_kwargs)
