def testPushSubscriptionsCreateNoOutput(self):
sub_refs = [
util.ParseSubscription('subs2', self.Project()),
util.ParseSubscription('subs3', self.Project())
]
topic_ref = util.ParseTopic('topic2', self.Project())
req_subscriptions = [
self.msgs.Subscription(
name=sub_ref.RelativeName(),
topic=topic_ref.RelativeName(),
pushConfig=self.msgs.PushConfig(
pushEndpoint='https://my.appspot.com/push'))
for sub_ref in sub_refs
]
result = self.ExpectCreatedSubscriptions(
('pubsub subscriptions create subs2 subs3 --topic topic2'
' --push-endpoint https://my.appspot.com/push'),
req_subscriptions)
self.assertEqual(2, len(result))
for idx, sub_ref in enumerate(sub_refs):
self.assertEqual(result[idx].ackDeadlineSeconds, 10)
self.assertEqual(result[idx].name, sub_ref.RelativeName())
self.assertEqual(result[idx].topic, topic_ref.RelativeName())
self.assertEqual(result[idx].pushConfig.pushEndpoint,
'https://my.appspot.com/push')
self.AssertOutputEquals('')
self.AssertErrEquals('')
def testPushSubscriptionsCreateWithOutputAndFormat(self):
properties.VALUES.core.user_output_enabled.Set(True)
sub_refs = [
util.ParseSubscription('subs2', self.Project()),
util.ParseSubscription('subs3', self.Project())
]
topic_ref = util.ParseTopic('topic2', self.Project())
req_subscriptions = [
self.msgs.Subscription(
name=sub_ref.RelativeName(),
topic=topic_ref.RelativeName(),
pushConfig=self.msgs.PushConfig(
pushEndpoint='https://my.appspot.com/push'))
for sub_ref in sub_refs
]
self.ExpectCreatedSubscriptions(
('pubsub subscriptions create subs2 subs3 --topic topic2'
' --push-endpoint https://my.appspot.com/push'
' --format=csv[no-heading]'
'(name,pushConfig.pushEndpoint,ackDeadlineSeconds)'),
req_subscriptions)
self.AssertOutputEquals("""\
{},https://my.appspot.com/push,10
{},https://my.appspot.com/push,10
""".format(sub_refs[0].RelativeName(), sub_refs[1].RelativeName()))
self.AssertErrEquals("""\
Created subscription [{}].
Created subscription [{}].
""".format(sub_refs[0].RelativeName(), sub_refs[1].RelativeName()))
def testSubscriptionsCreateAuthenticatedPush(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
topic_ref = util.ParseTopic('topic1', self.Project())
req_subscription = self.msgs.Subscription(
name=sub_ref.RelativeName(),
topic=topic_ref.RelativeName(),
pushConfig=self.msgs.PushConfig(
pushEndpoint='https://example.com/push',
oidcToken=self.msgs.OidcToken(
serviceAccountEmail='*****@*****.**',
audience='my-audience')))
result = self.ExpectCreatedSubscriptions(
'pubsub subscriptions create subs1 --topic topic1 '
'--push-endpoint=https://example.com/push '
'[email protected] '
'--push-auth-token-audience=my-audience', [req_subscription])
self.assertEqual(result[0].name, sub_ref.RelativeName())
self.assertEqual(result[0].topic, topic_ref.RelativeName())
self.assertEqual(result[0].pushConfig.pushEndpoint,
'https://example.com/push')
self.assertEqual(result[0].pushConfig.oidcToken.serviceAccountEmail,
'*****@*****.**')
self.assertEqual(result[0].pushConfig.oidcToken.audience,
'my-audience')
def Run(self, args):
"""This is what gets called when the user runs this command.
Args:
args: an argparse namespace. All the arguments that were provided to this
command invocation.
Returns:
A serialized object (dict) describing the results of the operation. This
description fits the Resource described in the ResourceRegistry under
'pubsub.subscriptions.seek'.
"""
client = subscriptions.SubscriptionsClient()
subscription_ref = util.ParseSubscription(args.subscription)
result = {'subscriptionId': subscription_ref.RelativeName()}
snapshot_ref = None
time = None
if args.snapshot:
snapshot_ref = util.ParseSnapshot(args.snapshot,
args.snapshot_project)
result['snapshotId'] = snapshot_ref.RelativeName()
else:
time = util.FormatSeekTime(args.time)
result['time'] = time
client.Seek(subscription_ref, time=time, snapshot_ref=snapshot_ref)
return result
def testUpdateAll(self):
sub_ref = util.ParseSubscription('sub', self.Project())
new_sub = self.msgs.Subscription(
name=sub_ref.RelativeName(),
ackDeadlineSeconds=100,
pushConfig=self.msgs.PushConfig(
pushEndpoint='https://my.appspot.com/push'),
retainAckedMessages=True,
messageRetentionDuration='259200s',
deadLetterPolicy=self.msgs.DeadLetterPolicy(
deadLetterTopic=util.ParseTopic('topic2',
self.Project()).RelativeName(),
maxDeliveryAttempts=5))
update_req = self.msgs.PubsubProjectsSubscriptionsPatchRequest(
updateSubscriptionRequest=self.msgs.UpdateSubscriptionRequest(
subscription=new_sub,
updateMask=('ackDeadlineSeconds,pushConfig,retainAckedMessages,'
'messageRetentionDuration,deadLetterPolicy')),
name=sub_ref.RelativeName())
self.svc.Expect(
request=update_req, response=self.msgs.Subscription()) # Ignore
self.Run('pubsub subscriptions update sub --ack-deadline 100'
' --push-endpoint https://my.appspot.com/push'
' --retain-acked-messages --message-retention-duration 3d'
' --dead-letter-topic topic2 --max-delivery-attempts 5')
self.AssertErrEquals('Updated subscription [{0}].\n'.format(
sub_ref.RelativeName()))
def testUpdateRemoveRetryPolicy(self):
sub_ref = util.ParseSubscription('sub', self.Project())
new_sub = self.msgs.Subscription(
name=sub_ref.RelativeName(),
ackDeadlineSeconds=100,
pushConfig=self.msgs.PushConfig(
pushEndpoint='https://my.appspot.com/push'),
retainAckedMessages=True,
messageRetentionDuration='259200s',
retryPolicy=None)
update_req = self.msgs.PubsubProjectsSubscriptionsPatchRequest(
updateSubscriptionRequest=self.msgs.UpdateSubscriptionRequest(
subscription=new_sub,
updateMask=('ackDeadlineSeconds,pushConfig,retainAckedMessages,'
'messageRetentionDuration,retryPolicy')),
name=sub_ref.RelativeName())
self.svc.Expect(
request=update_req, response=self.msgs.Subscription()) # Ignore
self.Run('pubsub subscriptions update sub --ack-deadline 100'
' --push-endpoint https://my.appspot.com/push'
' --retain-acked-messages --message-retention-duration 3d'
' --clear-retry-policy')
self.AssertErrEquals('Updated subscription [{0}].\n'.format(
sub_ref.RelativeName()))
def testSubscriptionsPullWithAutoAck(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
exp_received_message = self.msgs.ReceivedMessage(
ackId='000', message=self.messages[0])
exp_received_message.message.messageId = '123456'
self.svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsPullRequest(
pullRequest=self.msgs.PullRequest(
maxMessages=1,
returnImmediately=True),
subscription=sub_ref.RelativeName()),
response=self.msgs.PullResponse(
receivedMessages=[exp_received_message]))
self.ack_svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsAcknowledgeRequest(
acknowledgeRequest=self.msgs.AcknowledgeRequest(
ackIds=['000']),
subscription=sub_ref.RelativeName()),
response='')
self.Run('pubsub subscriptions pull subs1 --auto-ack')
self.AssertOutputContains(
self._GetMessageOutput('Hello, World!', 123456, ''),
normalize_space=True)
def testCreate(self):
sub_ref = util.ParseSubscription('sub1', self.Project())
topic_ref = util.ParseTopic('topic1', self.Project())
labels = self.msgs.Subscription.LabelsValue(additionalProperties=[
self.msgs.Subscription.LabelsValue.AdditionalProperty(
key='label1', value='value1')
])
subscription = self.msgs.Subscription(
name=sub_ref.RelativeName(),
topic=topic_ref.RelativeName(),
ackDeadlineSeconds=20,
enableMessageOrdering=True,
deadLetterPolicy=self.msgs.DeadLetterPolicy(
deadLetterTopic='topic2', maxDeliveryAttempts=5),
retryPolicy=self.msgs.RetryPolicy(minimumBackoff='20s',
maximumBackoff='500s'),
labels=labels)
self.subscriptions_service.Create.Expect(subscription, subscription)
result = self.subscriptions_client.Create(sub_ref,
topic_ref,
20,
labels=labels,
enable_message_ordering=True,
dead_letter_topic='topic2',
max_delivery_attempts=5,
min_retry_delay='20s',
max_retry_delay='500s')
self.assertEqual(result, subscription)
def testDelete(self):
sub_ref = util.ParseSubscription('sub1', self.Project())
self.subscriptions_service.Delete.Expect(
self.msgs.PubsubProjectsSubscriptionsDeleteRequest(
subscription=sub_ref.RelativeName()), self.msgs.Empty())
self.subscriptions_client.Delete(sub_ref)
def testSnapshotsCreateLabels(self):
snap_ref = util.ParseSnapshot('snap1', self.Project())
sub_ref = util.ParseSubscription('subs1', self.Project())
topic_ref = util.ParseTopic('topic1', self.Project())
labels = self.msgs.CreateSnapshotRequest.LabelsValue(additionalProperties=[
self.msgs.CreateSnapshotRequest.LabelsValue.AdditionalProperty(
key='key1', value='value1'),
self.msgs.CreateSnapshotRequest.LabelsValue.AdditionalProperty(
key='key2', value='value2')])
create_req = self.msgs.PubsubProjectsSnapshotsCreateRequest(
createSnapshotRequest=self.msgs.CreateSnapshotRequest(
subscription=sub_ref.RelativeName(),
labels=labels),
name=snap_ref.RelativeName()
)
create_resp = self.msgs.Snapshot(
name=snap_ref.RelativeName(),
topic=topic_ref.RelativeName(),
expireTime='sometime')
self.svc.Expect(request=create_req, response=create_resp)
result = list(self.Run(
'pubsub snapshots create snap1 '
'--labels key1=value1,key2=value2 '
'--subscription subs1'))
self.assertEqual(result[0]['snapshotId'], snap_ref.RelativeName())
self.assertEqual(result[0]['topic'], topic_ref.RelativeName())
self.assertEqual(result[0]['expireTime'], 'sometime')
def testSubscriptionsModifyWithLegacyOutput(self, command, err_msg):
properties.VALUES.pubsub.legacy_output.Set(True)
sub_ref = util.ParseSubscription('subs2', self.Project())
ack_ids = ['123456', '654321']
self.svc.Expect(
request=self.msgs.
PubsubProjectsSubscriptionsModifyAckDeadlineRequest(
modifyAckDeadlineRequest=self.msgs.ModifyAckDeadlineRequest(
ackDeadlineSeconds=600, ackIds=ack_ids),
subscription=sub_ref.RelativeName()),
response='')
self.Run('pubsub subscriptions {} subs2 '
'--ack-ids=123456,654321 --ack-deadline 600'.format(command))
self.AssertOutputEquals('ackDeadlineSeconds: 600\n'
'ackId:\n'
'- \'123456\'\n'
'- \'654321\'\n'
'subscriptionId: {}\n'.format(
sub_ref.RelativeName()))
self.AssertErrContains(
'Set ackDeadlineSeconds to [600] for messages with ackId [{0}]] for '
'subscription [{1}]'.format(','.join(ack_ids),
sub_ref.RelativeName()))
if err_msg:
self.AssertErrContains(err_msg)
def testSubscriptionsPullFullUri(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
exp_received_messages = []
for idx, message in enumerate(self.messages):
message.messageId = self.message_ids[idx]
exp_received_messages.append(self.msgs.ReceivedMessage(
ackId=str(idx),
message=message))
self.svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsPullRequest(
pullRequest=self.msgs.PullRequest(
maxMessages=20,
returnImmediately=True),
subscription=sub_ref.RelativeName()),
response=self.msgs.PullResponse(receivedMessages=exp_received_messages))
self.Run('pubsub subscriptions pull {} --limit 20'
.format(sub_ref.SelfLink()))
self.AssertOutputContains(
self._GetMessageOutput('Hello, World!', 123456, '0'),
normalize_space=True)
self.AssertOutputContains(
self._GetMessageOutput('World on Fire!', 654321, '1'),
normalize_space=True)
def Run(self, args):
"""This is what gets called when the user runs this command.
Args:
args: an argparse namespace. All the arguments that were provided to this
command invocation.
Yields:
A serialized object (dict) describing the results of the operation.
This description fits the Resource described in the ResourceRegistry under
'pubsub.projects.subscriptions'.
Raises:
util.RequestFailedError: if any of the requests to the API failed.
"""
client = subscriptions.SubscriptionsClient()
topic_ref = util.ParseTopic(args.topic, args.topic_project)
push_config = util.ParsePushConfig(args.push_endpoint)
retain_acked_messages = getattr(args, 'retain_acked_messages', None)
retention_duration = getattr(args, 'message_retention_duration', None)
if retention_duration:
retention_duration = util.FormatDuration(retention_duration)
labels = labels_util.UpdateLabels(
None,
client.messages.Subscription.LabelsValue,
update_labels=labels_util.GetUpdateLabelsDictFromArgs(args))
failed = []
for subscription_name in args.subscription:
subscription_ref = util.ParseSubscription(subscription_name)
try:
result = client.Create(subscription_ref,
topic_ref,
args.ack_deadline,
push_config,
retain_acked_messages,
retention_duration,
labels=labels)
except api_ex.HttpError as error:
exc = exceptions.HttpException(error)
log.CreatedResource(subscription_ref.RelativeName(),
kind='subscription',
failed=exc.payload.status_message)
failed.append(subscription_name)
continue
result = util.SubscriptionDisplayDict(result)
log.CreatedResource(subscription_ref.RelativeName(),
kind='subscription')
yield result
if failed:
raise util.RequestsFailedError(failed, 'create')
def testGetIamPolicy(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
self.svc.Expect(
self.msgs.PubsubProjectsSubscriptionsGetIamPolicyRequest(
resource=sub_ref.RelativeName()), self.policy)
result = self.Run('pubsub subscriptions get-iam-policy subs1')
self.assertEqual(result, self.policy)
def testModifyAckDeadline(self):
ack_ids = [str(i) for i in range(3)]
sub_ref = util.ParseSubscription('sub1', self.Project())
self.subscriptions_service.ModifyAckDeadline.Expect(
self.msgs.PubsubProjectsSubscriptionsModifyAckDeadlineRequest(
modifyAckDeadlineRequest=self.msgs.ModifyAckDeadlineRequest(
ackDeadlineSeconds=20, ackIds=ack_ids),
subscription=sub_ref.RelativeName()), self.msgs.Empty())
self.subscriptions_client.ModifyAckDeadline(sub_ref, ack_ids, 20)
def testAck(self):
ack_ids = [str(i) for i in range(3)]
sub_ref = util.ParseSubscription('sub1', self.Project())
self.subscriptions_service.Acknowledge.Expect(
self.msgs.PubsubProjectsSubscriptionsAcknowledgeRequest(
acknowledgeRequest=self.msgs.AcknowledgeRequest(
ackIds=ack_ids),
subscription=sub_ref.RelativeName()), self.msgs.Empty())
self.subscriptions_client.Ack(ack_ids, sub_ref)
def testModifyPushConfig(self):
sub_ref = util.ParseSubscription('sub1', self.Project())
args = MockArgs()
args.push_endpoint = 'endpoint'
push_config = util.ParsePushConfig(args)
self.subscriptions_service.ModifyPushConfig.Expect(
self.msgs.PubsubProjectsSubscriptionsModifyPushConfigRequest(
modifyPushConfigRequest=self.msgs.ModifyPushConfigRequest(
pushConfig=push_config),
subscription=sub_ref.RelativeName()), self.msgs.Empty())
self.subscriptions_client.ModifyPushConfig(sub_ref, push_config)
def Run(self, args):
client = subscriptions.SubscriptionsClient()
messages = client.messages
subscription_ref = util.ParseSubscription(args.subscription)
policy = iam_util.ParsePolicyFile(args.policy_file, messages.Policy)
response = client.SetIamPolicy(subscription_ref, policy=policy)
log.status.Print('Set IAM policy for Subscription [{}].'.format(
subscription_ref.Name()))
return response
def testSubscriptionsAcknowledge(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
subscription = self.msgs.Subscription(name=sub_ref.RelativeName())
self.svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsGetRequest(
subscription=sub_ref.RelativeName()),
response=subscription)
result = self.Run('pubsub subscriptions describe subs1')
self.assertEqual(result, subscription)
def testCreate(self):
snapshot_ref = util.ParseSnapshot('snap1', self.Project())
subscription_ref = util.ParseSubscription('sub1', self.Project())
create_req = self.msgs.PubsubProjectsSnapshotsCreateRequest(
createSnapshotRequest=self.msgs.CreateSnapshotRequest(
subscription=subscription_ref.RelativeName()),
name=snapshot_ref.RelativeName())
snapshot = self.msgs.Snapshot(name=snapshot_ref.RelativeName())
self.snapshots_service.Create.Expect(create_req, snapshot)
result = self.snapshots_client.Create(snapshot_ref, subscription_ref)
self.assertEqual(result, snapshot)
def testSubscriptionsDeleteNoLegacyOutput(self):
properties.VALUES.pubsub.legacy_output.Set(True)
subscription_to_delete = util.ParseSubscription(
'subs1', self.Project()).RelativeName()
self.svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsDeleteRequest(
subscription=subscription_to_delete),
response=self.msgs.Empty())
result = self.Run('pubsub subscriptions delete subs1')
self.assertEqual(result[0], self.msgs.Empty())
def testSubscriptionsDescribeFullUri(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
subscription = self.msgs.Subscription(name=sub_ref.RelativeName())
self.svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsGetRequest(
subscription=sub_ref.RelativeName()),
response=subscription)
result = self.Run('pubsub subscriptions describe {}'.format(
sub_ref.SelfLink()))
self.assertEqual(result, subscription)
def testGetIamPolicy_Filter(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
self.svc.Expect(
self.msgs.PubsubProjectsSubscriptionsGetIamPolicyRequest(
resource=sub_ref.RelativeName()), self.policy)
self.Run('pubsub subscriptions get-iam-policy subs1 '
'--flatten=bindings[].members '
'--filter=bindings.role:roles/owner '
'--format=value(bindings.members)')
self.AssertOutputEquals('user:[email protected]\n')
def testSeekToTime(self, time_flag_value, time_parsed_value):
sub_ref = util.ParseSubscription('sub', self.Project())
seek_req = self.msgs.PubsubProjectsSubscriptionsSeekRequest(
seekRequest=self.msgs.SeekRequest(time=time_parsed_value),
subscription=sub_ref.RelativeName())
self.svc.Expect(request=seek_req, response=self.msgs.SeekResponse())
result = self.Run('pubsub subscriptions seek sub'
' --time ' + time_flag_value)
self.assertEqual(result['subscriptionId'], sub_ref.RelativeName())
self.assertEqual(result['time'], time_parsed_value)
self.assertNotIn('snapshotId', result)
def testSubscriptionsDelete(self):
properties.VALUES.core.user_output_enabled.Set(True)
subscription_to_delete = util.ParseSubscription(
'subs1', self.Project()).RelativeName()
self.svc.Expect(
request=self.msgs.PubsubProjectsSubscriptionsDeleteRequest(
subscription=subscription_to_delete),
response='')
self.Run('pubsub subscriptions delete subs1')
self.AssertErrContains(
'Deleted subscription [{}]'.format(subscription_to_delete))
def testSeekToSnapshot(self):
sub_ref = util.ParseSubscription('sub', self.Project())
snap_ref = util.ParseSnapshot('snap', self.Project())
seek_req = self.msgs.PubsubProjectsSubscriptionsSeekRequest(
seekRequest=self.msgs.SeekRequest(
snapshot=snap_ref.RelativeName()),
subscription=sub_ref.RelativeName())
self.svc.Expect(request=seek_req, response=self.msgs.SeekResponse())
result = self.Run('pubsub subscriptions seek sub --snapshot snap')
self.assertEqual(result['subscriptionId'], sub_ref.RelativeName())
self.assertEqual(result['snapshotId'], snap_ref.RelativeName())
self.assertNotIn('time', result)
def testSubscriptionFormatsProjectsPathsCorrectly(self):
sub_ref = util.ParseSubscription('subs1', self.Project())
topic_ref = util.ParseTopic('topic1', 'my_project')
req_subscription = self.msgs.Subscription(
name=sub_ref.RelativeName(),
ackDeadlineSeconds=180,
topic=topic_ref.RelativeName())
result = self.ExpectCreatedSubscriptions((
'pubsub subscriptions create subs1 --ack-deadline 180 --topic topic1'
' --topic-project my_project'), [req_subscription])
self.assertEqual(result[0].name, sub_ref.RelativeName())
self.assertEqual(result[0].topic, topic_ref.RelativeName())
def testSubscriptionProjectFlags(self):
sub_ref = util.ParseSubscription('subs1', 'proj1')
topic_ref = util.ParseTopic('topic1', 'proj2')
req_subscription = self.msgs.Subscription(
name=sub_ref.RelativeName(),
ackDeadlineSeconds=180,
topic=topic_ref.RelativeName())
result = self.ExpectCreatedSubscriptions((
'pubsub subscriptions create subs1 --ack-deadline 180 --topic topic1'
' --topic-project proj2 --project proj1'), [req_subscription])
self.assertEqual(result[0].name, sub_ref.RelativeName())
self.assertEqual(result[0].topic, topic_ref.RelativeName())
def testPull(self):
sub_ref = util.ParseSubscription('sub1', self.Project())
received_messages = [
self.msgs.ReceivedMessage(ackId=str(i), message=msg)
for i, msg in enumerate(self.messages)
]
self.subscriptions_service.Pull.Expect(
self.msgs.PubsubProjectsSubscriptionsPullRequest(
pullRequest=self.msgs.PullRequest(maxMessages=2,
returnImmediately=True),
subscription=sub_ref.RelativeName()),
self.msgs.PullResponse(receivedMessages=received_messages))
result = self.subscriptions_client.Pull(sub_ref, 2)
self.assertEqual(result.receivedMessages, received_messages)
def testPatch_ClearRetryPolicy(self):
sub_ref = util.ParseSubscription('sub1', self.Project())
args = MockArgs()
args.push_endpoint = 'endpoint'
subscription = self.msgs.Subscription(name=sub_ref.RelativeName(),
retryPolicy=None)
self.subscriptions_service.Patch.Expect(
self.msgs.PubsubProjectsSubscriptionsPatchRequest(
updateSubscriptionRequest=self.msgs.UpdateSubscriptionRequest(
subscription=subscription, updateMask=('retryPolicy')),
name=sub_ref.RelativeName()), subscription)
result = self.subscriptions_client.Patch(sub_ref,
clear_retry_policy=True)
self.assertEqual(result, subscription)
